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 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 940 {
 941         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 942         return NDR_ERR_SUCCESS;
 943 }
 944
 945 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 946 {
 947         uint32_t v;
 948         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 949         *r = v;
 950         return NDR_ERR_SUCCESS;
 951 }
 952
 953 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 954 {
 955         ndr_print_uint32(ndr, name, r);
 956         ndr->depth++;
 957         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE", DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE, r);
 958         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP", DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP, r);
 959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS", DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS, r);
 960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_USE_ASYNC_INTERSIDE_TRANSPORT", DRSUAPI_DS_REPLICA_NEIGHBOUR_USE_ASYNC_INTERSIDE_TRANSPORT, r);
 961         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP", DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP, r);
 962         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_ERROR", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_ERROR, r);
 963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC, r);
 964         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY", DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY, r);
 965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS", DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS, r);
 966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS, r);
 967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET, r);
 968         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED", DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED, r);
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING", DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED", DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES", DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS, r);
 975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET, r);
 976         ndr->depth--;
 977 }
 978
 979 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 980 {
 981         {
 982                 uint32_t _flags_save_ENUM = ndr->flags;
 983                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 984                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 985                 ndr->flags = _flags_save_ENUM;
 986         }
 987         return NDR_ERR_SUCCESS;
 988 }
 989
 990 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 991 {
 992         uint32_t v;
 993         {
 994                 uint32_t _flags_save_ENUM = ndr->flags;
 995                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 996                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 997                 *r = v;
 998                 ndr->flags = _flags_save_ENUM;
 999         }
1000         return NDR_ERR_SUCCESS;
1001 }
1002
1003 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
1004 {
1005         const char *val = NULL;
1006
1007         {
1008                 uint32_t _flags_save_ENUM = ndr->flags;
1009                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1010                 switch (r) {
1011                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
1012                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
1013                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
1014                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
1015                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
1016                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
1017                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
1018                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
1019                 }
1020                 ndr_print_enum(ndr, name, "ENUM", val, r);
1021                 ndr->flags = _flags_save_ENUM;
1022         }
1023 }
1024
1025 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
1026 {
1027         {
1028                 uint32_t _flags_save_ENUM = ndr->flags;
1029                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1030                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1031                 ndr->flags = _flags_save_ENUM;
1032         }
1033         return NDR_ERR_SUCCESS;
1034 }
1035
1036 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
1037 {
1038         uint32_t v;
1039         {
1040                 uint32_t _flags_save_ENUM = ndr->flags;
1041                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1042                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1043                 *r = v;
1044                 ndr->flags = _flags_save_ENUM;
1045         }
1046         return NDR_ERR_SUCCESS;
1047 }
1048
1049 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
1050 {
1051         const char *val = NULL;
1052
1053         {
1054                 uint32_t _flags_save_ENUM = ndr->flags;
1055                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1056                 switch (r) {
1057                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
1058                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
1059                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
1060                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
1061                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
1062                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
1063                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
1064                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
1065                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
1066                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
1067                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
1068                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
1069                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
1070                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
1071                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
1072                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
1073                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
1074                 }
1075                 ndr_print_enum(ndr, name, "ENUM", val, r);
1076                 ndr->flags = _flags_save_ENUM;
1077         }
1078 }
1079
1080 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
1081 {
1082         if (ndr_flags & NDR_SCALARS) {
1083                 NDR_CHECK(ndr_push_align(ndr, 8));
1084                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1085                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1086                 if (r->naming_context == NULL) {
1087                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1088                 }
1089                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1090                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1092                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1095                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1096                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1097                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1098         }
1099         if (ndr_flags & NDR_BUFFERS) {
1100                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1101                 if (r->uptodateness_vector) {
1102                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1103                 }
1104         }
1105         return NDR_ERR_SUCCESS;
1106 }
1107
1108 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1109 {
1110         uint32_t _ptr_naming_context;
1111         TALLOC_CTX *_mem_save_naming_context_0;
1112         uint32_t _ptr_uptodateness_vector;
1113         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1114         if (ndr_flags & NDR_SCALARS) {
1115                 NDR_CHECK(ndr_pull_align(ndr, 8));
1116                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1117                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1118                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1119                 if (_ptr_naming_context) {
1120                         NDR_PULL_ALLOC(ndr, r->naming_context);
1121                 } else {
1122                         r->naming_context = NULL;
1123                 }
1124                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1126                 if (_ptr_uptodateness_vector) {
1127                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1128                 } else {
1129                         r->uptodateness_vector = NULL;
1130                 }
1131                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1134                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1135                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1136                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1137         }
1138         if (ndr_flags & NDR_BUFFERS) {
1139                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1140                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1141                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1143                 if (r->uptodateness_vector) {
1144                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1145                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1146                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1148                 }
1149         }
1150         return NDR_ERR_SUCCESS;
1151 }
1152
1153 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1154 {
1155         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1156         ndr->depth++;
1157         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1158         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1159         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1160         ndr->depth++;
1161         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1162         ndr->depth--;
1163         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1164         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1165         ndr->depth++;
1166         if (r->uptodateness_vector) {
1167                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1168         }
1169         ndr->depth--;
1170         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1171         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1172         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1173         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1174         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1175         ndr->depth--;
1176 }
1177
1178 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
1179 {
1180         if (ndr_flags & NDR_SCALARS) {
1181                 NDR_CHECK(ndr_push_align(ndr, 5));
1182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
1183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary_oid));
1184                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1185         }
1186         if (ndr_flags & NDR_BUFFERS) {
1187                 if (r->binary_oid) {
1188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
1189                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1190                 }
1191         }
1192         return NDR_ERR_SUCCESS;
1193 }
1194
1195 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
1196 {
1197         uint32_t _ptr_binary_oid;
1198         TALLOC_CTX *_mem_save_binary_oid_0;
1199         if (ndr_flags & NDR_SCALARS) {
1200                 NDR_CHECK(ndr_pull_align(ndr, 5));
1201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
1202                 if (r->length > 10000) {
1203                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1204                 }
1205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_oid));
1206                 if (_ptr_binary_oid) {
1207                         NDR_PULL_ALLOC(ndr, r->binary_oid);
1208                 } else {
1209                         r->binary_oid = NULL;
1210                 }
1211                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1212         }
1213         if (ndr_flags & NDR_BUFFERS) {
1214                 if (r->binary_oid) {
1215                         _mem_save_binary_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1216                         NDR_PULL_SET_MEM_CTX(ndr, r->binary_oid, 0);
1217                         NDR_CHECK(ndr_pull_array_size(ndr, &r->binary_oid));
1218                         NDR_PULL_ALLOC_N(ndr, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid));
1219                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid)));
1220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_oid_0, 0);
1221                 }
1222                 if (r->binary_oid) {
1223                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->binary_oid, r->length));
1224                 }
1225         }
1226         return NDR_ERR_SUCCESS;
1227 }
1228
1229 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1230 {
1231         if (ndr_flags & NDR_SCALARS) {
1232                 NDR_CHECK(ndr_push_align(ndr, 5));
1233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1234                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1235                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1236         }
1237         if (ndr_flags & NDR_BUFFERS) {
1238                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1239         }
1240         return NDR_ERR_SUCCESS;
1241 }
1242
1243 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1244 {
1245         if (ndr_flags & NDR_SCALARS) {
1246                 NDR_CHECK(ndr_pull_align(ndr, 5));
1247                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1248                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1249                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1250         }
1251         if (ndr_flags & NDR_BUFFERS) {
1252                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1253         }
1254         return NDR_ERR_SUCCESS;
1255 }
1256
1257 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1258 {
1259         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1260         ndr->depth++;
1261         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1262         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1263         ndr->depth--;
1264 }
1265
1266 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1267 {
1268         uint32_t cntr_mappings_1;
1269         if (ndr_flags & NDR_SCALARS) {
1270                 NDR_CHECK(ndr_push_align(ndr, 5));
1271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1272                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1273                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1274         }
1275         if (ndr_flags & NDR_BUFFERS) {
1276                 if (r->mappings) {
1277                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
1278                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1279                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1280                         }
1281                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1282                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1283                         }
1284                 }
1285         }
1286         return NDR_ERR_SUCCESS;
1287 }
1288
1289 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1290 {
1291         uint32_t _ptr_mappings;
1292         uint32_t cntr_mappings_1;
1293         TALLOC_CTX *_mem_save_mappings_0;
1294         TALLOC_CTX *_mem_save_mappings_1;
1295         if (ndr_flags & NDR_SCALARS) {
1296                 NDR_CHECK(ndr_pull_align(ndr, 5));
1297                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1298                 if (r->num_mappings > 0x100000) {
1299                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1300                 }
1301                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1302                 if (_ptr_mappings) {
1303                         NDR_PULL_ALLOC(ndr, r->mappings);
1304                 } else {
1305                         r->mappings = NULL;
1306                 }
1307                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1308         }
1309         if (ndr_flags & NDR_BUFFERS) {
1310                 if (r->mappings) {
1311                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1312                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1313                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1314                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1315                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1316                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1317                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1318                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1319                         }
1320                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1321                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1322                         }
1323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1325                 }
1326                 if (r->mappings) {
1327                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1328                 }
1329         }
1330         return NDR_ERR_SUCCESS;
1331 }
1332
1333 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1334 {
1335         uint32_t cntr_mappings_1;
1336         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1337         ndr->depth++;
1338         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1339         ndr_print_ptr(ndr, "mappings", r->mappings);
1340         ndr->depth++;
1341         if (r->mappings) {
1342                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1343                 ndr->depth++;
1344                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1345                         char *idx_1=NULL;
1346                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1347                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1348                                 free(idx_1);
1349                         }
1350                 }
1351                 ndr->depth--;
1352         }
1353         ndr->depth--;
1354         ndr->depth--;
1355 }
1356
1357 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1358 {
1359         {
1360                 uint32_t _flags_save_ENUM = ndr->flags;
1361                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1362                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1363                 ndr->flags = _flags_save_ENUM;
1364         }
1365         return NDR_ERR_SUCCESS;
1366 }
1367
1368 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1369 {
1370         uint32_t v;
1371         {
1372                 uint32_t _flags_save_ENUM = ndr->flags;
1373                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1374                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1375                 *r = v;
1376                 ndr->flags = _flags_save_ENUM;
1377         }
1378         return NDR_ERR_SUCCESS;
1379 }
1380
1381 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1382 {
1383         const char *val = NULL;
1384
1385         {
1386                 uint32_t _flags_save_ENUM = ndr->flags;
1387                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1388                 switch (r) {
1389                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1390                         case DRSUAPI_ATTRIBUTE_cn: val = "DRSUAPI_ATTRIBUTE_cn"; break;
1391                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1392                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1393                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1394                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1395                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1396                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1397                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1398                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1399                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1400                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1401                         case DRSUAPI_ATTRIBUTE_rDNAttId: val = "DRSUAPI_ATTRIBUTE_rDNAttId"; break;
1402                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1403                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1404                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1405                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1406                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1407                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1408                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1409                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1410                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1411                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1412                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1413                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1414                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1415                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1416                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1417                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1418                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1419                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1420                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1421                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1422                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1423                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1424                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1425                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1426                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1427                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1428                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1429                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1430                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1431                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1432                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1433                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1434                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1435                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1436                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1437                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1438                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1439                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1440                         case DRSUAPI_ATTRIBUTE_systemAuxiliaryClass: val = "DRSUAPI_ATTRIBUTE_systemAuxiliaryClass"; break;
1441                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1442                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1443                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1444                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1445                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1446                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1447                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1448                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1449                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1450                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1451                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1452                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1453                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1454                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1455                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1456                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1457                         case DRSUAPI_ATTRIBUTE_transportAddressAttribute: val = "DRSUAPI_ATTRIBUTE_transportAddressAttribute"; break;
1458                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1459                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1460                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1461                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1462                         case DRSUAPI_ATTRIBUTE_NONE: val = "DRSUAPI_ATTRIBUTE_NONE"; break;
1463                 }
1464                 ndr_print_enum(ndr, name, "ENUM", val, r);
1465                 ndr->flags = _flags_save_ENUM;
1466         }
1467 }
1468
1469 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1470 {
1471         uint32_t cntr_attids_0;
1472         if (ndr_flags & NDR_SCALARS) {
1473                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1474                 NDR_CHECK(ndr_push_align(ndr, 4));
1475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1478                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1479                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1480                 }
1481                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1482         }
1483         if (ndr_flags & NDR_BUFFERS) {
1484         }
1485         return NDR_ERR_SUCCESS;
1486 }
1487
1488 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1489 {
1490         uint32_t cntr_attids_0;
1491         TALLOC_CTX *_mem_save_attids_0;
1492         if (ndr_flags & NDR_SCALARS) {
1493                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1494                 NDR_CHECK(ndr_pull_align(ndr, 4));
1495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1498                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1499                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1500                 }
1501                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1502                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1503                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1504                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1505                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1506                 }
1507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1508                 if (r->attids) {
1509                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1510                 }
1511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1512         }
1513         if (ndr_flags & NDR_BUFFERS) {
1514         }
1515         return NDR_ERR_SUCCESS;
1516 }
1517
1518 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1519 {
1520         uint32_t cntr_attids_0;
1521         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1522         ndr->depth++;
1523         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1524         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1525         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1526         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1527         ndr->depth++;
1528         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1529                 char *idx_0=NULL;
1530                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1531                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1532                         free(idx_0);
1533                 }
1534         }
1535         ndr->depth--;
1536         ndr->depth--;
1537 }
1538
1539 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1540 {
1541         if (ndr_flags & NDR_SCALARS) {
1542                 NDR_CHECK(ndr_push_align(ndr, 8));
1543                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1544                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1545                 if (r->naming_context == NULL) {
1546                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1547                 }
1548                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1549                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1550                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1551                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1554                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1555                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1557                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1558                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1559                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1560         }
1561         if (ndr_flags & NDR_BUFFERS) {
1562                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1563                 if (r->uptodateness_vector) {
1564                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1565                 }
1566                 if (r->partial_attribute_set) {
1567                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1568                 }
1569                 if (r->partial_attribute_set_ex) {
1570                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1571                 }
1572                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1573         }
1574         return NDR_ERR_SUCCESS;
1575 }
1576
1577 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1578 {
1579         uint32_t _ptr_naming_context;
1580         TALLOC_CTX *_mem_save_naming_context_0;
1581         uint32_t _ptr_uptodateness_vector;
1582         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1583         uint32_t _ptr_partial_attribute_set;
1584         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1585         uint32_t _ptr_partial_attribute_set_ex;
1586         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1587         if (ndr_flags & NDR_SCALARS) {
1588                 NDR_CHECK(ndr_pull_align(ndr, 8));
1589                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1590                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1591                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1592                 if (_ptr_naming_context) {
1593                         NDR_PULL_ALLOC(ndr, r->naming_context);
1594                 } else {
1595                         r->naming_context = NULL;
1596                 }
1597                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1598                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1599                 if (_ptr_uptodateness_vector) {
1600                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1601                 } else {
1602                         r->uptodateness_vector = NULL;
1603                 }
1604                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1607                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1608                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1609                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1610                 if (_ptr_partial_attribute_set) {
1611                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1612                 } else {
1613                         r->partial_attribute_set = NULL;
1614                 }
1615                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1616                 if (_ptr_partial_attribute_set_ex) {
1617                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1618                 } else {
1619                         r->partial_attribute_set_ex = NULL;
1620                 }
1621                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1623         }
1624         if (ndr_flags & NDR_BUFFERS) {
1625                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1626                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1627                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1629                 if (r->uptodateness_vector) {
1630                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1631                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1632                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1634                 }
1635                 if (r->partial_attribute_set) {
1636                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1637                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1638                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1640                 }
1641                 if (r->partial_attribute_set_ex) {
1642                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1643                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1644                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1646                 }
1647                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1648         }
1649         return NDR_ERR_SUCCESS;
1650 }
1651
1652 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1653 {
1654         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1655         ndr->depth++;
1656         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1657         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1658         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1659         ndr->depth++;
1660         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1661         ndr->depth--;
1662         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1663         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1664         ndr->depth++;
1665         if (r->uptodateness_vector) {
1666                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1667         }
1668         ndr->depth--;
1669         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1670         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1671         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1672         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1673         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1674         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1675         ndr->depth++;
1676         if (r->partial_attribute_set) {
1677                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1678         }
1679         ndr->depth--;
1680         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1681         ndr->depth++;
1682         if (r->partial_attribute_set_ex) {
1683                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1684         }
1685         ndr->depth--;
1686         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1687         ndr->depth--;
1688 }
1689
1690 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1691 {
1692         if (ndr_flags & NDR_SCALARS) {
1693                 NDR_CHECK(ndr_push_align(ndr, 8));
1694                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1695                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1696                 if (r->naming_context == NULL) {
1697                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1698                 }
1699                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1700                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1702                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1705                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1706                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1709                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1711                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1712         }
1713         if (ndr_flags & NDR_BUFFERS) {
1714                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1715                 if (r->uptodateness_vector) {
1716                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1717                 }
1718                 if (r->partial_attribute_set) {
1719                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1720                 }
1721                 if (r->partial_attribute_set_ex) {
1722                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1723                 }
1724                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1725         }
1726         return NDR_ERR_SUCCESS;
1727 }
1728
1729 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1730 {
1731         uint32_t _ptr_naming_context;
1732         TALLOC_CTX *_mem_save_naming_context_0;
1733         uint32_t _ptr_uptodateness_vector;
1734         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1735         uint32_t _ptr_partial_attribute_set;
1736         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1737         uint32_t _ptr_partial_attribute_set_ex;
1738         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1739         if (ndr_flags & NDR_SCALARS) {
1740                 NDR_CHECK(ndr_pull_align(ndr, 8));
1741                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1742                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1743                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1744                 if (_ptr_naming_context) {
1745                         NDR_PULL_ALLOC(ndr, r->naming_context);
1746                 } else {
1747                         r->naming_context = NULL;
1748                 }
1749                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1751                 if (_ptr_uptodateness_vector) {
1752                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1753                 } else {
1754                         r->uptodateness_vector = NULL;
1755                 }
1756                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1758                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1759                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1760                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1762                 if (_ptr_partial_attribute_set) {
1763                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1764                 } else {
1765                         r->partial_attribute_set = NULL;
1766                 }
1767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1768                 if (_ptr_partial_attribute_set_ex) {
1769                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1770                 } else {
1771                         r->partial_attribute_set_ex = NULL;
1772                 }
1773                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1775                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1776         }
1777         if (ndr_flags & NDR_BUFFERS) {
1778                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1779                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1780                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1782                 if (r->uptodateness_vector) {
1783                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1784                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1785                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1787                 }
1788                 if (r->partial_attribute_set) {
1789                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1790                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1791                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1793                 }
1794                 if (r->partial_attribute_set_ex) {
1795                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1796                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1797                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1799                 }
1800                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1801         }
1802         return NDR_ERR_SUCCESS;
1803 }
1804
1805 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1806 {
1807         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1808         ndr->depth++;
1809         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1810         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1811         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1812         ndr->depth++;
1813         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1814         ndr->depth--;
1815         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1816         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1817         ndr->depth++;
1818         if (r->uptodateness_vector) {
1819                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1820         }
1821         ndr->depth--;
1822         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1823         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1824         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1825         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1826         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1827         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1828         ndr->depth++;
1829         if (r->partial_attribute_set) {
1830                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1831         }
1832         ndr->depth--;
1833         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1834         ndr->depth++;
1835         if (r->partial_attribute_set_ex) {
1836                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1837         }
1838         ndr->depth--;
1839         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1840         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1841         ndr->depth--;
1842 }
1843
1844 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1845 {
1846         if (ndr_flags & NDR_SCALARS) {
1847                 int level = ndr_push_get_switch_value(ndr, r);
1848                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1849                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1850                 switch (level) {
1851                         case 5: {
1852                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1853                         break; }
1854
1855                         case 8: {
1856                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1857                         break; }
1858
1859                         case 10: {
1860                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1861                         break; }
1862
1863                         default:
1864                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1865                 }
1866         }
1867         if (ndr_flags & NDR_BUFFERS) {
1868                 int level = ndr_push_get_switch_value(ndr, r);
1869                 switch (level) {
1870                         case 5:
1871                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1872                         break;
1873
1874                         case 8:
1875                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1876                         break;
1877
1878                         case 10:
1879                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1880                         break;
1881
1882                         default:
1883                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1884                 }
1885         }
1886         return NDR_ERR_SUCCESS;
1887 }
1888
1889 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1890 {
1891         int level;
1892         int32_t _level;
1893         level = ndr_pull_get_switch_value(ndr, r);
1894         if (ndr_flags & NDR_SCALARS) {
1895                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1896                 if (_level != level) {
1897                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1898                 }
1899                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1900                 switch (level) {
1901                         case 5: {
1902                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1903                         break; }
1904
1905                         case 8: {
1906                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1907                         break; }
1908
1909                         case 10: {
1910                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1911                         break; }
1912
1913                         default:
1914                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1915                 }
1916         }
1917         if (ndr_flags & NDR_BUFFERS) {
1918                 switch (level) {
1919                         case 5:
1920                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1921                         break;
1922
1923                         case 8:
1924                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1925                         break;
1926
1927                         case 10:
1928                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1929                         break;
1930
1931                         default:
1932                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1933                 }
1934         }
1935         return NDR_ERR_SUCCESS;
1936 }
1937
1938 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1939 {
1940         int level;
1941         level = ndr_print_get_switch_value(ndr, r);
1942         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1943         switch (level) {
1944                 case 5:
1945                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1946                 break;
1947
1948                 case 8:
1949                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1950                 break;
1951
1952                 case 10:
1953                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1954                 break;
1955
1956                 default:
1957                         ndr_print_bad_level(ndr, name, level);
1958         }
1959 }
1960
1961 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1962 {
1963         if (ndr_flags & NDR_SCALARS) {
1964                 NDR_CHECK(ndr_push_align(ndr, 8));
1965                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1966                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1967                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1968                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1969         }
1970         if (ndr_flags & NDR_BUFFERS) {
1971         }
1972         return NDR_ERR_SUCCESS;
1973 }
1974
1975 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1976 {
1977         if (ndr_flags & NDR_SCALARS) {
1978                 NDR_CHECK(ndr_pull_align(ndr, 8));
1979                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1980                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1981                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1982                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1983         }
1984         if (ndr_flags & NDR_BUFFERS) {
1985         }
1986         return NDR_ERR_SUCCESS;
1987 }
1988
1989 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1990 {
1991         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1992         ndr->depth++;
1993         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1994         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1995         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1996         ndr->depth--;
1997 }
1998
1999 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
2000 {
2001         uint32_t cntr_cursors_0;
2002         if (ndr_flags & NDR_SCALARS) {
2003                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2004                 NDR_CHECK(ndr_push_align(ndr, 8));
2005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
2006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2009                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
2010                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
2011                 }
2012                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2013         }
2014         if (ndr_flags & NDR_BUFFERS) {
2015         }
2016         return NDR_ERR_SUCCESS;
2017 }
2018
2019 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
2020 {
2021         uint32_t cntr_cursors_0;
2022         TALLOC_CTX *_mem_save_cursors_0;
2023         if (ndr_flags & NDR_SCALARS) {
2024                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
2025                 NDR_CHECK(ndr_pull_align(ndr, 8));
2026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
2028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2029                 if (r->count > 0x100000) {
2030                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2031                 }
2032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
2033                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
2034                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
2035                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
2036                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
2037                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
2038                 }
2039                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
2040                 if (r->cursors) {
2041                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
2042                 }
2043                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2044         }
2045         if (ndr_flags & NDR_BUFFERS) {
2046         }
2047         return NDR_ERR_SUCCESS;
2048 }
2049
2050 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
2051 {
2052         uint32_t cntr_cursors_0;
2053         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
2054         ndr->depth++;
2055         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
2056         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2057         ndr_print_uint32(ndr, "count", r->count);
2058         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2059         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
2060         ndr->depth++;
2061         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
2062                 char *idx_0=NULL;
2063                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
2064                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
2065                         free(idx_0);
2066                 }
2067         }
2068         ndr->depth--;
2069         ndr->depth--;
2070 }
2071
2072 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
2073 {
2074         if (ndr_flags & NDR_SCALARS) {
2075                 NDR_CHECK(ndr_push_align(ndr, 5));
2076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
2077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
2078                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2079         }
2080         if (ndr_flags & NDR_BUFFERS) {
2081                 if (r->blob) {
2082                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
2083                 }
2084         }
2085         return NDR_ERR_SUCCESS;
2086 }
2087
2088 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
2089 {
2090         uint32_t _ptr_blob;
2091         TALLOC_CTX *_mem_save_blob_0;
2092         if (ndr_flags & NDR_SCALARS) {
2093                 NDR_CHECK(ndr_pull_align(ndr, 5));
2094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2095                 if (r->__ndr_size > 10485760) {
2096                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2097                 }
2098                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
2099                 if (_ptr_blob) {
2100                         NDR_PULL_ALLOC(ndr, r->blob);
2101                 } else {
2102                         r->blob = NULL;
2103                 }
2104                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2105         }
2106         if (ndr_flags & NDR_BUFFERS) {
2107                 if (r->blob) {
2108                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2109                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2110                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2112                 }
2113         }
2114         return NDR_ERR_SUCCESS;
2115 }
2116
2117 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2118 {
2119         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2120         ndr->depth++;
2121         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2122         ndr_print_ptr(ndr, "blob", r->blob);
2123         ndr->depth++;
2124         if (r->blob) {
2125                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2126         }
2127         ndr->depth--;
2128         ndr->depth--;
2129 }
2130
2131 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2132 {
2133         uint32_t cntr_values_1;
2134         if (ndr_flags & NDR_SCALARS) {
2135                 NDR_CHECK(ndr_push_align(ndr, 5));
2136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2137                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2138                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2139         }
2140         if (ndr_flags & NDR_BUFFERS) {
2141                 if (r->values) {
2142                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2143                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2144                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2145                         }
2146                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2147                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2148                         }
2149                 }
2150         }
2151         return NDR_ERR_SUCCESS;
2152 }
2153
2154 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2155 {
2156         uint32_t _ptr_values;
2157         uint32_t cntr_values_1;
2158         TALLOC_CTX *_mem_save_values_0;
2159         TALLOC_CTX *_mem_save_values_1;
2160         if (ndr_flags & NDR_SCALARS) {
2161                 NDR_CHECK(ndr_pull_align(ndr, 5));
2162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2163                 if (r->num_values > 10485760) {
2164                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2165                 }
2166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2167                 if (_ptr_values) {
2168                         NDR_PULL_ALLOC(ndr, r->values);
2169                 } else {
2170                         r->values = NULL;
2171                 }
2172                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2173         }
2174         if (ndr_flags & NDR_BUFFERS) {
2175                 if (r->values) {
2176                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2177                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2178                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2179                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2180                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2181                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2182                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2183                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2184                         }
2185                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2186                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2187                         }
2188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2189                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2190                 }
2191                 if (r->values) {
2192                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2193                 }
2194         }
2195         return NDR_ERR_SUCCESS;
2196 }
2197
2198 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2199 {
2200         uint32_t cntr_values_1;
2201         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2202         ndr->depth++;
2203         ndr_print_uint32(ndr, "num_values", r->num_values);
2204         ndr_print_ptr(ndr, "values", r->values);
2205         ndr->depth++;
2206         if (r->values) {
2207                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2208                 ndr->depth++;
2209                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2210                         char *idx_1=NULL;
2211                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2212                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2213                                 free(idx_1);
2214                         }
2215                 }
2216                 ndr->depth--;
2217         }
2218         ndr->depth--;
2219         ndr->depth--;
2220 }
2221
2222 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2223 {
2224         if (ndr_flags & NDR_SCALARS) {
2225                 NDR_CHECK(ndr_push_align(ndr, 4));
2226                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2228                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2229                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2231                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2232                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2233         }
2234         if (ndr_flags & NDR_BUFFERS) {
2235                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2236         }
2237         return NDR_ERR_SUCCESS;
2238 }
2239
2240 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2241 {
2242         if (ndr_flags & NDR_SCALARS) {
2243                 NDR_CHECK(ndr_pull_align(ndr, 4));
2244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2246                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2247                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2249                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2250                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2251         }
2252         if (ndr_flags & NDR_BUFFERS) {
2253                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2254         }
2255         return NDR_ERR_SUCCESS;
2256 }
2257
2258 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2259 {
2260         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2261         ndr->depth++;
2262         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);
2263         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);
2264         ndr_print_GUID(ndr, "guid", &r->guid);
2265         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2266         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2267         ndr_print_string(ndr, "dn", r->dn);
2268         ndr->depth--;
2269 }
2270
2271 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2272 {
2273         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2274 }
2275
2276 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2277 {
2278         if (ndr_flags & NDR_SCALARS) {
2279                 NDR_CHECK(ndr_push_align(ndr, 4));
2280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags)));
2281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2282                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2283                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2285                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2287                 {
2288                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2290                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2291                         ndr->flags = _flags_save_DATA_BLOB;
2292                 }
2293                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2294         }
2295         if (ndr_flags & NDR_BUFFERS) {
2296                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2297         }
2298         return NDR_ERR_SUCCESS;
2299 }
2300
2301 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2302 {
2303         if (ndr_flags & NDR_SCALARS) {
2304                 NDR_CHECK(ndr_pull_align(ndr, 4));
2305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2307                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2308                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2310                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2312                 {
2313                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2315                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2316                         ndr->flags = _flags_save_DATA_BLOB;
2317                 }
2318                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2319         }
2320         if (ndr_flags & NDR_BUFFERS) {
2321                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2322         }
2323         return NDR_ERR_SUCCESS;
2324 }
2325
2326 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2327 {
2328         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2329         ndr->depth++;
2330         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);
2331         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);
2332         ndr_print_GUID(ndr, "guid", &r->guid);
2333         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2334         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2335         ndr_print_string(ndr, "dn", r->dn);
2336         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2337         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2338         ndr->depth--;
2339 }
2340
2341 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2342 {
2343         if (ndr_flags & NDR_SCALARS) {
2344                 NDR_CHECK(ndr_push_align(ndr, 5));
2345                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2346                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2347                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2348         }
2349         if (ndr_flags & NDR_BUFFERS) {
2350                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2351         }
2352         return NDR_ERR_SUCCESS;
2353 }
2354
2355 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2356 {
2357         if (ndr_flags & NDR_SCALARS) {
2358                 NDR_CHECK(ndr_pull_align(ndr, 5));
2359                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2360                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2361                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2362         }
2363         if (ndr_flags & NDR_BUFFERS) {
2364                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2365         }
2366         return NDR_ERR_SUCCESS;
2367 }
2368
2369 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2370 {
2371         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2372         ndr->depth++;
2373         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2374         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2375         ndr->depth--;
2376 }
2377
2378 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2379 {
2380         uint32_t cntr_attributes_1;
2381         if (ndr_flags & NDR_SCALARS) {
2382                 NDR_CHECK(ndr_push_align(ndr, 5));
2383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2385                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2386         }
2387         if (ndr_flags & NDR_BUFFERS) {
2388                 if (r->attributes) {
2389                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2390                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2391                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2392                         }
2393                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2394                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2395                         }
2396                 }
2397         }
2398         return NDR_ERR_SUCCESS;
2399 }
2400
2401 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2402 {
2403         uint32_t _ptr_attributes;
2404         uint32_t cntr_attributes_1;
2405         TALLOC_CTX *_mem_save_attributes_0;
2406         TALLOC_CTX *_mem_save_attributes_1;
2407         if (ndr_flags & NDR_SCALARS) {
2408                 NDR_CHECK(ndr_pull_align(ndr, 5));
2409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2410                 if (r->num_attributes > 1048576) {
2411                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2412                 }
2413                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2414                 if (_ptr_attributes) {
2415                         NDR_PULL_ALLOC(ndr, r->attributes);
2416                 } else {
2417                         r->attributes = NULL;
2418                 }
2419                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2420         }
2421         if (ndr_flags & NDR_BUFFERS) {
2422                 if (r->attributes) {
2423                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2424                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2426                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2427                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2428                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2429                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2430                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2431                         }
2432                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2433                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2434                         }
2435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2437                 }
2438                 if (r->attributes) {
2439                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2440                 }
2441         }
2442         return NDR_ERR_SUCCESS;
2443 }
2444
2445 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2446 {
2447         uint32_t cntr_attributes_1;
2448         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2449         ndr->depth++;
2450         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2451         ndr_print_ptr(ndr, "attributes", r->attributes);
2452         ndr->depth++;
2453         if (r->attributes) {
2454                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2455                 ndr->depth++;
2456                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2457                         char *idx_1=NULL;
2458                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2459                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2460                                 free(idx_1);
2461                         }
2462                 }
2463                 ndr->depth--;
2464         }
2465         ndr->depth--;
2466         ndr->depth--;
2467 }
2468
2469 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2470 {
2471         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2472         return NDR_ERR_SUCCESS;
2473 }
2474
2475 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2476 {
2477         uint32_t v;
2478         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2479         *r = v;
2480         return NDR_ERR_SUCCESS;
2481 }
2482
2483 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2484 {
2485         ndr_print_uint32(ndr, name, r);
2486         ndr->depth++;
2487         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2488         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2489         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2490         ndr->depth--;
2491 }
2492
2493 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2494 {
2495         if (ndr_flags & NDR_SCALARS) {
2496                 NDR_CHECK(ndr_push_align(ndr, 5));
2497                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2498                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2499                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2500                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2501         }
2502         if (ndr_flags & NDR_BUFFERS) {
2503                 if (r->identifier) {
2504                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2505                 }
2506                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2507         }
2508         return NDR_ERR_SUCCESS;
2509 }
2510
2511 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2512 {
2513         uint32_t _ptr_identifier;
2514         TALLOC_CTX *_mem_save_identifier_0;
2515         if (ndr_flags & NDR_SCALARS) {
2516                 NDR_CHECK(ndr_pull_align(ndr, 5));
2517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2518                 if (_ptr_identifier) {
2519                         NDR_PULL_ALLOC(ndr, r->identifier);
2520                 } else {
2521                         r->identifier = NULL;
2522                 }
2523                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2524                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2525                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2526         }
2527         if (ndr_flags & NDR_BUFFERS) {
2528                 if (r->identifier) {
2529                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2530                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2531                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2533                 }
2534                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2535         }
2536         return NDR_ERR_SUCCESS;
2537 }
2538
2539 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2540 {
2541         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2542         ndr->depth++;
2543         ndr_print_ptr(ndr, "identifier", r->identifier);
2544         ndr->depth++;
2545         if (r->identifier) {
2546                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2547         }
2548         ndr->depth--;
2549         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2550         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2551         ndr->depth--;
2552 }
2553
2554 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2555 {
2556         if (ndr_flags & NDR_SCALARS) {
2557                 NDR_CHECK(ndr_push_align(ndr, 8));
2558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2559                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2560                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2561                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2562                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2563         }
2564         if (ndr_flags & NDR_BUFFERS) {
2565         }
2566         return NDR_ERR_SUCCESS;
2567 }
2568
2569 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2570 {
2571         if (ndr_flags & NDR_SCALARS) {
2572                 NDR_CHECK(ndr_pull_align(ndr, 8));
2573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2574                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2575                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2576                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2577                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2578         }
2579         if (ndr_flags & NDR_BUFFERS) {
2580         }
2581         return NDR_ERR_SUCCESS;
2582 }
2583
2584 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2585 {
2586         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2587         ndr->depth++;
2588         ndr_print_uint32(ndr, "version", r->version);
2589         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2590         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2591         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2592         ndr->depth--;
2593 }
2594
2595 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2596 {
2597         uint32_t cntr_meta_data_0;
2598         if (ndr_flags & NDR_SCALARS) {
2599                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2600                 NDR_CHECK(ndr_push_align(ndr, 8));
2601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2602                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2603                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2604                 }
2605                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2606         }
2607         if (ndr_flags & NDR_BUFFERS) {
2608         }
2609         return NDR_ERR_SUCCESS;
2610 }
2611
2612 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2613 {
2614         uint32_t cntr_meta_data_0;
2615         TALLOC_CTX *_mem_save_meta_data_0;
2616         if (ndr_flags & NDR_SCALARS) {
2617                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2618                 NDR_CHECK(ndr_pull_align(ndr, 8));
2619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2620                 if (r->count > 1048576) {
2621                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2622                 }
2623                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2624                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2625                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2626                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2627                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2628                 }
2629                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2630                 if (r->meta_data) {
2631                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2632                 }
2633                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2634         }
2635         if (ndr_flags & NDR_BUFFERS) {
2636         }
2637         return NDR_ERR_SUCCESS;
2638 }
2639
2640 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2641 {
2642         uint32_t cntr_meta_data_0;
2643         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2644         ndr->depth++;
2645         ndr_print_uint32(ndr, "count", r->count);
2646         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2647         ndr->depth++;
2648         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2649                 char *idx_0=NULL;
2650                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2651                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2652                         free(idx_0);
2653                 }
2654         }
2655         ndr->depth--;
2656         ndr->depth--;
2657 }
2658
2659 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2660 {
2661         if (ndr_flags & NDR_SCALARS) {
2662                 NDR_CHECK(ndr_push_align(ndr, 5));
2663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2664                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2666                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2667                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2668                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2669         }
2670         if (ndr_flags & NDR_BUFFERS) {
2671                 if (r->next_object) {
2672                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2673                 }
2674                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2675                 if (r->parent_object_guid) {
2676                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2677                 }
2678                 if (r->meta_data_ctr) {
2679                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2680                 }
2681         }
2682         return NDR_ERR_SUCCESS;
2683 }
2684
2685 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2686 {
2687         uint32_t _ptr_next_object;
2688         TALLOC_CTX *_mem_save_next_object_0;
2689         uint32_t _ptr_parent_object_guid;
2690         TALLOC_CTX *_mem_save_parent_object_guid_0;
2691         uint32_t _ptr_meta_data_ctr;
2692         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2693         if (ndr_flags & NDR_SCALARS) {
2694                 NDR_CHECK(ndr_pull_align(ndr, 5));
2695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2696                 if (_ptr_next_object) {
2697                         NDR_PULL_ALLOC(ndr, r->next_object);
2698                 } else {
2699                         r->next_object = NULL;
2700                 }
2701                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2704                 if (_ptr_parent_object_guid) {
2705                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2706                 } else {
2707                         r->parent_object_guid = NULL;
2708                 }
2709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2710                 if (_ptr_meta_data_ctr) {
2711                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2712                 } else {
2713                         r->meta_data_ctr = NULL;
2714                 }
2715                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2716         }
2717         if (ndr_flags & NDR_BUFFERS) {
2718                 if (r->next_object) {
2719                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2720                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2721                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2722                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2723                 }
2724                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2725                 if (r->parent_object_guid) {
2726                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2727                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2728                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2730                 }
2731                 if (r->meta_data_ctr) {
2732                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2733                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2734                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2736                 }
2737         }
2738         return NDR_ERR_SUCCESS;
2739 }
2740
2741 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2742 {
2743         if (ndr_flags & NDR_SCALARS) {
2744                 NDR_CHECK(ndr_push_align(ndr, 8));
2745                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2746                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2748                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2749                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2751                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2752                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2757                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2758         }
2759         if (ndr_flags & NDR_BUFFERS) {
2760                 if (r->naming_context) {
2761                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2762                 }
2763                 if (r->uptodateness_vector) {
2764                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2765                 }
2766                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2767                 if (r->first_object) {
2768                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2769                 }
2770         }
2771         return NDR_ERR_SUCCESS;
2772 }
2773
2774 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2775 {
2776         uint32_t _ptr_naming_context;
2777         TALLOC_CTX *_mem_save_naming_context_0;
2778         uint32_t _ptr_uptodateness_vector;
2779         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2780         uint32_t _ptr_first_object;
2781         TALLOC_CTX *_mem_save_first_object_0;
2782         if (ndr_flags & NDR_SCALARS) {
2783                 NDR_CHECK(ndr_pull_align(ndr, 8));
2784                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2785                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2786                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2787                 if (_ptr_naming_context) {
2788                         NDR_PULL_ALLOC(ndr, r->naming_context);
2789                 } else {
2790                         r->naming_context = NULL;
2791                 }
2792                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2793                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2795                 if (_ptr_uptodateness_vector) {
2796                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2797                 } else {
2798                         r->uptodateness_vector = NULL;
2799                 }
2800                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2801                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2805                 if (_ptr_first_object) {
2806                         NDR_PULL_ALLOC(ndr, r->first_object);
2807                 } else {
2808                         r->first_object = NULL;
2809                 }
2810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2811                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2812         }
2813         if (ndr_flags & NDR_BUFFERS) {
2814                 if (r->naming_context) {
2815                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2816                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2817                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2818                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2819                 }
2820                 if (r->uptodateness_vector) {
2821                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2822                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2823                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2825                 }
2826                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2827                 if (r->first_object) {
2828                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2829                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2830                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2831                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2832                 }
2833         }
2834         return NDR_ERR_SUCCESS;
2835 }
2836
2837 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2838 {
2839         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2840         ndr->depth++;
2841         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2842         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2843         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2844         ndr->depth++;
2845         if (r->naming_context) {
2846                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2847         }
2848         ndr->depth--;
2849         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2850         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2851         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2852         ndr->depth++;
2853         if (r->uptodateness_vector) {
2854                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2855         }
2856         ndr->depth--;
2857         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2858         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2859         ndr_print_uint32(ndr, "object_count", r->object_count);
2860         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);
2861         ndr_print_ptr(ndr, "first_object", r->first_object);
2862         ndr->depth++;
2863         if (r->first_object) {
2864                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2865         }
2866         ndr->depth--;
2867         ndr_print_uint32(ndr, "more_data", r->more_data);
2868         ndr->depth--;
2869 }
2870
2871 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2872 {
2873         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2874 }
2875
2876 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2877 {
2878         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2879         return NDR_ERR_SUCCESS;
2880 }
2881
2882 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2883 {
2884         uint32_t v;
2885         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2886         *r = v;
2887         return NDR_ERR_SUCCESS;
2888 }
2889
2890 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2891 {
2892         ndr_print_uint32(ndr, name, r);
2893         ndr->depth++;
2894         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2895         ndr->depth--;
2896 }
2897
2898 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2899 {
2900         if (ndr_flags & NDR_SCALARS) {
2901                 NDR_CHECK(ndr_push_align(ndr, 8));
2902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2903                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2904                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2905                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2906                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2907                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2908                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2909         }
2910         if (ndr_flags & NDR_BUFFERS) {
2911                 if (r->identifier) {
2912                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2913                 }
2914                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2915         }
2916         return NDR_ERR_SUCCESS;
2917 }
2918
2919 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2920 {
2921         uint32_t _ptr_identifier;
2922         TALLOC_CTX *_mem_save_identifier_0;
2923         if (ndr_flags & NDR_SCALARS) {
2924                 NDR_CHECK(ndr_pull_align(ndr, 8));
2925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2926                 if (_ptr_identifier) {
2927                         NDR_PULL_ALLOC(ndr, r->identifier);
2928                 } else {
2929                         r->identifier = NULL;
2930                 }
2931                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2932                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2933                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2934                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2935                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2936                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2937         }
2938         if (ndr_flags & NDR_BUFFERS) {
2939                 if (r->identifier) {
2940                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2941                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2942                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2943                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2944                 }
2945                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2946         }
2947         return NDR_ERR_SUCCESS;
2948 }
2949
2950 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2951 {
2952         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2953         ndr->depth++;
2954         ndr_print_ptr(ndr, "identifier", r->identifier);
2955         ndr->depth++;
2956         if (r->identifier) {
2957                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2958         }
2959         ndr->depth--;
2960         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2961         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2962         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2963         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2964         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2965         ndr->depth--;
2966 }
2967
2968 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2969 {
2970         uint32_t cntr_linked_attributes_1;
2971         if (ndr_flags & NDR_SCALARS) {
2972                 NDR_CHECK(ndr_push_align(ndr, 8));
2973                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2974                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2975                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2976                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2977                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2978                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2979                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2980                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2989                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2990                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2991         }
2992         if (ndr_flags & NDR_BUFFERS) {
2993                 if (r->naming_context) {
2994                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2995                 }
2996                 if (r->uptodateness_vector) {
2997                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2998                 }
2999                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3000                 if (r->first_object) {
3001                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3002                 }
3003                 if (r->linked_attributes) {
3004                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
3005                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3006                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3007                         }
3008                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3009                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3010                         }
3011                 }
3012         }
3013         return NDR_ERR_SUCCESS;
3014 }
3015
3016 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
3017 {
3018         uint32_t _ptr_naming_context;
3019         TALLOC_CTX *_mem_save_naming_context_0;
3020         uint32_t _ptr_uptodateness_vector;
3021         TALLOC_CTX *_mem_save_uptodateness_vector_0;
3022         uint32_t _ptr_first_object;
3023         TALLOC_CTX *_mem_save_first_object_0;
3024         uint32_t _ptr_linked_attributes;
3025         uint32_t cntr_linked_attributes_1;
3026         TALLOC_CTX *_mem_save_linked_attributes_0;
3027         TALLOC_CTX *_mem_save_linked_attributes_1;
3028         if (ndr_flags & NDR_SCALARS) {
3029                 NDR_CHECK(ndr_pull_align(ndr, 8));
3030                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
3031                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
3032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
3033                 if (_ptr_naming_context) {
3034                         NDR_PULL_ALLOC(ndr, r->naming_context);
3035                 } else {
3036                         r->naming_context = NULL;
3037                 }
3038                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
3039                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
3040                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
3041                 if (_ptr_uptodateness_vector) {
3042                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
3043                 } else {
3044                         r->uptodateness_vector = NULL;
3045                 }
3046                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
3047                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
3048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
3049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
3050                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
3051                 if (_ptr_first_object) {
3052                         NDR_PULL_ALLOC(ndr, r->first_object);
3053                 } else {
3054                         r->first_object = NULL;
3055                 }
3056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
3057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
3058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
3059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
3060                 if (r->linked_attributes_count > 1048576) {
3061                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3062                 }
3063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
3064                 if (_ptr_linked_attributes) {
3065                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
3066                 } else {
3067                         r->linked_attributes = NULL;
3068                 }
3069                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
3070                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3071         }
3072         if (ndr_flags & NDR_BUFFERS) {
3073                 if (r->naming_context) {
3074                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3075                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3076                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3078                 }
3079                 if (r->uptodateness_vector) {
3080                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
3081                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
3082                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
3083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
3084                 }
3085                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3086                 if (r->first_object) {
3087                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
3088                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
3089                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3090                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
3091                 }
3092                 if (r->linked_attributes) {
3093                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
3094                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3095                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3096                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3097                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3098                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3099                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3100                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3101                         }
3102                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3103                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3104                         }
3105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3107                 }
3108                 if (r->linked_attributes) {
3109                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3110                 }
3111         }
3112         return NDR_ERR_SUCCESS;
3113 }
3114
3115 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3116 {
3117         uint32_t cntr_linked_attributes_1;
3118         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3119         ndr->depth++;
3120         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3121         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3122         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3123         ndr->depth++;
3124         if (r->naming_context) {
3125                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3126         }
3127         ndr->depth--;
3128         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3129         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3130         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3131         ndr->depth++;
3132         if (r->uptodateness_vector) {
3133                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3134         }
3135         ndr->depth--;
3136         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3137         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3138         ndr_print_uint32(ndr, "object_count", r->object_count);
3139         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);
3140         ndr_print_ptr(ndr, "first_object", r->first_object);
3141         ndr->depth++;
3142         if (r->first_object) {
3143                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3144         }
3145         ndr->depth--;
3146         ndr_print_uint32(ndr, "more_data", r->more_data);
3147         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3148         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3149         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3150         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3151         ndr->depth++;
3152         if (r->linked_attributes) {
3153                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3154                 ndr->depth++;
3155                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3156                         char *idx_1=NULL;
3157                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3158                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3159                                 free(idx_1);
3160                         }
3161                 }
3162                 ndr->depth--;
3163         }
3164         ndr->depth--;
3165         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3166         ndr->depth--;
3167 }
3168
3169 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3170 {
3171         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3172 }
3173
3174 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3175 {
3176         if (ndr_flags & NDR_SCALARS) {
3177                 NDR_CHECK(ndr_push_align(ndr, 1));
3178                 {
3179                         struct ndr_push *_ndr_ctr1;
3180                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3181                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3182                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3183                 }
3184                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3185         }
3186         if (ndr_flags & NDR_BUFFERS) {
3187         }
3188         return NDR_ERR_SUCCESS;
3189 }
3190
3191 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3192 {
3193         if (ndr_flags & NDR_SCALARS) {
3194                 NDR_CHECK(ndr_pull_align(ndr, 1));
3195                 {
3196                         struct ndr_pull *_ndr_ctr1;
3197                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3198                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3199                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3200                 }
3201                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3202         }
3203         if (ndr_flags & NDR_BUFFERS) {
3204         }
3205         return NDR_ERR_SUCCESS;
3206 }
3207
3208 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3209 {
3210         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3211         ndr->depth++;
3212         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3213         ndr->depth--;
3214 }
3215
3216 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3217 {
3218         if (ndr_flags & NDR_SCALARS) {
3219                 NDR_CHECK(ndr_push_align(ndr, 1));
3220                 {
3221                         struct ndr_push *_ndr_ctr6;
3222                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3223                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3224                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3225                 }
3226                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3227         }
3228         if (ndr_flags & NDR_BUFFERS) {
3229         }
3230         return NDR_ERR_SUCCESS;
3231 }
3232
3233 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3234 {
3235         if (ndr_flags & NDR_SCALARS) {
3236                 NDR_CHECK(ndr_pull_align(ndr, 1));
3237                 {
3238                         struct ndr_pull *_ndr_ctr6;
3239                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3240                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3241                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3242                 }
3243                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3244         }
3245         if (ndr_flags & NDR_BUFFERS) {
3246         }
3247         return NDR_ERR_SUCCESS;
3248 }
3249
3250 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3251 {
3252         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3253         ndr->depth++;
3254         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3255         ndr->depth--;
3256 }
3257
3258 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3259 {
3260         uint32_t _ptr_ts;
3261         TALLOC_CTX *_mem_save_ts_0;
3262         if (ndr_flags & NDR_SCALARS) {
3263                 NDR_CHECK(ndr_pull_align(ndr, 5));
3264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3267                 if (_ptr_ts) {
3268                         NDR_PULL_ALLOC(ndr, r->ts);
3269                 } else {
3270                         r->ts = NULL;
3271                 }
3272                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3273         }
3274         if (ndr_flags & NDR_BUFFERS) {
3275                 if (r->ts) {
3276                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3277                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3278                         {
3279                                 struct ndr_pull *_ndr_ts;
3280                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3281                                 {
3282                                         struct ndr_pull *_ndr_ts_compressed;
3283                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3284                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3285                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3286                                 }
3287                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3288                         }
3289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3290                 }
3291         }
3292         return NDR_ERR_SUCCESS;
3293 }
3294
3295 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3296 {
3297         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3298         ndr->depth++;
3299         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3300         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3301         ndr_print_ptr(ndr, "ts", r->ts);
3302         ndr->depth++;
3303         if (r->ts) {
3304                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3305         }
3306         ndr->depth--;
3307         ndr->depth--;
3308 }
3309
3310 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3311 {
3312         uint32_t _ptr_ts;
3313         TALLOC_CTX *_mem_save_ts_0;
3314         if (ndr_flags & NDR_SCALARS) {
3315                 NDR_CHECK(ndr_pull_align(ndr, 5));
3316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3319                 if (_ptr_ts) {
3320                         NDR_PULL_ALLOC(ndr, r->ts);
3321                 } else {
3322                         r->ts = NULL;
3323                 }
3324                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3325         }
3326         if (ndr_flags & NDR_BUFFERS) {
3327                 if (r->ts) {
3328                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3329                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3330                         {
3331                                 struct ndr_pull *_ndr_ts;
3332                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3333                                 {
3334                                         struct ndr_pull *_ndr_ts_compressed;
3335                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3336                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3337                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3338                                 }
3339                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3340                         }
3341                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3342                 }
3343         }
3344         return NDR_ERR_SUCCESS;
3345 }
3346
3347 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3348 {
3349         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3350         ndr->depth++;
3351         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3352         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3353         ndr_print_ptr(ndr, "ts", r->ts);
3354         ndr->depth++;
3355         if (r->ts) {
3356                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3357         }
3358         ndr->depth--;
3359         ndr->depth--;
3360 }
3361
3362 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3363 {
3364         uint32_t _ptr_ts;
3365         TALLOC_CTX *_mem_save_ts_0;
3366         if (ndr_flags & NDR_SCALARS) {
3367                 NDR_CHECK(ndr_pull_align(ndr, 5));
3368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3371                 if (_ptr_ts) {
3372                         NDR_PULL_ALLOC(ndr, r->ts);
3373                 } else {
3374                         r->ts = NULL;
3375                 }
3376                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3377         }
3378         if (ndr_flags & NDR_BUFFERS) {
3379                 if (r->ts) {
3380                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3381                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3382                         {
3383                                 struct ndr_pull *_ndr_ts;
3384                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3385                                 {
3386                                         struct ndr_pull *_ndr_ts_compressed;
3387                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3388                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3389                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3390                                 }
3391                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3392                         }
3393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3394                 }
3395         }
3396         return NDR_ERR_SUCCESS;
3397 }
3398
3399 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3400 {
3401         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3402         ndr->depth++;
3403         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3404         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3405         ndr_print_ptr(ndr, "ts", r->ts);
3406         ndr->depth++;
3407         if (r->ts) {
3408                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3409         }
3410         ndr->depth--;
3411         ndr->depth--;
3412 }
3413
3414 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3415 {
3416         uint32_t _ptr_ts;
3417         TALLOC_CTX *_mem_save_ts_0;
3418         if (ndr_flags & NDR_SCALARS) {
3419                 NDR_CHECK(ndr_pull_align(ndr, 5));
3420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3423                 if (_ptr_ts) {
3424                         NDR_PULL_ALLOC(ndr, r->ts);
3425                 } else {
3426                         r->ts = NULL;
3427                 }
3428                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3429         }
3430         if (ndr_flags & NDR_BUFFERS) {
3431                 if (r->ts) {
3432                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3433                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3434                         {
3435                                 struct ndr_pull *_ndr_ts;
3436                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3437                                 {
3438                                         struct ndr_pull *_ndr_ts_compressed;
3439                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3440                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3441                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3442                                 }
3443                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3444                         }
3445                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3446                 }
3447         }
3448         return NDR_ERR_SUCCESS;
3449 }
3450
3451 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3452 {
3453         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3454         ndr->depth++;
3455         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3456         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3457         ndr_print_ptr(ndr, "ts", r->ts);
3458         ndr->depth++;
3459         if (r->ts) {
3460                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3461         }
3462         ndr->depth--;
3463         ndr->depth--;
3464 }
3465
3466 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3467 {
3468         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3469         return NDR_ERR_SUCCESS;
3470 }
3471
3472 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3473 {
3474         uint16_t v;
3475         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3476         *r = v;
3477         return NDR_ERR_SUCCESS;
3478 }
3479
3480 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3481 {
3482         const char *val = NULL;
3483
3484         switch (r) {
3485                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3486                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3487         }
3488         ndr_print_enum(ndr, name, "ENUM", val, r);
3489 }
3490
3491 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3492 {
3493         {
3494                 uint32_t _flags_save_UNION = ndr->flags;
3495                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3496                 if (ndr_flags & NDR_SCALARS) {
3497                         int level = ndr_push_get_switch_value(ndr, r);
3498                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3499                         switch (level) {
3500                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3501                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3502                                 break; }
3503
3504                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3505                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3506                                 break; }
3507
3508                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3509                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3510                                 break; }
3511
3512                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3513                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3514                                 break; }
3515
3516                                 default:
3517                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3518                         }
3519                 }
3520                 if (ndr_flags & NDR_BUFFERS) {
3521                         int level = ndr_push_get_switch_value(ndr, r);
3522                         switch (level) {
3523                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3524                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3525                                 break;
3526
3527                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3528                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3529                                 break;
3530
3531                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3532                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3533                                 break;
3534
3535                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3536                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3537                                 break;
3538
3539                                 default:
3540                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3541                         }
3542                 }
3543                 ndr->flags = _flags_save_UNION;
3544         }
3545         return NDR_ERR_SUCCESS;
3546 }
3547
3548 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3549 {
3550         int level;
3551         {
3552                 uint32_t _flags_save_UNION = ndr->flags;
3553                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3554                 level = ndr_pull_get_switch_value(ndr, r);
3555                 if (ndr_flags & NDR_SCALARS) {
3556                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3557                         switch (level) {
3558                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3559                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3560                                 break; }
3561
3562                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3563                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3564                                 break; }
3565
3566                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3567                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3568                                 break; }
3569
3570                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3571                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3572                                 break; }
3573
3574                                 default:
3575                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3576                         }
3577                 }
3578                 if (ndr_flags & NDR_BUFFERS) {
3579                         switch (level) {
3580                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3581                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3582                                 break;
3583
3584                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3585                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3586                                 break;
3587
3588                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3589                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3590                                 break;
3591
3592                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3593                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3594                                 break;
3595
3596                                 default:
3597                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3598                         }
3599                 }
3600                 ndr->flags = _flags_save_UNION;
3601         }
3602         return NDR_ERR_SUCCESS;
3603 }
3604
3605 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3606 {
3607         int level;
3608         {
3609                 uint32_t _flags_save_UNION = ndr->flags;
3610                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3611                 level = ndr_print_get_switch_value(ndr, r);
3612                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3613                 switch (level) {
3614                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3615                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3616                         break;
3617
3618                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3619                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3620                         break;
3621
3622                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3623                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3624                         break;
3625
3626                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3627                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3628                         break;
3629
3630                         default:
3631                                 ndr_print_bad_level(ndr, name, level);
3632                 }
3633                 ndr->flags = _flags_save_UNION;
3634         }
3635 }
3636
3637 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3638 {
3639         if (ndr_flags & NDR_SCALARS) {
3640                 NDR_CHECK(ndr_push_align(ndr, 5));
3641                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3642                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3643         }
3644         if (ndr_flags & NDR_BUFFERS) {
3645                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3646         }
3647         return NDR_ERR_SUCCESS;
3648 }
3649
3650 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3651 {
3652         if (ndr_flags & NDR_SCALARS) {
3653                 NDR_CHECK(ndr_pull_align(ndr, 5));
3654                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3655                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3656         }
3657         if (ndr_flags & NDR_BUFFERS) {
3658                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3659         }
3660         return NDR_ERR_SUCCESS;
3661 }
3662
3663 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3664 {
3665         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3666         ndr->depth++;
3667         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3668         ndr->depth--;
3669 }
3670
3671 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3672 {
3673         if (ndr_flags & NDR_SCALARS) {
3674                 NDR_CHECK(ndr_push_align(ndr, 5));
3675                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3676                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3677                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3678                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3679                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3680         }
3681         if (ndr_flags & NDR_BUFFERS) {
3682                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3683         }
3684         return NDR_ERR_SUCCESS;
3685 }
3686
3687 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3688 {
3689         if (ndr_flags & NDR_SCALARS) {
3690                 NDR_CHECK(ndr_pull_align(ndr, 5));
3691                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3692                 if (r->level < 0 || r->level > 6) {
3693                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3694                 }
3695                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3696                 if (r->type < 2 || r->type > 3) {
3697                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3698                 }
3699                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3700                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3701                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3702         }
3703         if (ndr_flags & NDR_BUFFERS) {
3704                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3705         }
3706         return NDR_ERR_SUCCESS;
3707 }
3708
3709 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3710 {
3711         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3712         ndr->depth++;
3713         ndr_print_int32(ndr, "level", r->level);
3714         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3715         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3716         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3717         ndr->depth--;
3718 }
3719
3720 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3721 {
3722         if (ndr_flags & NDR_SCALARS) {
3723                 int level = ndr_push_get_switch_value(ndr, r);
3724                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3725                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3726                 switch (level) {
3727                         case 1: {
3728                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3729                         break; }
3730
3731                         case 2: {
3732                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3733                         break; }
3734
3735                         case 6: {
3736                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3737                         break; }
3738
3739                         case 7: {
3740                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3741                         break; }
3742
3743                         default:
3744                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3745                 }
3746         }
3747         if (ndr_flags & NDR_BUFFERS) {
3748                 int level = ndr_push_get_switch_value(ndr, r);
3749                 switch (level) {
3750                         case 1:
3751                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3752                         break;
3753
3754                         case 2:
3755                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3756                         break;
3757
3758                         case 6:
3759                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3760                         break;
3761
3762                         case 7:
3763                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3764                         break;
3765
3766                         default:
3767                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3768                 }
3769         }
3770         return NDR_ERR_SUCCESS;
3771 }
3772
3773 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3774 {
3775         int level;
3776         int32_t _level;
3777         level = ndr_pull_get_switch_value(ndr, r);
3778         if (ndr_flags & NDR_SCALARS) {
3779                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3780                 if (_level != level) {
3781                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3782                 }
3783                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3784                 switch (level) {
3785                         case 1: {
3786                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3787                         break; }
3788
3789                         case 2: {
3790                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3791                         break; }
3792
3793                         case 6: {
3794                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3795                         break; }
3796
3797                         case 7: {
3798                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3799                         break; }
3800
3801                         default:
3802                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3803                 }
3804         }
3805         if (ndr_flags & NDR_BUFFERS) {
3806                 switch (level) {
3807                         case 1:
3808                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3809                         break;
3810
3811                         case 2:
3812                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3813                         break;
3814
3815                         case 6:
3816                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3817                         break;
3818
3819                         case 7:
3820                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3821                         break;
3822
3823                         default:
3824                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3825                 }
3826         }
3827         return NDR_ERR_SUCCESS;
3828 }
3829
3830 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3831 {
3832         int level;
3833         level = ndr_print_get_switch_value(ndr, r);
3834         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3835         switch (level) {
3836                 case 1:
3837                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3838                 break;
3839
3840                 case 2:
3841                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3842                 break;
3843
3844                 case 6:
3845                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3846                 break;
3847
3848                 case 7:
3849                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3850                 break;
3851
3852                 default:
3853                         ndr_print_bad_level(ndr, name, level);
3854         }
3855 }
3856
3857 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3858 {
3859         if (ndr_flags & NDR_SCALARS) {
3860                 NDR_CHECK(ndr_push_align(ndr, 5));
3861                 if (r->naming_context == NULL) {
3862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3863                 }
3864                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3865                 if (r->dest_dsa_dns_name == NULL) {
3866                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3867                 }
3868                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3869                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3870                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3871                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3872         }
3873         if (ndr_flags & NDR_BUFFERS) {
3874                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3875                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3876                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3877                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3878                 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));
3879         }
3880         return NDR_ERR_SUCCESS;
3881 }
3882
3883 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3884 {
3885         uint32_t _ptr_naming_context;
3886         TALLOC_CTX *_mem_save_naming_context_0;
3887         uint32_t _ptr_dest_dsa_dns_name;
3888         if (ndr_flags & NDR_SCALARS) {
3889                 NDR_CHECK(ndr_pull_align(ndr, 5));
3890                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3891                 if (_ptr_naming_context) {
3892                         NDR_PULL_ALLOC(ndr, r->naming_context);
3893                 } else {
3894                         r->naming_context = NULL;
3895                 }
3896                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3897                 if (_ptr_dest_dsa_dns_name) {
3898                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3899                 } else {
3900                         r->dest_dsa_dns_name = NULL;
3901                 }
3902                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3903                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
3904                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3905         }
3906         if (ndr_flags & NDR_BUFFERS) {
3907                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3908                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3909                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3910                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3911                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3912                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3913                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3914                         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));
3915                 }
3916                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3917                 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));
3918         }
3919         return NDR_ERR_SUCCESS;
3920 }
3921
3922 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3923 {
3924         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3925         ndr->depth++;
3926         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3927         ndr->depth++;
3928         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3929         ndr->depth--;
3930         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3931         ndr->depth++;
3932         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3933         ndr->depth--;
3934         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3935         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
3936         ndr->depth--;
3937 }
3938
3939 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3940 {
3941         if (ndr_flags & NDR_SCALARS) {
3942                 int level = ndr_push_get_switch_value(ndr, r);
3943                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3944                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3945                 switch (level) {
3946                         case 1: {
3947                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3948                         break; }
3949
3950                         default:
3951                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3952                 }
3953         }
3954         if (ndr_flags & NDR_BUFFERS) {
3955                 int level = ndr_push_get_switch_value(ndr, r);
3956                 switch (level) {
3957                         case 1:
3958                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3959                         break;
3960
3961                         default:
3962                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3963                 }
3964         }
3965         return NDR_ERR_SUCCESS;
3966 }
3967
3968 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3969 {
3970         int level;
3971         int32_t _level;
3972         level = ndr_pull_get_switch_value(ndr, r);
3973         if (ndr_flags & NDR_SCALARS) {
3974                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3975                 if (_level != level) {
3976                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3977                 }
3978                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3979                 switch (level) {
3980                         case 1: {
3981                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3982                         break; }
3983
3984                         default:
3985                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3986                 }
3987         }
3988         if (ndr_flags & NDR_BUFFERS) {
3989                 switch (level) {
3990                         case 1:
3991                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3992                         break;
3993
3994                         default:
3995                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3996                 }
3997         }
3998         return NDR_ERR_SUCCESS;
3999 }
4000
4001 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
4002 {
4003         int level;
4004         level = ndr_print_get_switch_value(ndr, r);
4005         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
4006         switch (level) {
4007                 case 1:
4008                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
4009                 break;
4010
4011                 default:
4012                         ndr_print_bad_level(ndr, name, level);
4013         }
4014 }
4015
4016 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
4017 {
4018         if (ndr_flags & NDR_SCALARS) {
4019                 NDR_CHECK(ndr_push_align(ndr, 5));
4020                 if (r->naming_context == NULL) {
4021                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4022                 }
4023                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4025                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4026                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4027                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4028         }
4029         if (ndr_flags & NDR_BUFFERS) {
4030                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4031                 if (r->source_dsa_address) {
4032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4035                         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));
4036                 }
4037         }
4038         return NDR_ERR_SUCCESS;
4039 }
4040
4041 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
4042 {
4043         uint32_t _ptr_naming_context;
4044         TALLOC_CTX *_mem_save_naming_context_0;
4045         uint32_t _ptr_source_dsa_address;
4046         TALLOC_CTX *_mem_save_source_dsa_address_0;
4047         if (ndr_flags & NDR_SCALARS) {
4048                 NDR_CHECK(ndr_pull_align(ndr, 5));
4049                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4050                 if (_ptr_naming_context) {
4051                         NDR_PULL_ALLOC(ndr, r->naming_context);
4052                 } else {
4053                         r->naming_context = NULL;
4054                 }
4055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4056                 if (_ptr_source_dsa_address) {
4057                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4058                 } else {
4059                         r->source_dsa_address = NULL;
4060                 }
4061                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4062                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4063                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4064         }
4065         if (ndr_flags & NDR_BUFFERS) {
4066                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4067                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4068                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4069                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4070                 if (r->source_dsa_address) {
4071                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4072                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4073                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4074                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4075                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4076                                 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));
4077                         }
4078                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4079                         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));
4080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4081                 }
4082         }
4083         return NDR_ERR_SUCCESS;
4084 }
4085
4086 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4087 {
4088         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4089         ndr->depth++;
4090         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4091         ndr->depth++;
4092         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4093         ndr->depth--;
4094         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4095         ndr->depth++;
4096         if (r->source_dsa_address) {
4097                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4098         }
4099         ndr->depth--;
4100         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4101         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4102         ndr->depth--;
4103 }
4104
4105 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4106 {
4107         if (ndr_flags & NDR_SCALARS) {
4108                 NDR_CHECK(ndr_push_align(ndr, 5));
4109                 if (r->naming_context == NULL) {
4110                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4111                 }
4112                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4113                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4114                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4115                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4116                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4117                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4118                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4119         }
4120         if (ndr_flags & NDR_BUFFERS) {
4121                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4122                 if (r->source_dsa_dn) {
4123                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4124                 }
4125                 if (r->transport_dn) {
4126                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4127                 }
4128                 if (r->source_dsa_address) {
4129                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4130                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4132                         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));
4133                 }
4134         }
4135         return NDR_ERR_SUCCESS;
4136 }
4137
4138 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4139 {
4140         uint32_t _ptr_naming_context;
4141         TALLOC_CTX *_mem_save_naming_context_0;
4142         uint32_t _ptr_source_dsa_dn;
4143         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4144         uint32_t _ptr_transport_dn;
4145         TALLOC_CTX *_mem_save_transport_dn_0;
4146         uint32_t _ptr_source_dsa_address;
4147         TALLOC_CTX *_mem_save_source_dsa_address_0;
4148         if (ndr_flags & NDR_SCALARS) {
4149                 NDR_CHECK(ndr_pull_align(ndr, 5));
4150                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4151                 if (_ptr_naming_context) {
4152                         NDR_PULL_ALLOC(ndr, r->naming_context);
4153                 } else {
4154                         r->naming_context = NULL;
4155                 }
4156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4157                 if (_ptr_source_dsa_dn) {
4158                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4159                 } else {
4160                         r->source_dsa_dn = NULL;
4161                 }
4162                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4163                 if (_ptr_transport_dn) {
4164                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4165                 } else {
4166                         r->transport_dn = NULL;
4167                 }
4168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4169                 if (_ptr_source_dsa_address) {
4170                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4171                 } else {
4172                         r->source_dsa_address = NULL;
4173                 }
4174                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4175                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4176                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4177         }
4178         if (ndr_flags & NDR_BUFFERS) {
4179                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4180                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4181                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4183                 if (r->source_dsa_dn) {
4184                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4185                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4186                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4188                 }
4189                 if (r->transport_dn) {
4190                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4191                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4192                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4194                 }
4195                 if (r->source_dsa_address) {
4196                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4197                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4198                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4199                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4200                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4201                                 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));
4202                         }
4203                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4204                         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));
4205                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4206                 }
4207         }
4208         return NDR_ERR_SUCCESS;
4209 }
4210
4211 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4212 {
4213         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4214         ndr->depth++;
4215         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4216         ndr->depth++;
4217         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4218         ndr->depth--;
4219         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4220         ndr->depth++;
4221         if (r->source_dsa_dn) {
4222                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4223         }
4224         ndr->depth--;
4225         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4226         ndr->depth++;
4227         if (r->transport_dn) {
4228                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4229         }
4230         ndr->depth--;
4231         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4232         ndr->depth++;
4233         if (r->source_dsa_address) {
4234                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4235         }
4236         ndr->depth--;
4237         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4238         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4239         ndr->depth--;
4240 }
4241
4242 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4243 {
4244         if (ndr_flags & NDR_SCALARS) {
4245                 int level = ndr_push_get_switch_value(ndr, r);
4246                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4247                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4248                 switch (level) {
4249                         case 1: {
4250                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4251                         break; }
4252
4253                         case 2: {
4254                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4255                         break; }
4256
4257                         default:
4258                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4259                 }
4260         }
4261         if (ndr_flags & NDR_BUFFERS) {
4262                 int level = ndr_push_get_switch_value(ndr, r);
4263                 switch (level) {
4264                         case 1:
4265                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4266                         break;
4267
4268                         case 2:
4269                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4270                         break;
4271
4272                         default:
4273                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4274                 }
4275         }
4276         return NDR_ERR_SUCCESS;
4277 }
4278
4279 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4280 {
4281         int level;
4282         int32_t _level;
4283         level = ndr_pull_get_switch_value(ndr, r);
4284         if (ndr_flags & NDR_SCALARS) {
4285                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4286                 if (_level != level) {
4287                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4288                 }
4289                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4290                 switch (level) {
4291                         case 1: {
4292                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4293                         break; }
4294
4295                         case 2: {
4296                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4297                         break; }
4298
4299                         default:
4300                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4301                 }
4302         }
4303         if (ndr_flags & NDR_BUFFERS) {
4304                 switch (level) {
4305                         case 1:
4306                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4307                         break;
4308
4309                         case 2:
4310                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4311                         break;
4312
4313                         default:
4314                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4315                 }
4316         }
4317         return NDR_ERR_SUCCESS;
4318 }
4319
4320 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4321 {
4322         int level;
4323         level = ndr_print_get_switch_value(ndr, r);
4324         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4325         switch (level) {
4326                 case 1:
4327                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4328                 break;
4329
4330                 case 2:
4331                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4332                 break;
4333
4334                 default:
4335                         ndr_print_bad_level(ndr, name, level);
4336         }
4337 }
4338
4339 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4340 {
4341         if (ndr_flags & NDR_SCALARS) {
4342                 NDR_CHECK(ndr_push_align(ndr, 5));
4343                 if (r->naming_context == NULL) {
4344                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4345                 }
4346                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4348                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4349                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4350         }
4351         if (ndr_flags & NDR_BUFFERS) {
4352                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4353                 if (r->source_dsa_address) {
4354                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4355                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4356                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4357                         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));
4358                 }
4359         }
4360         return NDR_ERR_SUCCESS;
4361 }
4362
4363 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4364 {
4365         uint32_t _ptr_naming_context;
4366         TALLOC_CTX *_mem_save_naming_context_0;
4367         uint32_t _ptr_source_dsa_address;
4368         TALLOC_CTX *_mem_save_source_dsa_address_0;
4369         if (ndr_flags & NDR_SCALARS) {
4370                 NDR_CHECK(ndr_pull_align(ndr, 5));
4371                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4372                 if (_ptr_naming_context) {
4373                         NDR_PULL_ALLOC(ndr, r->naming_context);
4374                 } else {
4375                         r->naming_context = NULL;
4376                 }
4377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4378                 if (_ptr_source_dsa_address) {
4379                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4380                 } else {
4381                         r->source_dsa_address = NULL;
4382                 }
4383                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4384                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4385         }
4386         if (ndr_flags & NDR_BUFFERS) {
4387                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4388                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4389                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4390                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4391                 if (r->source_dsa_address) {
4392                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4393                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4394                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4395                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4396                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4397                                 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));
4398                         }
4399                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4400                         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));
4401                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4402                 }
4403         }
4404         return NDR_ERR_SUCCESS;
4405 }
4406
4407 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4408 {
4409         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4410         ndr->depth++;
4411         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4412         ndr->depth++;
4413         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4414         ndr->depth--;
4415         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4416         ndr->depth++;
4417         if (r->source_dsa_address) {
4418                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4419         }
4420         ndr->depth--;
4421         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4422         ndr->depth--;
4423 }
4424
4425 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4426 {
4427         if (ndr_flags & NDR_SCALARS) {
4428                 int level = ndr_push_get_switch_value(ndr, r);
4429                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4430                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4431                 switch (level) {
4432                         case 1: {
4433                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4434                         break; }
4435
4436                         default:
4437                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4438                 }
4439         }
4440         if (ndr_flags & NDR_BUFFERS) {
4441                 int level = ndr_push_get_switch_value(ndr, r);
4442                 switch (level) {
4443                         case 1:
4444                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4445                         break;
4446
4447                         default:
4448                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4449                 }
4450         }
4451         return NDR_ERR_SUCCESS;
4452 }
4453
4454 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4455 {
4456         int level;
4457         int32_t _level;
4458         level = ndr_pull_get_switch_value(ndr, r);
4459         if (ndr_flags & NDR_SCALARS) {
4460                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4461                 if (_level != level) {
4462                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4463                 }
4464                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4465                 switch (level) {
4466                         case 1: {
4467                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4468                         break; }
4469
4470                         default:
4471                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4472                 }
4473         }
4474         if (ndr_flags & NDR_BUFFERS) {
4475                 switch (level) {
4476                         case 1:
4477                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4478                         break;
4479
4480                         default:
4481                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4482                 }
4483         }
4484         return NDR_ERR_SUCCESS;
4485 }
4486
4487 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4488 {
4489         int level;
4490         level = ndr_print_get_switch_value(ndr, r);
4491         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4492         switch (level) {
4493                 case 1:
4494                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4495                 break;
4496
4497                 default:
4498                         ndr_print_bad_level(ndr, name, level);
4499         }
4500 }
4501
4502 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4503 {
4504         if (ndr_flags & NDR_SCALARS) {
4505                 NDR_CHECK(ndr_push_align(ndr, 5));
4506                 if (r->naming_context == NULL) {
4507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4508                 }
4509                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4510                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4512                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4515                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4516                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4517         }
4518         if (ndr_flags & NDR_BUFFERS) {
4519                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4520                 if (r->source_dra_address) {
4521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4524                         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));
4525                 }
4526         }
4527         return NDR_ERR_SUCCESS;
4528 }
4529
4530 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4531 {
4532         uint32_t _ptr_naming_context;
4533         TALLOC_CTX *_mem_save_naming_context_0;
4534         uint32_t _ptr_source_dra_address;
4535         TALLOC_CTX *_mem_save_source_dra_address_0;
4536         if (ndr_flags & NDR_SCALARS) {
4537                 NDR_CHECK(ndr_pull_align(ndr, 5));
4538                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4539                 if (_ptr_naming_context) {
4540                         NDR_PULL_ALLOC(ndr, r->naming_context);
4541                 } else {
4542                         r->naming_context = NULL;
4543                 }
4544                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4546                 if (_ptr_source_dra_address) {
4547                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4548                 } else {
4549                         r->source_dra_address = NULL;
4550                 }
4551                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4554                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4555                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4556         }
4557         if (ndr_flags & NDR_BUFFERS) {
4558                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4559                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4560                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4562                 if (r->source_dra_address) {
4563                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4564                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4565                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4566                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4567                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4568                                 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));
4569                         }
4570                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4571                         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));
4572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4573                 }
4574         }
4575         return NDR_ERR_SUCCESS;
4576 }
4577
4578 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4579 {
4580         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4581         ndr->depth++;
4582         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4583         ndr->depth++;
4584         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4585         ndr->depth--;
4586         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4587         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4588         ndr->depth++;
4589         if (r->source_dra_address) {
4590                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4591         }
4592         ndr->depth--;
4593         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4594         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4595         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4596         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4597         ndr->depth--;
4598 }
4599
4600 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4601 {
4602         if (ndr_flags & NDR_SCALARS) {
4603                 int level = ndr_push_get_switch_value(ndr, r);
4604                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4605                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4606                 switch (level) {
4607                         case 1: {
4608                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4609                         break; }
4610
4611                         default:
4612                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4613                 }
4614         }
4615         if (ndr_flags & NDR_BUFFERS) {
4616                 int level = ndr_push_get_switch_value(ndr, r);
4617                 switch (level) {
4618                         case 1:
4619                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4620                         break;
4621
4622                         default:
4623                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4624                 }
4625         }
4626         return NDR_ERR_SUCCESS;
4627 }
4628
4629 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4630 {
4631         int level;
4632         int32_t _level;
4633         level = ndr_pull_get_switch_value(ndr, r);
4634         if (ndr_flags & NDR_SCALARS) {
4635                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4636                 if (_level != level) {
4637                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4638                 }
4639                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4640                 switch (level) {
4641                         case 1: {
4642                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4643                         break; }
4644
4645                         default:
4646                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4647                 }
4648         }
4649         if (ndr_flags & NDR_BUFFERS) {
4650                 switch (level) {
4651                         case 1:
4652                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4653                         break;
4654
4655                         default:
4656                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4657                 }
4658         }
4659         return NDR_ERR_SUCCESS;
4660 }
4661
4662 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4663 {
4664         int level;
4665         level = ndr_print_get_switch_value(ndr, r);
4666         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4667         switch (level) {
4668                 case 1:
4669                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4670                 break;
4671
4672                 default:
4673                         ndr_print_bad_level(ndr, name, level);
4674         }
4675 }
4676
4677 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4678 {
4679         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4680         return NDR_ERR_SUCCESS;
4681 }
4682
4683 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4684 {
4685         uint32_t v;
4686         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4687         *r = v;
4688         return NDR_ERR_SUCCESS;
4689 }
4690
4691 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4692 {
4693         const char *val = NULL;
4694
4695         switch (r) {
4696                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4697                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4698                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4699                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4700                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4701                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4702                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4703         }
4704         ndr_print_enum(ndr, name, "ENUM", val, r);
4705 }
4706
4707 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4708 {
4709         uint32_t cntr_info_array_1;
4710         uint32_t cntr_group_attrs_1;
4711         uint32_t cntr_sids_1;
4712         if (ndr_flags & NDR_SCALARS) {
4713                 NDR_CHECK(ndr_push_align(ndr, 5));
4714                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4720                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4721         }
4722         if (ndr_flags & NDR_BUFFERS) {
4723                 if (r->info_array) {
4724                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4725                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4726                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4727                         }
4728                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4729                                 if (r->info_array[cntr_info_array_1]) {
4730                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4731                                 }
4732                         }
4733                 }
4734                 if (r->group_attrs) {
4735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4736                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4737                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4738                         }
4739                 }
4740                 if (r->sids) {
4741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4742                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4743                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4744                         }
4745                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4746                                 if (r->sids[cntr_sids_1]) {
4747                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4748                                 }
4749                         }
4750                 }
4751         }
4752         return NDR_ERR_SUCCESS;
4753 }
4754
4755 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4756 {
4757         uint32_t _ptr_info_array;
4758         uint32_t cntr_info_array_1;
4759         TALLOC_CTX *_mem_save_info_array_0;
4760         TALLOC_CTX *_mem_save_info_array_1;
4761         TALLOC_CTX *_mem_save_info_array_2;
4762         uint32_t _ptr_group_attrs;
4763         uint32_t cntr_group_attrs_1;
4764         TALLOC_CTX *_mem_save_group_attrs_0;
4765         TALLOC_CTX *_mem_save_group_attrs_1;
4766         uint32_t _ptr_sids;
4767         uint32_t cntr_sids_1;
4768         TALLOC_CTX *_mem_save_sids_0;
4769         TALLOC_CTX *_mem_save_sids_1;
4770         TALLOC_CTX *_mem_save_sids_2;
4771         if (ndr_flags & NDR_SCALARS) {
4772                 NDR_CHECK(ndr_pull_align(ndr, 5));
4773                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4775                 if (r->num_memberships > 10000) {
4776                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4777                 }
4778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4779                 if (r->num_sids > 10000) {
4780                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4781                 }
4782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4783                 if (_ptr_info_array) {
4784                         NDR_PULL_ALLOC(ndr, r->info_array);
4785                 } else {
4786                         r->info_array = NULL;
4787                 }
4788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4789                 if (_ptr_group_attrs) {
4790                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4791                 } else {
4792                         r->group_attrs = NULL;
4793                 }
4794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4795                 if (_ptr_sids) {
4796                         NDR_PULL_ALLOC(ndr, r->sids);
4797                 } else {
4798                         r->sids = NULL;
4799                 }
4800                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4801         }
4802         if (ndr_flags & NDR_BUFFERS) {
4803                 if (r->info_array) {
4804                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4805                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4806                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4807                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4808                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4809                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4810                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4811                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4812                                 if (_ptr_info_array) {
4813                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4814                                 } else {
4815                                         r->info_array[cntr_info_array_1] = NULL;
4816                                 }
4817                         }
4818                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4819                                 if (r->info_array[cntr_info_array_1]) {
4820                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4821                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4822                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4823                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4824                                 }
4825                         }
4826                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4828                 }
4829                 if (r->group_attrs) {
4830                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4831                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4832                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4833                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4834                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4835                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4836                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4837                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4838                         }
4839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4840                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4841                 }
4842                 if (r->sids) {
4843                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4844                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4845                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4846                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4847                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4848                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4849                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4850                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4851                                 if (_ptr_sids) {
4852                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4853                                 } else {
4854                                         r->sids[cntr_sids_1] = NULL;
4855                                 }
4856                         }
4857                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4858                                 if (r->sids[cntr_sids_1]) {
4859                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4860                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4861                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4862                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4863                                 }
4864                         }
4865                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4866                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4867                 }
4868                 if (r->info_array) {
4869                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4870                 }
4871                 if (r->group_attrs) {
4872                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4873                 }
4874                 if (r->sids) {
4875                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4876                 }
4877         }
4878         return NDR_ERR_SUCCESS;
4879 }
4880
4881 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4882 {
4883         uint32_t cntr_info_array_1;
4884         uint32_t cntr_group_attrs_1;
4885         uint32_t cntr_sids_1;
4886         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4887         ndr->depth++;
4888         ndr_print_NTSTATUS(ndr, "status", r->status);
4889         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4890         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4891         ndr_print_ptr(ndr, "info_array", r->info_array);
4892         ndr->depth++;
4893         if (r->info_array) {
4894                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4895                 ndr->depth++;
4896                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4897                         char *idx_1=NULL;
4898                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4899                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4900                                 ndr->depth++;
4901                                 if (r->info_array[cntr_info_array_1]) {
4902                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4903                                 }
4904                                 ndr->depth--;
4905                                 free(idx_1);
4906                         }
4907                 }
4908                 ndr->depth--;
4909         }
4910         ndr->depth--;
4911         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4912         ndr->depth++;
4913         if (r->group_attrs) {
4914                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4915                 ndr->depth++;
4916                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4917                         char *idx_1=NULL;
4918                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4919                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4920                                 free(idx_1);
4921                         }
4922                 }
4923                 ndr->depth--;
4924         }
4925         ndr->depth--;
4926         ndr_print_ptr(ndr, "sids", r->sids);
4927         ndr->depth++;
4928         if (r->sids) {
4929                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4930                 ndr->depth++;
4931                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4932                         char *idx_1=NULL;
4933                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4934                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4935                                 ndr->depth++;
4936                                 if (r->sids[cntr_sids_1]) {
4937                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4938                                 }
4939                                 ndr->depth--;
4940                                 free(idx_1);
4941                         }
4942                 }
4943                 ndr->depth--;
4944         }
4945         ndr->depth--;
4946         ndr->depth--;
4947 }
4948
4949 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4950 {
4951         if (ndr_flags & NDR_SCALARS) {
4952                 int level = ndr_push_get_switch_value(ndr, r);
4953                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4954                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4955                 switch (level) {
4956                         case 1: {
4957                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4958                         break; }
4959
4960                         default:
4961                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4962                 }
4963         }
4964         if (ndr_flags & NDR_BUFFERS) {
4965                 int level = ndr_push_get_switch_value(ndr, r);
4966                 switch (level) {
4967                         case 1:
4968                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4969                         break;
4970
4971                         default:
4972                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4973                 }
4974         }
4975         return NDR_ERR_SUCCESS;
4976 }
4977
4978 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4979 {
4980         int level;
4981         int32_t _level;
4982         level = ndr_pull_get_switch_value(ndr, r);
4983         if (ndr_flags & NDR_SCALARS) {
4984                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4985                 if (_level != level) {
4986                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4987                 }
4988                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4989                 switch (level) {
4990                         case 1: {
4991                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4992                         break; }
4993
4994                         default:
4995                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4996                 }
4997         }
4998         if (ndr_flags & NDR_BUFFERS) {
4999                 switch (level) {
5000                         case 1:
5001                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
5002                         break;
5003
5004                         default:
5005                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5006                 }
5007         }
5008         return NDR_ERR_SUCCESS;
5009 }
5010
5011 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
5012 {
5013         int level;
5014         level = ndr_print_get_switch_value(ndr, r);
5015         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
5016         switch (level) {
5017                 case 1:
5018                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
5019                 break;
5020
5021                 default:
5022                         ndr_print_bad_level(ndr, name, level);
5023         }
5024 }
5025
5026 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
5027 {
5028         uint32_t cntr_info_array_1;
5029         if (ndr_flags & NDR_SCALARS) {
5030                 NDR_CHECK(ndr_push_align(ndr, 5));
5031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
5033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
5034                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
5035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
5036                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5037         }
5038         if (ndr_flags & NDR_BUFFERS) {
5039                 if (r->info_array) {
5040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5041                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5042                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
5043                         }
5044                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5045                                 if (r->info_array[cntr_info_array_1]) {
5046                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5047                                 }
5048                         }
5049                 }
5050                 if (r->domain) {
5051                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5052                 }
5053         }
5054         return NDR_ERR_SUCCESS;
5055 }
5056
5057 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5058 {
5059         uint32_t _ptr_info_array;
5060         uint32_t cntr_info_array_1;
5061         TALLOC_CTX *_mem_save_info_array_0;
5062         TALLOC_CTX *_mem_save_info_array_1;
5063         TALLOC_CTX *_mem_save_info_array_2;
5064         uint32_t _ptr_domain;
5065         TALLOC_CTX *_mem_save_domain_0;
5066         if (ndr_flags & NDR_SCALARS) {
5067                 NDR_CHECK(ndr_pull_align(ndr, 5));
5068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5069                 if (r->count < 1 || r->count > 10000) {
5070                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5071                 }
5072                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5073                 if (_ptr_info_array) {
5074                         NDR_PULL_ALLOC(ndr, r->info_array);
5075                 } else {
5076                         r->info_array = NULL;
5077                 }
5078                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5079                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
5080                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
5081                 if (_ptr_domain) {
5082                         NDR_PULL_ALLOC(ndr, r->domain);
5083                 } else {
5084                         r->domain = NULL;
5085                 }
5086                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5087         }
5088         if (ndr_flags & NDR_BUFFERS) {
5089                 if (r->info_array) {
5090                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5091                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5092                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5093                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5094                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5095                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5096                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5097                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5098                                 if (_ptr_info_array) {
5099                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5100                                 } else {
5101                                         r->info_array[cntr_info_array_1] = NULL;
5102                                 }
5103                         }
5104                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5105                                 if (r->info_array[cntr_info_array_1]) {
5106                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5107                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5108                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5109                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5110                                 }
5111                         }
5112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5114                 }
5115                 if (r->domain) {
5116                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5117                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5118                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5120                 }
5121                 if (r->info_array) {
5122                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5123                 }
5124         }
5125         return NDR_ERR_SUCCESS;
5126 }
5127
5128 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5129 {
5130         uint32_t cntr_info_array_1;
5131         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5132         ndr->depth++;
5133         ndr_print_uint32(ndr, "count", r->count);
5134         ndr_print_ptr(ndr, "info_array", r->info_array);
5135         ndr->depth++;
5136         if (r->info_array) {
5137                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5138                 ndr->depth++;
5139                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5140                         char *idx_1=NULL;
5141                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5142                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5143                                 ndr->depth++;
5144                                 if (r->info_array[cntr_info_array_1]) {
5145                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5146                                 }
5147                                 ndr->depth--;
5148                                 free(idx_1);
5149                         }
5150                 }
5151                 ndr->depth--;
5152         }
5153         ndr->depth--;
5154         ndr_print_uint32(ndr, "flags", r->flags);
5155         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5156         ndr_print_ptr(ndr, "domain", r->domain);
5157         ndr->depth++;
5158         if (r->domain) {
5159                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5160         }
5161         ndr->depth--;
5162         ndr->depth--;
5163 }
5164
5165 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5166 {
5167         if (ndr_flags & NDR_SCALARS) {
5168                 int level = ndr_push_get_switch_value(ndr, r);
5169                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5170                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5171                 switch (level) {
5172                         case 1: {
5173                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5174                         break; }
5175
5176                         default:
5177                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5178                 }
5179         }
5180         if (ndr_flags & NDR_BUFFERS) {
5181                 int level = ndr_push_get_switch_value(ndr, r);
5182                 switch (level) {
5183                         case 1:
5184                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5185                         break;
5186
5187                         default:
5188                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5189                 }
5190         }
5191         return NDR_ERR_SUCCESS;
5192 }
5193
5194 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5195 {
5196         int level;
5197         int32_t _level;
5198         level = ndr_pull_get_switch_value(ndr, r);
5199         if (ndr_flags & NDR_SCALARS) {
5200                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5201                 if (_level != level) {
5202                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5203                 }
5204                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5205                 switch (level) {
5206                         case 1: {
5207                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5208                         break; }
5209
5210                         default:
5211                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5212                 }
5213         }
5214         if (ndr_flags & NDR_BUFFERS) {
5215                 switch (level) {
5216                         case 1:
5217                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5218                         break;
5219
5220                         default:
5221                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5222                 }
5223         }
5224         return NDR_ERR_SUCCESS;
5225 }
5226
5227 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5228 {
5229         int level;
5230         level = ndr_print_get_switch_value(ndr, r);
5231         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5232         switch (level) {
5233                 case 1:
5234                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5235                 break;
5236
5237                 default:
5238                         ndr_print_bad_level(ndr, name, level);
5239         }
5240 }
5241
5242 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5243 {
5244         if (ndr_flags & NDR_SCALARS) {
5245                 NDR_CHECK(ndr_push_align(ndr, 5));
5246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5249                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5250                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5251         }
5252         if (ndr_flags & NDR_BUFFERS) {
5253                 if (r->data) {
5254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5255                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5256                 }
5257         }
5258         return NDR_ERR_SUCCESS;
5259 }
5260
5261 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5262 {
5263         uint32_t _ptr_data;
5264         TALLOC_CTX *_mem_save_data_0;
5265         if (ndr_flags & NDR_SCALARS) {
5266                 NDR_CHECK(ndr_pull_align(ndr, 5));
5267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5270                 if (r->length > 0x00A00000) {
5271                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5272                 }
5273                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5274                 if (_ptr_data) {
5275                         NDR_PULL_ALLOC(ndr, r->data);
5276                 } else {
5277                         r->data = NULL;
5278                 }
5279                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5280         }
5281         if (ndr_flags & NDR_BUFFERS) {
5282                 if (r->data) {
5283                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5284                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5286                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5287                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5289                 }
5290                 if (r->data) {
5291                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5292                 }
5293         }
5294         return NDR_ERR_SUCCESS;
5295 }
5296
5297 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5298 {
5299         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5300         ndr->depth++;
5301         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5302         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5303         ndr_print_uint32(ndr, "length", r->length);
5304         ndr_print_ptr(ndr, "data", r->data);
5305         ndr->depth++;
5306         if (r->data) {
5307                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5308         }
5309         ndr->depth--;
5310         ndr->depth--;
5311 }
5312
5313 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5314 {
5315         if (ndr_flags & NDR_SCALARS) {
5316                 int level = ndr_push_get_switch_value(ndr, r);
5317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5318                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5319                 switch (level) {
5320                         case 1: {
5321                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5322                         break; }
5323
5324                         default:
5325                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5326                 }
5327         }
5328         if (ndr_flags & NDR_BUFFERS) {
5329                 int level = ndr_push_get_switch_value(ndr, r);
5330                 switch (level) {
5331                         case 1:
5332                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5333                         break;
5334
5335                         default:
5336                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5337                 }
5338         }
5339         return NDR_ERR_SUCCESS;
5340 }
5341
5342 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5343 {
5344         int level;
5345         uint32_t _level;
5346         level = ndr_pull_get_switch_value(ndr, r);
5347         if (ndr_flags & NDR_SCALARS) {
5348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5349                 if (_level != level) {
5350                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5351                 }
5352                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5353                 switch (level) {
5354                         case 1: {
5355                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5356                         break; }
5357
5358                         default:
5359                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5360                 }
5361         }
5362         if (ndr_flags & NDR_BUFFERS) {
5363                 switch (level) {
5364                         case 1:
5365                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5366                         break;
5367
5368                         default:
5369                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5370                 }
5371         }
5372         return NDR_ERR_SUCCESS;
5373 }
5374
5375 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5376 {
5377         int level;
5378         level = ndr_print_get_switch_value(ndr, r);
5379         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5380         switch (level) {
5381                 case 1:
5382                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5383                 break;
5384
5385                 default:
5386                         ndr_print_bad_level(ndr, name, level);
5387         }
5388 }
5389
5390 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5391 {
5392         if (ndr_flags & NDR_SCALARS) {
5393                 NDR_CHECK(ndr_push_align(ndr, 8));
5394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5396                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5397                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5398                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5399                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5400                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5401                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5402                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5405                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5406         }
5407         if (ndr_flags & NDR_BUFFERS) {
5408                 if (r->data1) {
5409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5410                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5411                 }
5412                 if (r->data2) {
5413                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5414                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5415                 }
5416         }
5417         return NDR_ERR_SUCCESS;
5418 }
5419
5420 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5421 {
5422         uint32_t _ptr_data1;
5423         TALLOC_CTX *_mem_save_data1_0;
5424         uint32_t _ptr_data2;
5425         TALLOC_CTX *_mem_save_data2_0;
5426         if (ndr_flags & NDR_SCALARS) {
5427                 NDR_CHECK(ndr_pull_align(ndr, 8));
5428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5429                 if (r->length1 > 0x00A00000) {
5430                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5431                 }
5432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5433                 if (r->length2 > 0x00A00000) {
5434                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5435                 }
5436                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5437                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5438                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5439                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5440                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5441                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5442                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5443                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5444                 if (_ptr_data1) {
5445                         NDR_PULL_ALLOC(ndr, r->data1);
5446                 } else {
5447                         r->data1 = NULL;
5448                 }
5449                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5450                 if (_ptr_data2) {
5451                         NDR_PULL_ALLOC(ndr, r->data2);
5452                 } else {
5453                         r->data2 = NULL;
5454                 }
5455                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5456         }
5457         if (ndr_flags & NDR_BUFFERS) {
5458                 if (r->data1) {
5459                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5460                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5462                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5463                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5464                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5465                 }
5466                 if (r->data2) {
5467                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5468                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5469                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5470                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5471                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5472                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5473                 }
5474                 if (r->data1) {
5475                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5476                 }
5477                 if (r->data2) {
5478                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5479                 }
5480         }
5481         return NDR_ERR_SUCCESS;
5482 }
5483
5484 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5485 {
5486         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5487         ndr->depth++;
5488         ndr_print_uint32(ndr, "length1", r->length1);
5489         ndr_print_uint32(ndr, "length2", r->length2);
5490         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5491         ndr_print_NTTIME(ndr, "time2", r->time2);
5492         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5493         ndr_print_NTTIME(ndr, "time4", r->time4);
5494         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5495         ndr_print_NTTIME(ndr, "time6", r->time6);
5496         ndr_print_NTSTATUS(ndr, "status", r->status);
5497         ndr_print_ptr(ndr, "data1", r->data1);
5498         ndr->depth++;
5499         if (r->data1) {
5500                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5501         }
5502         ndr->depth--;
5503         ndr_print_ptr(ndr, "data2", r->data2);
5504         ndr->depth++;
5505         if (r->data2) {
5506                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5507         }
5508         ndr->depth--;
5509         ndr->depth--;
5510 }
5511
5512 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5513 {
5514         if (ndr_flags & NDR_SCALARS) {
5515                 int level = ndr_push_get_switch_value(ndr, r);
5516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5517                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5518                 switch (level) {
5519                         case 1: {
5520                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5521                         break; }
5522
5523                         default:
5524                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5525                 }
5526         }
5527         if (ndr_flags & NDR_BUFFERS) {
5528                 int level = ndr_push_get_switch_value(ndr, r);
5529                 switch (level) {
5530                         case 1:
5531                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5532                         break;
5533
5534                         default:
5535                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5536                 }
5537         }
5538         return NDR_ERR_SUCCESS;
5539 }
5540
5541 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5542 {
5543         int level;
5544         uint32_t _level;
5545         level = ndr_pull_get_switch_value(ndr, r);
5546         if (ndr_flags & NDR_SCALARS) {
5547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5548                 if (_level != level) {
5549                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5550                 }
5551                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5552                 switch (level) {
5553                         case 1: {
5554                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5555                         break; }
5556
5557                         default:
5558                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5559                 }
5560         }
5561         if (ndr_flags & NDR_BUFFERS) {
5562                 switch (level) {
5563                         case 1:
5564                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5565                         break;
5566
5567                         default:
5568                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5569                 }
5570         }
5571         return NDR_ERR_SUCCESS;
5572 }
5573
5574 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5575 {
5576         int level;
5577         level = ndr_print_get_switch_value(ndr, r);
5578         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5579         switch (level) {
5580                 case 1:
5581                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5582                 break;
5583
5584                 default:
5585                         ndr_print_bad_level(ndr, name, level);
5586         }
5587 }
5588
5589 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5590 {
5591         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5592         return NDR_ERR_SUCCESS;
5593 }
5594
5595 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5596 {
5597         uint32_t v;
5598         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5599         *r = v;
5600         return NDR_ERR_SUCCESS;
5601 }
5602
5603 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5604 {
5605         const char *val = NULL;
5606
5607         switch (r) {
5608                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5609                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5610                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5611                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5612                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5613                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5614                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5615                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5616         }
5617         ndr_print_enum(ndr, name, "ENUM", val, r);
5618 }
5619
5620 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5621 {
5622         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5623         return NDR_ERR_SUCCESS;
5624 }
5625
5626 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5627 {
5628         uint32_t v;
5629         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5630         *r = v;
5631         return NDR_ERR_SUCCESS;
5632 }
5633
5634 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5635 {
5636         const char *val = NULL;
5637
5638         switch (r) {
5639                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5640                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5641                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5642                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5643                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5644         }
5645         ndr_print_enum(ndr, name, "ENUM", val, r);
5646 }
5647
5648 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5649 {
5650         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5651         return NDR_ERR_SUCCESS;
5652 }
5653
5654 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5655 {
5656         uint32_t v;
5657         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5658         *r = v;
5659         return NDR_ERR_SUCCESS;
5660 }
5661
5662 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5663 {
5664         const char *val = NULL;
5665
5666         switch (r) {
5667                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5668                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5669                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5670                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5671                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5672                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5673                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5674                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5675                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5676                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5677                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5678         }
5679         ndr_print_enum(ndr, name, "ENUM", val, r);
5680 }
5681
5682 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5683 {
5684         if (ndr_flags & NDR_SCALARS) {
5685                 NDR_CHECK(ndr_push_align(ndr, 5));
5686                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5687                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5688         }
5689         if (ndr_flags & NDR_BUFFERS) {
5690                 if (r->str) {
5691                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5694                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5695                 }
5696         }
5697         return NDR_ERR_SUCCESS;
5698 }
5699
5700 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5701 {
5702         uint32_t _ptr_str;
5703         TALLOC_CTX *_mem_save_str_0;
5704         if (ndr_flags & NDR_SCALARS) {
5705                 NDR_CHECK(ndr_pull_align(ndr, 5));
5706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5707                 if (_ptr_str) {
5708                         NDR_PULL_ALLOC(ndr, r->str);
5709                 } else {
5710                         r->str = NULL;
5711                 }
5712                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5713         }
5714         if (ndr_flags & NDR_BUFFERS) {
5715                 if (r->str) {
5716                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5717                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5718                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5719                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5720                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5721                                 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));
5722                         }
5723                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5724                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5726                 }
5727         }
5728         return NDR_ERR_SUCCESS;
5729 }
5730
5731 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5732 {
5733         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5734         ndr->depth++;
5735         ndr_print_ptr(ndr, "str", r->str);
5736         ndr->depth++;
5737         if (r->str) {
5738                 ndr_print_string(ndr, "str", r->str);
5739         }
5740         ndr->depth--;
5741         ndr->depth--;
5742 }
5743
5744 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5745 {
5746         uint32_t cntr_names_1;
5747         if (ndr_flags & NDR_SCALARS) {
5748                 NDR_CHECK(ndr_push_align(ndr, 5));
5749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5751                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5752                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5753                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5756                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5757         }
5758         if (ndr_flags & NDR_BUFFERS) {
5759                 if (r->names) {
5760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5761                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5762                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5763                         }
5764                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5765                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5766                         }
5767                 }
5768         }
5769         return NDR_ERR_SUCCESS;
5770 }
5771
5772 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5773 {
5774         uint32_t _ptr_names;
5775         uint32_t cntr_names_1;
5776         TALLOC_CTX *_mem_save_names_0;
5777         TALLOC_CTX *_mem_save_names_1;
5778         if (ndr_flags & NDR_SCALARS) {
5779                 NDR_CHECK(ndr_pull_align(ndr, 5));
5780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5782                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5783                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5784                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5786                 if (r->count < 1 || r->count > 10000) {
5787                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5788                 }
5789                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5790                 if (_ptr_names) {
5791                         NDR_PULL_ALLOC(ndr, r->names);
5792                 } else {
5793                         r->names = NULL;
5794                 }
5795                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5796         }
5797         if (ndr_flags & NDR_BUFFERS) {
5798                 if (r->names) {
5799                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5800                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5801                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5802                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5803                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5804                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5805                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5806                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5807                         }
5808                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5809                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5810                         }
5811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5813                 }
5814                 if (r->names) {
5815                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5816                 }
5817         }
5818         return NDR_ERR_SUCCESS;
5819 }
5820
5821 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5822 {
5823         uint32_t cntr_names_1;
5824         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5825         ndr->depth++;
5826         ndr_print_uint32(ndr, "codepage", r->codepage);
5827         ndr_print_uint32(ndr, "language", r->language);
5828         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5829         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5830         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5831         ndr_print_uint32(ndr, "count", r->count);
5832         ndr_print_ptr(ndr, "names", r->names);
5833         ndr->depth++;
5834         if (r->names) {
5835                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5836                 ndr->depth++;
5837                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5838                         char *idx_1=NULL;
5839                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5840                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5841                                 free(idx_1);
5842                         }
5843                 }
5844                 ndr->depth--;
5845         }
5846         ndr->depth--;
5847         ndr->depth--;
5848 }
5849
5850 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5851 {
5852         if (ndr_flags & NDR_SCALARS) {
5853                 int level = ndr_push_get_switch_value(ndr, r);
5854                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5855                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5856                 switch (level) {
5857                         case 1: {
5858                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5859                         break; }
5860
5861                         default:
5862                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5863                 }
5864         }
5865         if (ndr_flags & NDR_BUFFERS) {
5866                 int level = ndr_push_get_switch_value(ndr, r);
5867                 switch (level) {
5868                         case 1:
5869                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5870                         break;
5871
5872                         default:
5873                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5874                 }
5875         }
5876         return NDR_ERR_SUCCESS;
5877 }
5878
5879 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5880 {
5881         int level;
5882         int32_t _level;
5883         level = ndr_pull_get_switch_value(ndr, r);
5884         if (ndr_flags & NDR_SCALARS) {
5885                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5886                 if (_level != level) {
5887                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5888                 }
5889                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5890                 switch (level) {
5891                         case 1: {
5892                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5893                         break; }
5894
5895                         default:
5896                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5897                 }
5898         }
5899         if (ndr_flags & NDR_BUFFERS) {
5900                 switch (level) {
5901                         case 1:
5902                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5903                         break;
5904
5905                         default:
5906                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5907                 }
5908         }
5909         return NDR_ERR_SUCCESS;
5910 }
5911
5912 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5913 {
5914         int level;
5915         level = ndr_print_get_switch_value(ndr, r);
5916         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5917         switch (level) {
5918                 case 1:
5919                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5920                 break;
5921
5922                 default:
5923                         ndr_print_bad_level(ndr, name, level);
5924         }
5925 }
5926
5927 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5928 {
5929         if (ndr_flags & NDR_SCALARS) {
5930                 NDR_CHECK(ndr_push_align(ndr, 5));
5931                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5932                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5934                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5935         }
5936         if (ndr_flags & NDR_BUFFERS) {
5937                 if (r->dns_domain_name) {
5938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5940                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5941                         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));
5942                 }
5943                 if (r->result_name) {
5944                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5945                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5946                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5947                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5948                 }
5949         }
5950         return NDR_ERR_SUCCESS;
5951 }
5952
5953 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5954 {
5955         uint32_t _ptr_dns_domain_name;
5956         TALLOC_CTX *_mem_save_dns_domain_name_0;
5957         uint32_t _ptr_result_name;
5958         TALLOC_CTX *_mem_save_result_name_0;
5959         if (ndr_flags & NDR_SCALARS) {
5960                 NDR_CHECK(ndr_pull_align(ndr, 5));
5961                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5963                 if (_ptr_dns_domain_name) {
5964                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5965                 } else {
5966                         r->dns_domain_name = NULL;
5967                 }
5968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5969                 if (_ptr_result_name) {
5970                         NDR_PULL_ALLOC(ndr, r->result_name);
5971                 } else {
5972                         r->result_name = NULL;
5973                 }
5974                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5975         }
5976         if (ndr_flags & NDR_BUFFERS) {
5977                 if (r->dns_domain_name) {
5978                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5979                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5982                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5983                                 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));
5984                         }
5985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5986                         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));
5987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5988                 }
5989                 if (r->result_name) {
5990                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5991                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5992                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5993                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5994                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5995                                 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));
5996                         }
5997                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5998                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
6000                 }
6001         }
6002         return NDR_ERR_SUCCESS;
6003 }
6004
6005 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
6006 {
6007         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
6008         ndr->depth++;
6009         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
6010         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
6011         ndr->depth++;
6012         if (r->dns_domain_name) {
6013                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
6014         }
6015         ndr->depth--;
6016         ndr_print_ptr(ndr, "result_name", r->result_name);
6017         ndr->depth++;
6018         if (r->result_name) {
6019                 ndr_print_string(ndr, "result_name", r->result_name);
6020         }
6021         ndr->depth--;
6022         ndr->depth--;
6023 }
6024
6025 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
6026 {
6027         uint32_t cntr_array_1;
6028         if (ndr_flags & NDR_SCALARS) {
6029                 NDR_CHECK(ndr_push_align(ndr, 5));
6030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6032                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6033         }
6034         if (ndr_flags & NDR_BUFFERS) {
6035                 if (r->array) {
6036                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6037                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6038                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6039                         }
6040                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6041                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6042                         }
6043                 }
6044         }
6045         return NDR_ERR_SUCCESS;
6046 }
6047
6048 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6049 {
6050         uint32_t _ptr_array;
6051         uint32_t cntr_array_1;
6052         TALLOC_CTX *_mem_save_array_0;
6053         TALLOC_CTX *_mem_save_array_1;
6054         if (ndr_flags & NDR_SCALARS) {
6055                 NDR_CHECK(ndr_pull_align(ndr, 5));
6056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6058                 if (_ptr_array) {
6059                         NDR_PULL_ALLOC(ndr, r->array);
6060                 } else {
6061                         r->array = NULL;
6062                 }
6063                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6064         }
6065         if (ndr_flags & NDR_BUFFERS) {
6066                 if (r->array) {
6067                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6068                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6069                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6070                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6071                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6072                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6073                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6074                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6075                         }
6076                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6077                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6078                         }
6079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6081                 }
6082                 if (r->array) {
6083                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6084                 }
6085         }
6086         return NDR_ERR_SUCCESS;
6087 }
6088
6089 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6090 {
6091         uint32_t cntr_array_1;
6092         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6093         ndr->depth++;
6094         ndr_print_uint32(ndr, "count", r->count);
6095         ndr_print_ptr(ndr, "array", r->array);
6096         ndr->depth++;
6097         if (r->array) {
6098                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6099                 ndr->depth++;
6100                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6101                         char *idx_1=NULL;
6102                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6103                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6104                                 free(idx_1);
6105                         }
6106                 }
6107                 ndr->depth--;
6108         }
6109         ndr->depth--;
6110         ndr->depth--;
6111 }
6112
6113 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6114 {
6115         if (ndr_flags & NDR_SCALARS) {
6116                 int level = ndr_push_get_switch_value(ndr, r);
6117                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6118                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6119                 switch (level) {
6120                         case 1: {
6121                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6122                         break; }
6123
6124                         default:
6125                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6126                 }
6127         }
6128         if (ndr_flags & NDR_BUFFERS) {
6129                 int level = ndr_push_get_switch_value(ndr, r);
6130                 switch (level) {
6131                         case 1:
6132                                 if (r->ctr1) {
6133                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6134                                 }
6135                         break;
6136
6137                         default:
6138                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6139                 }
6140         }
6141         return NDR_ERR_SUCCESS;
6142 }
6143
6144 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6145 {
6146         int level;
6147         int32_t _level;
6148         TALLOC_CTX *_mem_save_ctr1_0;
6149         level = ndr_pull_get_switch_value(ndr, r);
6150         if (ndr_flags & NDR_SCALARS) {
6151                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6152                 if (_level != level) {
6153                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6154                 }
6155                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6156                 switch (level) {
6157                         case 1: {
6158                                 uint32_t _ptr_ctr1;
6159                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6160                                 if (_ptr_ctr1) {
6161                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6162                                 } else {
6163                                         r->ctr1 = NULL;
6164                                 }
6165                         break; }
6166
6167                         default:
6168                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6169                 }
6170         }
6171         if (ndr_flags & NDR_BUFFERS) {
6172                 switch (level) {
6173                         case 1:
6174                                 if (r->ctr1) {
6175                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6176                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6177                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6178                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6179                                 }
6180                         break;
6181
6182                         default:
6183                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6184                 }
6185         }
6186         return NDR_ERR_SUCCESS;
6187 }
6188
6189 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6190 {
6191         int level;
6192         level = ndr_print_get_switch_value(ndr, r);
6193         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6194         switch (level) {
6195                 case 1:
6196                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6197                         ndr->depth++;
6198                         if (r->ctr1) {
6199                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6200                         }
6201                         ndr->depth--;
6202                 break;
6203
6204                 default:
6205                         ndr_print_bad_level(ndr, name, level);
6206         }
6207 }
6208
6209 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6210 {
6211         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6212         return NDR_ERR_SUCCESS;
6213 }
6214
6215 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6216 {
6217         uint32_t v;
6218         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6219         *r = v;
6220         return NDR_ERR_SUCCESS;
6221 }
6222
6223 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6224 {
6225         const char *val = NULL;
6226
6227         switch (r) {
6228                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6229                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6230                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6231         }
6232         ndr_print_enum(ndr, name, "ENUM", val, r);
6233 }
6234
6235 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6236 {
6237         uint32_t cntr_spn_names_1;
6238         if (ndr_flags & NDR_SCALARS) {
6239                 NDR_CHECK(ndr_push_align(ndr, 5));
6240                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6242                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6245                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6246         }
6247         if (ndr_flags & NDR_BUFFERS) {
6248                 if (r->object_dn) {
6249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6253                 }
6254                 if (r->spn_names) {
6255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6256                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6257                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6258                         }
6259                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6260                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6261                         }
6262                 }
6263         }
6264         return NDR_ERR_SUCCESS;
6265 }
6266
6267 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6268 {
6269         uint32_t _ptr_object_dn;
6270         TALLOC_CTX *_mem_save_object_dn_0;
6271         uint32_t _ptr_spn_names;
6272         uint32_t cntr_spn_names_1;
6273         TALLOC_CTX *_mem_save_spn_names_0;
6274         TALLOC_CTX *_mem_save_spn_names_1;
6275         if (ndr_flags & NDR_SCALARS) {
6276                 NDR_CHECK(ndr_pull_align(ndr, 5));
6277                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6280                 if (_ptr_object_dn) {
6281                         NDR_PULL_ALLOC(ndr, r->object_dn);
6282                 } else {
6283                         r->object_dn = NULL;
6284                 }
6285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6286                 if (r->count > 10000) {
6287                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6288                 }
6289                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6290                 if (_ptr_spn_names) {
6291                         NDR_PULL_ALLOC(ndr, r->spn_names);
6292                 } else {
6293                         r->spn_names = NULL;
6294                 }
6295                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6296         }
6297         if (ndr_flags & NDR_BUFFERS) {
6298                 if (r->object_dn) {
6299                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6300                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6301                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6302                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6303                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6304                                 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));
6305                         }
6306                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6307                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6309                 }
6310                 if (r->spn_names) {
6311                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6312                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6313                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6314                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6315                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6316                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6317                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6318                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6319                         }
6320                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6321                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6322                         }
6323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6325                 }
6326                 if (r->spn_names) {
6327                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6328                 }
6329         }
6330         return NDR_ERR_SUCCESS;
6331 }
6332
6333 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6334 {
6335         uint32_t cntr_spn_names_1;
6336         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6337         ndr->depth++;
6338         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6339         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6340         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6341         ndr->depth++;
6342         if (r->object_dn) {
6343                 ndr_print_string(ndr, "object_dn", r->object_dn);
6344         }
6345         ndr->depth--;
6346         ndr_print_uint32(ndr, "count", r->count);
6347         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6348         ndr->depth++;
6349         if (r->spn_names) {
6350                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6351                 ndr->depth++;
6352                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6353                         char *idx_1=NULL;
6354                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6355                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6356                                 free(idx_1);
6357                         }
6358                 }
6359                 ndr->depth--;
6360         }
6361         ndr->depth--;
6362         ndr->depth--;
6363 }
6364
6365 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6366 {
6367         if (ndr_flags & NDR_SCALARS) {
6368                 int level = ndr_push_get_switch_value(ndr, r);
6369                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6370                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6371                 switch (level) {
6372                         case 1: {
6373                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6374                         break; }
6375
6376                         default:
6377                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6378                 }
6379         }
6380         if (ndr_flags & NDR_BUFFERS) {
6381                 int level = ndr_push_get_switch_value(ndr, r);
6382                 switch (level) {
6383                         case 1:
6384                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6385                         break;
6386
6387                         default:
6388                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6389                 }
6390         }
6391         return NDR_ERR_SUCCESS;
6392 }
6393
6394 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6395 {
6396         int level;
6397         int32_t _level;
6398         level = ndr_pull_get_switch_value(ndr, r);
6399         if (ndr_flags & NDR_SCALARS) {
6400                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6401                 if (_level != level) {
6402                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6403                 }
6404                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6405                 switch (level) {
6406                         case 1: {
6407                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6408                         break; }
6409
6410                         default:
6411                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6412                 }
6413         }
6414         if (ndr_flags & NDR_BUFFERS) {
6415                 switch (level) {
6416                         case 1:
6417                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6418                         break;
6419
6420                         default:
6421                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6422                 }
6423         }
6424         return NDR_ERR_SUCCESS;
6425 }
6426
6427 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6428 {
6429         int level;
6430         level = ndr_print_get_switch_value(ndr, r);
6431         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6432         switch (level) {
6433                 case 1:
6434                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6435                 break;
6436
6437                 default:
6438                         ndr_print_bad_level(ndr, name, level);
6439         }
6440 }
6441
6442 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6443 {
6444         if (ndr_flags & NDR_SCALARS) {
6445                 NDR_CHECK(ndr_push_align(ndr, 4));
6446                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6447                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6448         }
6449         if (ndr_flags & NDR_BUFFERS) {
6450         }
6451         return NDR_ERR_SUCCESS;
6452 }
6453
6454 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6455 {
6456         if (ndr_flags & NDR_SCALARS) {
6457                 NDR_CHECK(ndr_pull_align(ndr, 4));
6458                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6459                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6460         }
6461         if (ndr_flags & NDR_BUFFERS) {
6462         }
6463         return NDR_ERR_SUCCESS;
6464 }
6465
6466 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6467 {
6468         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6469         ndr->depth++;
6470         ndr_print_WERROR(ndr, "status", r->status);
6471         ndr->depth--;
6472 }
6473
6474 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6475 {
6476         if (ndr_flags & NDR_SCALARS) {
6477                 int level = ndr_push_get_switch_value(ndr, r);
6478                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6479                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6480                 switch (level) {
6481                         case 1: {
6482                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6483                         break; }
6484
6485                         default:
6486                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6487                 }
6488         }
6489         if (ndr_flags & NDR_BUFFERS) {
6490                 int level = ndr_push_get_switch_value(ndr, r);
6491                 switch (level) {
6492                         case 1:
6493                         break;
6494
6495                         default:
6496                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6497                 }
6498         }
6499         return NDR_ERR_SUCCESS;
6500 }
6501
6502 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6503 {
6504         int level;
6505         int32_t _level;
6506         level = ndr_pull_get_switch_value(ndr, r);
6507         if (ndr_flags & NDR_SCALARS) {
6508                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6509                 if (_level != level) {
6510                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6511                 }
6512                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6513                 switch (level) {
6514                         case 1: {
6515                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6516                         break; }
6517
6518                         default:
6519                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6520                 }
6521         }
6522         if (ndr_flags & NDR_BUFFERS) {
6523                 switch (level) {
6524                         case 1:
6525                         break;
6526
6527                         default:
6528                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6529                 }
6530         }
6531         return NDR_ERR_SUCCESS;
6532 }
6533
6534 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6535 {
6536         int level;
6537         level = ndr_print_get_switch_value(ndr, r);
6538         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6539         switch (level) {
6540                 case 1:
6541                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6542                 break;
6543
6544                 default:
6545                         ndr_print_bad_level(ndr, name, level);
6546         }
6547 }
6548
6549 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6550 {
6551         if (ndr_flags & NDR_SCALARS) {
6552                 NDR_CHECK(ndr_push_align(ndr, 5));
6553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6554                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6556                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6557         }
6558         if (ndr_flags & NDR_BUFFERS) {
6559                 if (r->server_dn) {
6560                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6561                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6563                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6564                 }
6565                 if (r->domain_dn) {
6566                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6567                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6569                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6570                 }
6571         }
6572         return NDR_ERR_SUCCESS;
6573 }
6574
6575 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6576 {
6577         uint32_t _ptr_server_dn;
6578         TALLOC_CTX *_mem_save_server_dn_0;
6579         uint32_t _ptr_domain_dn;
6580         TALLOC_CTX *_mem_save_domain_dn_0;
6581         if (ndr_flags & NDR_SCALARS) {
6582                 NDR_CHECK(ndr_pull_align(ndr, 5));
6583                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6584                 if (_ptr_server_dn) {
6585                         NDR_PULL_ALLOC(ndr, r->server_dn);
6586                 } else {
6587                         r->server_dn = NULL;
6588                 }
6589                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6590                 if (_ptr_domain_dn) {
6591                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6592                 } else {
6593                         r->domain_dn = NULL;
6594                 }
6595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6596                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6597         }
6598         if (ndr_flags & NDR_BUFFERS) {
6599                 if (r->server_dn) {
6600                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6601                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6602                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6603                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6604                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6605                                 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));
6606                         }
6607                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6608                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6609                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6610                 }
6611                 if (r->domain_dn) {
6612                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6613                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6614                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6615                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6616                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6617                                 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));
6618                         }
6619                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6620                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6621                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6622                 }
6623         }
6624         return NDR_ERR_SUCCESS;
6625 }
6626
6627 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6628 {
6629         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6630         ndr->depth++;
6631         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6632         ndr->depth++;
6633         if (r->server_dn) {
6634                 ndr_print_string(ndr, "server_dn", r->server_dn);
6635         }
6636         ndr->depth--;
6637         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6638         ndr->depth++;
6639         if (r->domain_dn) {
6640                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6641         }
6642         ndr->depth--;
6643         ndr_print_uint32(ndr, "commit", r->commit);
6644         ndr->depth--;
6645 }
6646
6647 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6648 {
6649         if (ndr_flags & NDR_SCALARS) {
6650                 int level = ndr_push_get_switch_value(ndr, r);
6651                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6652                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6653                 switch (level) {
6654                         case 1: {
6655                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6656                         break; }
6657
6658                         default:
6659                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6660                 }
6661         }
6662         if (ndr_flags & NDR_BUFFERS) {
6663                 int level = ndr_push_get_switch_value(ndr, r);
6664                 switch (level) {
6665                         case 1:
6666                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6667                         break;
6668
6669                         default:
6670                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6671                 }
6672         }
6673         return NDR_ERR_SUCCESS;
6674 }
6675
6676 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6677 {
6678         int level;
6679         int32_t _level;
6680         level = ndr_pull_get_switch_value(ndr, r);
6681         if (ndr_flags & NDR_SCALARS) {
6682                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6683                 if (_level != level) {
6684                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6685                 }
6686                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6687                 switch (level) {
6688                         case 1: {
6689                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6690                         break; }
6691
6692                         default:
6693                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6694                 }
6695         }
6696         if (ndr_flags & NDR_BUFFERS) {
6697                 switch (level) {
6698                         case 1:
6699                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6700                         break;
6701
6702                         default:
6703                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6704                 }
6705         }
6706         return NDR_ERR_SUCCESS;
6707 }
6708
6709 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6710 {
6711         int level;
6712         level = ndr_print_get_switch_value(ndr, r);
6713         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6714         switch (level) {
6715                 case 1:
6716                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6717                 break;
6718
6719                 default:
6720                         ndr_print_bad_level(ndr, name, level);
6721         }
6722 }
6723
6724 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6725 {
6726         if (ndr_flags & NDR_SCALARS) {
6727                 NDR_CHECK(ndr_push_align(ndr, 4));
6728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6729                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6730         }
6731         if (ndr_flags & NDR_BUFFERS) {
6732         }
6733         return NDR_ERR_SUCCESS;
6734 }
6735
6736 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6737 {
6738         if (ndr_flags & NDR_SCALARS) {
6739                 NDR_CHECK(ndr_pull_align(ndr, 4));
6740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6741                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6742         }
6743         if (ndr_flags & NDR_BUFFERS) {
6744         }
6745         return NDR_ERR_SUCCESS;
6746 }
6747
6748 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6749 {
6750         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6751         ndr->depth++;
6752         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6753         ndr->depth--;
6754 }
6755
6756 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6757 {
6758         if (ndr_flags & NDR_SCALARS) {
6759                 int level = ndr_push_get_switch_value(ndr, r);
6760                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6761                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6762                 switch (level) {
6763                         case 1: {
6764                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6765                         break; }
6766
6767                         default:
6768                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6769                 }
6770         }
6771         if (ndr_flags & NDR_BUFFERS) {
6772                 int level = ndr_push_get_switch_value(ndr, r);
6773                 switch (level) {
6774                         case 1:
6775                         break;
6776
6777                         default:
6778                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6779                 }
6780         }
6781         return NDR_ERR_SUCCESS;
6782 }
6783
6784 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6785 {
6786         int level;
6787         int32_t _level;
6788         level = ndr_pull_get_switch_value(ndr, r);
6789         if (ndr_flags & NDR_SCALARS) {
6790                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6791                 if (_level != level) {
6792                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6793                 }
6794                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6795                 switch (level) {
6796                         case 1: {
6797                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6798                         break; }
6799
6800                         default:
6801                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6802                 }
6803         }
6804         if (ndr_flags & NDR_BUFFERS) {
6805                 switch (level) {
6806                         case 1:
6807                         break;
6808
6809                         default:
6810                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6811                 }
6812         }
6813         return NDR_ERR_SUCCESS;
6814 }
6815
6816 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6817 {
6818         int level;
6819         level = ndr_print_get_switch_value(ndr, r);
6820         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6821         switch (level) {
6822                 case 1:
6823                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6824                 break;
6825
6826                 default:
6827                         ndr_print_bad_level(ndr, name, level);
6828         }
6829 }
6830
6831 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6832 {
6833         if (ndr_flags & NDR_SCALARS) {
6834                 NDR_CHECK(ndr_push_align(ndr, 5));
6835                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6836                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6837                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6838         }
6839         if (ndr_flags & NDR_BUFFERS) {
6840                 if (r->domain_name) {
6841                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6842                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6843                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6844                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6845                 }
6846         }
6847         return NDR_ERR_SUCCESS;
6848 }
6849
6850 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6851 {
6852         uint32_t _ptr_domain_name;
6853         TALLOC_CTX *_mem_save_domain_name_0;
6854         if (ndr_flags & NDR_SCALARS) {
6855                 NDR_CHECK(ndr_pull_align(ndr, 5));
6856                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6857                 if (_ptr_domain_name) {
6858                         NDR_PULL_ALLOC(ndr, r->domain_name);
6859                 } else {
6860                         r->domain_name = NULL;
6861                 }
6862                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6863                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6864         }
6865         if (ndr_flags & NDR_BUFFERS) {
6866                 if (r->domain_name) {
6867                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6868                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6869                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6870                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6871                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6872                                 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));
6873                         }
6874                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6875                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6877                 }
6878         }
6879         return NDR_ERR_SUCCESS;
6880 }
6881
6882 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6883 {
6884         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6885         ndr->depth++;
6886         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6887         ndr->depth++;
6888         if (r->domain_name) {
6889                 ndr_print_string(ndr, "domain_name", r->domain_name);
6890         }
6891         ndr->depth--;
6892         ndr_print_int32(ndr, "level", r->level);
6893         ndr->depth--;
6894 }
6895
6896 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6897 {
6898         if (ndr_flags & NDR_SCALARS) {
6899                 int level = ndr_push_get_switch_value(ndr, r);
6900                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6901                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6902                 switch (level) {
6903                         case 1: {
6904                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6905                         break; }
6906
6907                         default:
6908                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6909                 }
6910         }
6911         if (ndr_flags & NDR_BUFFERS) {
6912                 int level = ndr_push_get_switch_value(ndr, r);
6913                 switch (level) {
6914                         case 1:
6915                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6916                         break;
6917
6918                         default:
6919                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6920                 }
6921         }
6922         return NDR_ERR_SUCCESS;
6923 }
6924
6925 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6926 {
6927         int level;
6928         int32_t _level;
6929         level = ndr_pull_get_switch_value(ndr, r);
6930         if (ndr_flags & NDR_SCALARS) {
6931                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6932                 if (_level != level) {
6933                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6934                 }
6935                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6936                 switch (level) {
6937                         case 1: {
6938                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6939                         break; }
6940
6941                         default:
6942                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6943                 }
6944         }
6945         if (ndr_flags & NDR_BUFFERS) {
6946                 switch (level) {
6947                         case 1:
6948                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6949                         break;
6950
6951                         default:
6952                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6953                 }
6954         }
6955         return NDR_ERR_SUCCESS;
6956 }
6957
6958 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6959 {
6960         int level;
6961         level = ndr_print_get_switch_value(ndr, r);
6962         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6963         switch (level) {
6964                 case 1:
6965                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6966                 break;
6967
6968                 default:
6969                         ndr_print_bad_level(ndr, name, level);
6970         }
6971 }
6972
6973 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6974 {
6975         if (ndr_flags & NDR_SCALARS) {
6976                 NDR_CHECK(ndr_push_align(ndr, 5));
6977                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6978                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6979                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6981                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6984                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6985         }
6986         if (ndr_flags & NDR_BUFFERS) {
6987                 if (r->netbios_name) {
6988                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6989                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6990                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6991                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6992                 }
6993                 if (r->dns_name) {
6994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6997                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6998                 }
6999                 if (r->site_name) {
7000                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7002                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7003                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7004                 }
7005                 if (r->computer_dn) {
7006                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7007                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7008                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7009                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7010                 }
7011                 if (r->server_dn) {
7012                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7013                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7014                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7015                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7016                 }
7017         }
7018         return NDR_ERR_SUCCESS;
7019 }
7020
7021 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
7022 {
7023         uint32_t _ptr_netbios_name;
7024         TALLOC_CTX *_mem_save_netbios_name_0;
7025         uint32_t _ptr_dns_name;
7026         TALLOC_CTX *_mem_save_dns_name_0;
7027         uint32_t _ptr_site_name;
7028         TALLOC_CTX *_mem_save_site_name_0;
7029         uint32_t _ptr_computer_dn;
7030         TALLOC_CTX *_mem_save_computer_dn_0;
7031         uint32_t _ptr_server_dn;
7032         TALLOC_CTX *_mem_save_server_dn_0;
7033         if (ndr_flags & NDR_SCALARS) {
7034                 NDR_CHECK(ndr_pull_align(ndr, 5));
7035                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7036                 if (_ptr_netbios_name) {
7037                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7038                 } else {
7039                         r->netbios_name = NULL;
7040                 }
7041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7042                 if (_ptr_dns_name) {
7043                         NDR_PULL_ALLOC(ndr, r->dns_name);
7044                 } else {
7045                         r->dns_name = NULL;
7046                 }
7047                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7048                 if (_ptr_site_name) {
7049                         NDR_PULL_ALLOC(ndr, r->site_name);
7050                 } else {
7051                         r->site_name = NULL;
7052                 }
7053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7054                 if (_ptr_computer_dn) {
7055                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7056                 } else {
7057                         r->computer_dn = NULL;
7058                 }
7059                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7060                 if (_ptr_server_dn) {
7061                         NDR_PULL_ALLOC(ndr, r->server_dn);
7062                 } else {
7063                         r->server_dn = NULL;
7064                 }
7065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7066                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7067                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7068         }
7069         if (ndr_flags & NDR_BUFFERS) {
7070                 if (r->netbios_name) {
7071                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7072                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7073                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7074                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7075                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7076                                 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));
7077                         }
7078                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7079                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7081                 }
7082                 if (r->dns_name) {
7083                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7084                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7085                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7086                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7087                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7088                                 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));
7089                         }
7090                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7091                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7093                 }
7094                 if (r->site_name) {
7095                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7096                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7099                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7100                                 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));
7101                         }
7102                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7103                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7105                 }
7106                 if (r->computer_dn) {
7107                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7108                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7109                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7110                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7111                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7112                                 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));
7113                         }
7114                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7115                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7117                 }
7118                 if (r->server_dn) {
7119                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7120                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7121                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7122                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7123                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7124                                 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));
7125                         }
7126                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7127                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7128                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7129                 }
7130         }
7131         return NDR_ERR_SUCCESS;
7132 }
7133
7134 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7135 {
7136         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7137         ndr->depth++;
7138         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7139         ndr->depth++;
7140         if (r->netbios_name) {
7141                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7142         }
7143         ndr->depth--;
7144         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7145         ndr->depth++;
7146         if (r->dns_name) {
7147                 ndr_print_string(ndr, "dns_name", r->dns_name);
7148         }
7149         ndr->depth--;
7150         ndr_print_ptr(ndr, "site_name", r->site_name);
7151         ndr->depth++;
7152         if (r->site_name) {
7153                 ndr_print_string(ndr, "site_name", r->site_name);
7154         }
7155         ndr->depth--;
7156         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7157         ndr->depth++;
7158         if (r->computer_dn) {
7159                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7160         }
7161         ndr->depth--;
7162         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7163         ndr->depth++;
7164         if (r->server_dn) {
7165                 ndr_print_string(ndr, "server_dn", r->server_dn);
7166         }
7167         ndr->depth--;
7168         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7169         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7170         ndr->depth--;
7171 }
7172
7173 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7174 {
7175         uint32_t cntr_array_1;
7176         if (ndr_flags & NDR_SCALARS) {
7177                 NDR_CHECK(ndr_push_align(ndr, 5));
7178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7179                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7180                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7181         }
7182         if (ndr_flags & NDR_BUFFERS) {
7183                 if (r->array) {
7184                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7185                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7186                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7187                         }
7188                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7189                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7190                         }
7191                 }
7192         }
7193         return NDR_ERR_SUCCESS;
7194 }
7195
7196 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7197 {
7198         uint32_t _ptr_array;
7199         uint32_t cntr_array_1;
7200         TALLOC_CTX *_mem_save_array_0;
7201         TALLOC_CTX *_mem_save_array_1;
7202         if (ndr_flags & NDR_SCALARS) {
7203                 NDR_CHECK(ndr_pull_align(ndr, 5));
7204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7205                 if (r->count > 10000) {
7206                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7207                 }
7208                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7209                 if (_ptr_array) {
7210                         NDR_PULL_ALLOC(ndr, r->array);
7211                 } else {
7212                         r->array = NULL;
7213                 }
7214                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7215         }
7216         if (ndr_flags & NDR_BUFFERS) {
7217                 if (r->array) {
7218                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7219                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7221                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7222                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7223                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7224                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7225                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7226                         }
7227                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7228                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7229                         }
7230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7232                 }
7233                 if (r->array) {
7234                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7235                 }
7236         }
7237         return NDR_ERR_SUCCESS;
7238 }
7239
7240 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7241 {
7242         uint32_t cntr_array_1;
7243         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7244         ndr->depth++;
7245         ndr_print_uint32(ndr, "count", r->count);
7246         ndr_print_ptr(ndr, "array", r->array);
7247         ndr->depth++;
7248         if (r->array) {
7249                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7250                 ndr->depth++;
7251                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7252                         char *idx_1=NULL;
7253                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7254                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7255                                 free(idx_1);
7256                         }
7257                 }
7258                 ndr->depth--;
7259         }
7260         ndr->depth--;
7261         ndr->depth--;
7262 }
7263
7264 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7265 {
7266         if (ndr_flags & NDR_SCALARS) {
7267                 NDR_CHECK(ndr_push_align(ndr, 5));
7268                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7269                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7270                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7271                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7272                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7274                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7278                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7279                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7280                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7281                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7282                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7283         }
7284         if (ndr_flags & NDR_BUFFERS) {
7285                 if (r->netbios_name) {
7286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7287                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7288                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7289                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7290                 }
7291                 if (r->dns_name) {
7292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7294                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7295                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7296                 }
7297                 if (r->site_name) {
7298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7299                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7300                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7301                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7302                 }
7303                 if (r->site_dn) {
7304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7306                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7307                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7308                 }
7309                 if (r->computer_dn) {
7310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7312                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7313                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7314                 }
7315                 if (r->server_dn) {
7316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7318                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7319                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7320                 }
7321                 if (r->ntds_dn) {
7322                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7323                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7324                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7325                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7326                 }
7327         }
7328         return NDR_ERR_SUCCESS;
7329 }
7330
7331 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7332 {
7333         uint32_t _ptr_netbios_name;
7334         TALLOC_CTX *_mem_save_netbios_name_0;
7335         uint32_t _ptr_dns_name;
7336         TALLOC_CTX *_mem_save_dns_name_0;
7337         uint32_t _ptr_site_name;
7338         TALLOC_CTX *_mem_save_site_name_0;
7339         uint32_t _ptr_site_dn;
7340         TALLOC_CTX *_mem_save_site_dn_0;
7341         uint32_t _ptr_computer_dn;
7342         TALLOC_CTX *_mem_save_computer_dn_0;
7343         uint32_t _ptr_server_dn;
7344         TALLOC_CTX *_mem_save_server_dn_0;
7345         uint32_t _ptr_ntds_dn;
7346         TALLOC_CTX *_mem_save_ntds_dn_0;
7347         if (ndr_flags & NDR_SCALARS) {
7348                 NDR_CHECK(ndr_pull_align(ndr, 5));
7349                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7350                 if (_ptr_netbios_name) {
7351                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7352                 } else {
7353                         r->netbios_name = NULL;
7354                 }
7355                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7356                 if (_ptr_dns_name) {
7357                         NDR_PULL_ALLOC(ndr, r->dns_name);
7358                 } else {
7359                         r->dns_name = NULL;
7360                 }
7361                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7362                 if (_ptr_site_name) {
7363                         NDR_PULL_ALLOC(ndr, r->site_name);
7364                 } else {
7365                         r->site_name = NULL;
7366                 }
7367                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7368                 if (_ptr_site_dn) {
7369                         NDR_PULL_ALLOC(ndr, r->site_dn);
7370                 } else {
7371                         r->site_dn = NULL;
7372                 }
7373                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7374                 if (_ptr_computer_dn) {
7375                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7376                 } else {
7377                         r->computer_dn = NULL;
7378                 }
7379                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7380                 if (_ptr_server_dn) {
7381                         NDR_PULL_ALLOC(ndr, r->server_dn);
7382                 } else {
7383                         r->server_dn = NULL;
7384                 }
7385                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7386                 if (_ptr_ntds_dn) {
7387                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7388                 } else {
7389                         r->ntds_dn = NULL;
7390                 }
7391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7393                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7394                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7395                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7396                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7397                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7398                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7399         }
7400         if (ndr_flags & NDR_BUFFERS) {
7401                 if (r->netbios_name) {
7402                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7403                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7404                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7405                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7406                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7407                                 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));
7408                         }
7409                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7410                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7411                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7412                 }
7413                 if (r->dns_name) {
7414                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7415                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7416                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7417                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7418                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7419                                 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));
7420                         }
7421                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7422                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7423                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7424                 }
7425                 if (r->site_name) {
7426                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7427                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7428                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7429                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7430                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7431                                 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));
7432                         }
7433                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7434                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7436                 }
7437                 if (r->site_dn) {
7438                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7439                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7440                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7441                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7442                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7443                                 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));
7444                         }
7445                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7446                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7448                 }
7449                 if (r->computer_dn) {
7450                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7451                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7452                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7453                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7454                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7455                                 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));
7456                         }
7457                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7458                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7459                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7460                 }
7461                 if (r->server_dn) {
7462                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7463                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7464                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7465                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7466                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7467                                 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));
7468                         }
7469                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7470                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7471                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7472                 }
7473                 if (r->ntds_dn) {
7474                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7475                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7476                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7477                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7478                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7479                                 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));
7480                         }
7481                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7482                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7484                 }
7485         }
7486         return NDR_ERR_SUCCESS;
7487 }
7488
7489 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7490 {
7491         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7492         ndr->depth++;
7493         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7494         ndr->depth++;
7495         if (r->netbios_name) {
7496                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7497         }
7498         ndr->depth--;
7499         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7500         ndr->depth++;
7501         if (r->dns_name) {
7502                 ndr_print_string(ndr, "dns_name", r->dns_name);
7503         }
7504         ndr->depth--;
7505         ndr_print_ptr(ndr, "site_name", r->site_name);
7506         ndr->depth++;
7507         if (r->site_name) {
7508                 ndr_print_string(ndr, "site_name", r->site_name);
7509         }
7510         ndr->depth--;
7511         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7512         ndr->depth++;
7513         if (r->site_dn) {
7514                 ndr_print_string(ndr, "site_dn", r->site_dn);
7515         }
7516         ndr->depth--;
7517         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7518         ndr->depth++;
7519         if (r->computer_dn) {
7520                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7521         }
7522         ndr->depth--;
7523         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7524         ndr->depth++;
7525         if (r->server_dn) {
7526                 ndr_print_string(ndr, "server_dn", r->server_dn);
7527         }
7528         ndr->depth--;
7529         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7530         ndr->depth++;
7531         if (r->ntds_dn) {
7532                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7533         }
7534         ndr->depth--;
7535         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7536         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7537         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7538         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7539         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7540         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7541         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7542         ndr->depth--;
7543 }
7544
7545 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7546 {
7547         uint32_t cntr_array_1;
7548         if (ndr_flags & NDR_SCALARS) {
7549                 NDR_CHECK(ndr_push_align(ndr, 5));
7550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7551                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7552                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7553         }
7554         if (ndr_flags & NDR_BUFFERS) {
7555                 if (r->array) {
7556                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7557                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7558                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7559                         }
7560                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7561                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7562                         }
7563                 }
7564         }
7565         return NDR_ERR_SUCCESS;
7566 }
7567
7568 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7569 {
7570         uint32_t _ptr_array;
7571         uint32_t cntr_array_1;
7572         TALLOC_CTX *_mem_save_array_0;
7573         TALLOC_CTX *_mem_save_array_1;
7574         if (ndr_flags & NDR_SCALARS) {
7575                 NDR_CHECK(ndr_pull_align(ndr, 5));
7576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7577                 if (r->count > 10000) {
7578                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7579                 }
7580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7581                 if (_ptr_array) {
7582                         NDR_PULL_ALLOC(ndr, r->array);
7583                 } else {
7584                         r->array = NULL;
7585                 }
7586                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7587         }
7588         if (ndr_flags & NDR_BUFFERS) {
7589                 if (r->array) {
7590                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7591                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7592                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7593                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7594                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7595                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7596                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7597                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7598                         }
7599                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7600                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7601                         }
7602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7604                 }
7605                 if (r->array) {
7606                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7607                 }
7608         }
7609         return NDR_ERR_SUCCESS;
7610 }
7611
7612 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7613 {
7614         uint32_t cntr_array_1;
7615         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7616         ndr->depth++;
7617         ndr_print_uint32(ndr, "count", r->count);
7618         ndr_print_ptr(ndr, "array", r->array);
7619         ndr->depth++;
7620         if (r->array) {
7621                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7622                 ndr->depth++;
7623                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7624                         char *idx_1=NULL;
7625                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7626                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7627                                 free(idx_1);
7628                         }
7629                 }
7630                 ndr->depth--;
7631         }
7632         ndr->depth--;
7633         ndr->depth--;
7634 }
7635
7636 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7637 {
7638         if (ndr_flags & NDR_SCALARS) {
7639                 NDR_CHECK(ndr_push_align(ndr, 5));
7640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7642                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7643                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7644                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7651                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7652                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7653                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7654                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7655                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7656         }
7657         if (ndr_flags & NDR_BUFFERS) {
7658                 if (r->netbios_name) {
7659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7662                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7663                 }
7664                 if (r->dns_name) {
7665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7668                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7669                 }
7670                 if (r->site_name) {
7671                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7672                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7673                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7674                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7675                 }
7676                 if (r->site_dn) {
7677                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7678                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7679                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7680                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7681                 }
7682                 if (r->computer_dn) {
7683                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7684                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7685                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7686                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7687                 }
7688                 if (r->server_dn) {
7689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7691                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7692                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7693                 }
7694                 if (r->ntds_dn) {
7695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7698                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7699                 }
7700         }
7701         return NDR_ERR_SUCCESS;
7702 }
7703
7704 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7705 {
7706         uint32_t _ptr_netbios_name;
7707         TALLOC_CTX *_mem_save_netbios_name_0;
7708         uint32_t _ptr_dns_name;
7709         TALLOC_CTX *_mem_save_dns_name_0;
7710         uint32_t _ptr_site_name;
7711         TALLOC_CTX *_mem_save_site_name_0;
7712         uint32_t _ptr_site_dn;
7713         TALLOC_CTX *_mem_save_site_dn_0;
7714         uint32_t _ptr_computer_dn;
7715         TALLOC_CTX *_mem_save_computer_dn_0;
7716         uint32_t _ptr_server_dn;
7717         TALLOC_CTX *_mem_save_server_dn_0;
7718         uint32_t _ptr_ntds_dn;
7719         TALLOC_CTX *_mem_save_ntds_dn_0;
7720         if (ndr_flags & NDR_SCALARS) {
7721                 NDR_CHECK(ndr_pull_align(ndr, 5));
7722                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7723                 if (_ptr_netbios_name) {
7724                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7725                 } else {
7726                         r->netbios_name = NULL;
7727                 }
7728                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7729                 if (_ptr_dns_name) {
7730                         NDR_PULL_ALLOC(ndr, r->dns_name);
7731                 } else {
7732                         r->dns_name = NULL;
7733                 }
7734                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7735                 if (_ptr_site_name) {
7736                         NDR_PULL_ALLOC(ndr, r->site_name);
7737                 } else {
7738                         r->site_name = NULL;
7739                 }
7740                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7741                 if (_ptr_site_dn) {
7742                         NDR_PULL_ALLOC(ndr, r->site_dn);
7743                 } else {
7744                         r->site_dn = NULL;
7745                 }
7746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7747                 if (_ptr_computer_dn) {
7748                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7749                 } else {
7750                         r->computer_dn = NULL;
7751                 }
7752                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7753                 if (_ptr_server_dn) {
7754                         NDR_PULL_ALLOC(ndr, r->server_dn);
7755                 } else {
7756                         r->server_dn = NULL;
7757                 }
7758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7759                 if (_ptr_ntds_dn) {
7760                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7761                 } else {
7762                         r->ntds_dn = NULL;
7763                 }
7764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7768                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7769                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7770                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7771                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7772                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7773         }
7774         if (ndr_flags & NDR_BUFFERS) {
7775                 if (r->netbios_name) {
7776                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7777                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7780                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7781                                 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));
7782                         }
7783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7786                 }
7787                 if (r->dns_name) {
7788                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7789                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7790                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7791                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7792                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7793                                 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));
7794                         }
7795                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7796                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7798                 }
7799                 if (r->site_name) {
7800                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7801                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7802                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7803                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7804                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7805                                 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));
7806                         }
7807                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7808                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7810                 }
7811                 if (r->site_dn) {
7812                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7813                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7814                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7815                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7816                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7817                                 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));
7818                         }
7819                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7820                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7821                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7822                 }
7823                 if (r->computer_dn) {
7824                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7825                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7826                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7827                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7828                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7829                                 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));
7830                         }
7831                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7832                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7833                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7834                 }
7835                 if (r->server_dn) {
7836                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7837                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7838                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7839                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7840                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7841                                 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));
7842                         }
7843                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7844                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7845                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7846                 }
7847                 if (r->ntds_dn) {
7848                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7849                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7850                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7851                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7852                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7853                                 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));
7854                         }
7855                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7856                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7858                 }
7859         }
7860         return NDR_ERR_SUCCESS;
7861 }
7862
7863 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7864 {
7865         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7866         ndr->depth++;
7867         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7868         ndr->depth++;
7869         if (r->netbios_name) {
7870                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7871         }
7872         ndr->depth--;
7873         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7874         ndr->depth++;
7875         if (r->dns_name) {
7876                 ndr_print_string(ndr, "dns_name", r->dns_name);
7877         }
7878         ndr->depth--;
7879         ndr_print_ptr(ndr, "site_name", r->site_name);
7880         ndr->depth++;
7881         if (r->site_name) {
7882                 ndr_print_string(ndr, "site_name", r->site_name);
7883         }
7884         ndr->depth--;
7885         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7886         ndr->depth++;
7887         if (r->site_dn) {
7888                 ndr_print_string(ndr, "site_dn", r->site_dn);
7889         }
7890         ndr->depth--;
7891         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7892         ndr->depth++;
7893         if (r->computer_dn) {
7894                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7895         }
7896         ndr->depth--;
7897         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7898         ndr->depth++;
7899         if (r->server_dn) {
7900                 ndr_print_string(ndr, "server_dn", r->server_dn);
7901         }
7902         ndr->depth--;
7903         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7904         ndr->depth++;
7905         if (r->ntds_dn) {
7906                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7907         }
7908         ndr->depth--;
7909         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7910         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7911         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7912         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7913         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7914         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7915         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7916         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7917         ndr->depth--;
7918 }
7919
7920 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7921 {
7922         uint32_t cntr_array_1;
7923         if (ndr_flags & NDR_SCALARS) {
7924                 NDR_CHECK(ndr_push_align(ndr, 5));
7925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7926                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7927                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7928         }
7929         if (ndr_flags & NDR_BUFFERS) {
7930                 if (r->array) {
7931                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7932                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7933                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7934                         }
7935                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7936                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7937                         }
7938                 }
7939         }
7940         return NDR_ERR_SUCCESS;
7941 }
7942
7943 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7944 {
7945         uint32_t _ptr_array;
7946         uint32_t cntr_array_1;
7947         TALLOC_CTX *_mem_save_array_0;
7948         TALLOC_CTX *_mem_save_array_1;
7949         if (ndr_flags & NDR_SCALARS) {
7950                 NDR_CHECK(ndr_pull_align(ndr, 5));
7951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7952                 if (r->count > 10000) {
7953                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7954                 }
7955                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7956                 if (_ptr_array) {
7957                         NDR_PULL_ALLOC(ndr, r->array);
7958                 } else {
7959                         r->array = NULL;
7960                 }
7961                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7962         }
7963         if (ndr_flags & NDR_BUFFERS) {
7964                 if (r->array) {
7965                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7966                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7967                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7968                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7969                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7970                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7971                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7972                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7973                         }
7974                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7975                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7976                         }
7977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7979                 }
7980                 if (r->array) {
7981                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7982                 }
7983         }
7984         return NDR_ERR_SUCCESS;
7985 }
7986
7987 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7988 {
7989         uint32_t cntr_array_1;
7990         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7991         ndr->depth++;
7992         ndr_print_uint32(ndr, "count", r->count);
7993         ndr_print_ptr(ndr, "array", r->array);
7994         ndr->depth++;
7995         if (r->array) {
7996                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7997                 ndr->depth++;
7998                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7999                         char *idx_1=NULL;
8000                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8001                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
8002                                 free(idx_1);
8003                         }
8004                 }
8005                 ndr->depth--;
8006         }
8007         ndr->depth--;
8008         ndr->depth--;
8009 }
8010
8011 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
8012 {
8013         if (ndr_flags & NDR_SCALARS) {
8014                 NDR_CHECK(ndr_push_align(ndr, 5));
8015                 {
8016                         uint32_t _flags_save_ipv4address = ndr->flags;
8017                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8018                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
8019                         ndr->flags = _flags_save_ipv4address;
8020                 }
8021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
8023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
8024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
8025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
8026                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
8027                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8028         }
8029         if (ndr_flags & NDR_BUFFERS) {
8030                 if (r->client_account) {
8031                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8034                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8035                 }
8036         }
8037         return NDR_ERR_SUCCESS;
8038 }
8039
8040 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8041 {
8042         uint32_t _ptr_client_account;
8043         TALLOC_CTX *_mem_save_client_account_0;
8044         if (ndr_flags & NDR_SCALARS) {
8045                 NDR_CHECK(ndr_pull_align(ndr, 5));
8046                 {
8047                         uint32_t _flags_save_ipv4address = ndr->flags;
8048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8049                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
8050                         ndr->flags = _flags_save_ipv4address;
8051                 }
8052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
8054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
8055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
8056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
8057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
8058                 if (_ptr_client_account) {
8059                         NDR_PULL_ALLOC(ndr, r->client_account);
8060                 } else {
8061                         r->client_account = NULL;
8062                 }
8063                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8064         }
8065         if (ndr_flags & NDR_BUFFERS) {
8066                 if (r->client_account) {
8067                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8068                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8069                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8070                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8071                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8072                                 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));
8073                         }
8074                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8075                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8077                 }
8078         }
8079         return NDR_ERR_SUCCESS;
8080 }
8081
8082 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8083 {
8084         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8085         ndr->depth++;
8086         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8087         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8088         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8089         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8090         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8091         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8092         ndr_print_ptr(ndr, "client_account", r->client_account);
8093         ndr->depth++;
8094         if (r->client_account) {
8095                 ndr_print_string(ndr, "client_account", r->client_account);
8096         }
8097         ndr->depth--;
8098         ndr->depth--;
8099 }
8100
8101 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8102 {
8103         uint32_t cntr_array_1;
8104         if (ndr_flags & NDR_SCALARS) {
8105                 NDR_CHECK(ndr_push_align(ndr, 5));
8106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8108                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8109         }
8110         if (ndr_flags & NDR_BUFFERS) {
8111                 if (r->array) {
8112                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8113                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8114                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8115                         }
8116                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8117                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8118                         }
8119                 }
8120         }
8121         return NDR_ERR_SUCCESS;
8122 }
8123
8124 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8125 {
8126         uint32_t _ptr_array;
8127         uint32_t cntr_array_1;
8128         TALLOC_CTX *_mem_save_array_0;
8129         TALLOC_CTX *_mem_save_array_1;
8130         if (ndr_flags & NDR_SCALARS) {
8131                 NDR_CHECK(ndr_pull_align(ndr, 5));
8132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8133                 if (r->count > 10000) {
8134                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8135                 }
8136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8137                 if (_ptr_array) {
8138                         NDR_PULL_ALLOC(ndr, r->array);
8139                 } else {
8140                         r->array = NULL;
8141                 }
8142                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8143         }
8144         if (ndr_flags & NDR_BUFFERS) {
8145                 if (r->array) {
8146                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8147                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8148                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8149                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8150                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8151                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8152                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8153                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8154                         }
8155                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8156                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8157                         }
8158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8159                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8160                 }
8161                 if (r->array) {
8162                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8163                 }
8164         }
8165         return NDR_ERR_SUCCESS;
8166 }
8167
8168 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8169 {
8170         uint32_t cntr_array_1;
8171         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8172         ndr->depth++;
8173         ndr_print_uint32(ndr, "count", r->count);
8174         ndr_print_ptr(ndr, "array", r->array);
8175         ndr->depth++;
8176         if (r->array) {
8177                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8178                 ndr->depth++;
8179                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8180                         char *idx_1=NULL;
8181                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8182                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8183                                 free(idx_1);
8184                         }
8185                 }
8186                 ndr->depth--;
8187         }
8188         ndr->depth--;
8189         ndr->depth--;
8190 }
8191
8192 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8193 {
8194         if (ndr_flags & NDR_SCALARS) {
8195                 int level = ndr_push_get_switch_value(ndr, r);
8196                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8197                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8198                 switch (level) {
8199                         case DRSUAPI_DC_INFO_CTR_1: {
8200                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8201                         break; }
8202
8203                         case DRSUAPI_DC_INFO_CTR_2: {
8204                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8205                         break; }
8206
8207                         case DRSUAPI_DC_INFO_CTR_3: {
8208                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8209                         break; }
8210
8211                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8212                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8213                         break; }
8214
8215                         default:
8216                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8217                 }
8218         }
8219         if (ndr_flags & NDR_BUFFERS) {
8220                 int level = ndr_push_get_switch_value(ndr, r);
8221                 switch (level) {
8222                         case DRSUAPI_DC_INFO_CTR_1:
8223                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8224                         break;
8225
8226                         case DRSUAPI_DC_INFO_CTR_2:
8227                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8228                         break;
8229
8230                         case DRSUAPI_DC_INFO_CTR_3:
8231                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8232                         break;
8233
8234                         case DRSUAPI_DC_CONNECTION_CTR_01:
8235                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8236                         break;
8237
8238                         default:
8239                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8240                 }
8241         }
8242         return NDR_ERR_SUCCESS;
8243 }
8244
8245 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8246 {
8247         int level;
8248         int32_t _level;
8249         level = ndr_pull_get_switch_value(ndr, r);
8250         if (ndr_flags & NDR_SCALARS) {
8251                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8252                 if (_level != level) {
8253                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8254                 }
8255                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8256                 switch (level) {
8257                         case DRSUAPI_DC_INFO_CTR_1: {
8258                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8259                         break; }
8260
8261                         case DRSUAPI_DC_INFO_CTR_2: {
8262                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8263                         break; }
8264
8265                         case DRSUAPI_DC_INFO_CTR_3: {
8266                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8267                         break; }
8268
8269                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8270                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8271                         break; }
8272
8273                         default:
8274                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8275                 }
8276         }
8277         if (ndr_flags & NDR_BUFFERS) {
8278                 switch (level) {
8279                         case DRSUAPI_DC_INFO_CTR_1:
8280                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8281                         break;
8282
8283                         case DRSUAPI_DC_INFO_CTR_2:
8284                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8285                         break;
8286
8287                         case DRSUAPI_DC_INFO_CTR_3:
8288                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8289                         break;
8290
8291                         case DRSUAPI_DC_CONNECTION_CTR_01:
8292                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8293                         break;
8294
8295                         default:
8296                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8297                 }
8298         }
8299         return NDR_ERR_SUCCESS;
8300 }
8301
8302 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8303 {
8304         int level;
8305         level = ndr_print_get_switch_value(ndr, r);
8306         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8307         switch (level) {
8308                 case DRSUAPI_DC_INFO_CTR_1:
8309                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8310                 break;
8311
8312                 case DRSUAPI_DC_INFO_CTR_2:
8313                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8314                 break;
8315
8316                 case DRSUAPI_DC_INFO_CTR_3:
8317                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8318                 break;
8319
8320                 case DRSUAPI_DC_CONNECTION_CTR_01:
8321                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8322                 break;
8323
8324                 default:
8325                         ndr_print_bad_level(ndr, name, level);
8326         }
8327 }
8328
8329 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8330 {
8331         if (ndr_flags & NDR_SCALARS) {
8332                 NDR_CHECK(ndr_push_align(ndr, 5));
8333                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8334                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8335                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8336         }
8337         if (ndr_flags & NDR_BUFFERS) {
8338                 if (r->next_object) {
8339                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8340                 }
8341                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8342         }
8343         return NDR_ERR_SUCCESS;
8344 }
8345
8346 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8347 {
8348         uint32_t _ptr_next_object;
8349         TALLOC_CTX *_mem_save_next_object_0;
8350         if (ndr_flags & NDR_SCALARS) {
8351                 NDR_CHECK(ndr_pull_align(ndr, 5));
8352                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8353                 if (_ptr_next_object) {
8354                         NDR_PULL_ALLOC(ndr, r->next_object);
8355                 } else {
8356                         r->next_object = NULL;
8357                 }
8358                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8359                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8360         }
8361         if (ndr_flags & NDR_BUFFERS) {
8362                 if (r->next_object) {
8363                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8364                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8365                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8366                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8367                 }
8368                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8369         }
8370         return NDR_ERR_SUCCESS;
8371 }
8372
8373 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8374 {
8375         if (ndr_flags & NDR_SCALARS) {
8376                 NDR_CHECK(ndr_push_align(ndr, 5));
8377                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8378                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8379         }
8380         if (ndr_flags & NDR_BUFFERS) {
8381                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8382         }
8383         return NDR_ERR_SUCCESS;
8384 }
8385
8386 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8387 {
8388         if (ndr_flags & NDR_SCALARS) {
8389                 NDR_CHECK(ndr_pull_align(ndr, 5));
8390                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8391                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8392         }
8393         if (ndr_flags & NDR_BUFFERS) {
8394                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8395         }
8396         return NDR_ERR_SUCCESS;
8397 }
8398
8399 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8400 {
8401         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8402         ndr->depth++;
8403         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8404         ndr->depth--;
8405 }
8406
8407 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8408 {
8409         if (ndr_flags & NDR_SCALARS) {
8410                 int level = ndr_push_get_switch_value(ndr, r);
8411                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8412                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8413                 switch (level) {
8414                         case 2: {
8415                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8416                         break; }
8417
8418                         default:
8419                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8420                 }
8421         }
8422         if (ndr_flags & NDR_BUFFERS) {
8423                 int level = ndr_push_get_switch_value(ndr, r);
8424                 switch (level) {
8425                         case 2:
8426                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8427                         break;
8428
8429                         default:
8430                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8431                 }
8432         }
8433         return NDR_ERR_SUCCESS;
8434 }
8435
8436 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8437 {
8438         int level;
8439         int32_t _level;
8440         level = ndr_pull_get_switch_value(ndr, r);
8441         if (ndr_flags & NDR_SCALARS) {
8442                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8443                 if (_level != level) {
8444                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8445                 }
8446                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8447                 switch (level) {
8448                         case 2: {
8449                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8450                         break; }
8451
8452                         default:
8453                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8454                 }
8455         }
8456         if (ndr_flags & NDR_BUFFERS) {
8457                 switch (level) {
8458                         case 2:
8459                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8460                         break;
8461
8462                         default:
8463                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8464                 }
8465         }
8466         return NDR_ERR_SUCCESS;
8467 }
8468
8469 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8470 {
8471         int level;
8472         level = ndr_print_get_switch_value(ndr, r);
8473         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8474         switch (level) {
8475                 case 2:
8476                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8477                 break;
8478
8479                 default:
8480                         ndr_print_bad_level(ndr, name, level);
8481         }
8482 }
8483
8484 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8485 {
8486         if (ndr_flags & NDR_SCALARS) {
8487                 NDR_CHECK(ndr_push_align(ndr, 4));
8488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8489                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8491                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8492                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8493         }
8494         if (ndr_flags & NDR_BUFFERS) {
8495         }
8496         return NDR_ERR_SUCCESS;
8497 }
8498
8499 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8500 {
8501         if (ndr_flags & NDR_SCALARS) {
8502                 NDR_CHECK(ndr_pull_align(ndr, 4));
8503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8504                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8506                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8507                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8508         }
8509         if (ndr_flags & NDR_BUFFERS) {
8510         }
8511         return NDR_ERR_SUCCESS;
8512 }
8513
8514 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8515 {
8516         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8517         ndr->depth++;
8518         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8519         ndr_print_WERROR(ndr, "status", r->status);
8520         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8521         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8522         ndr->depth--;
8523 }
8524
8525 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8526 {
8527         if (ndr_flags & NDR_SCALARS) {
8528                 NDR_CHECK(ndr_push_align(ndr, 5));
8529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8530                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8531                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8532         }
8533         if (ndr_flags & NDR_BUFFERS) {
8534                 if (r->data) {
8535                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8536                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8537                 }
8538         }
8539         return NDR_ERR_SUCCESS;
8540 }
8541
8542 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8543 {
8544         uint32_t _ptr_data;
8545         TALLOC_CTX *_mem_save_data_0;
8546         if (ndr_flags & NDR_SCALARS) {
8547                 NDR_CHECK(ndr_pull_align(ndr, 5));
8548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8549                 if (r->size > 10485760) {
8550                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8551                 }
8552                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8553                 if (_ptr_data) {
8554                         NDR_PULL_ALLOC(ndr, r->data);
8555                 } else {
8556                         r->data = NULL;
8557                 }
8558                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8559         }
8560         if (ndr_flags & NDR_BUFFERS) {
8561                 if (r->data) {
8562                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8563                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8565                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8566                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8567                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8568                 }
8569                 if (r->data) {
8570                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8571                 }
8572         }
8573         return NDR_ERR_SUCCESS;
8574 }
8575
8576 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8577 {
8578         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8579         ndr->depth++;
8580         ndr_print_uint32(ndr, "size", r->size);
8581         ndr_print_ptr(ndr, "data", r->data);
8582         ndr->depth++;
8583         if (r->data) {
8584                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8585         }
8586         ndr->depth--;
8587         ndr->depth--;
8588 }
8589
8590 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8591 {
8592         if (ndr_flags & NDR_SCALARS) {
8593                 NDR_CHECK(ndr_push_align(ndr, 5));
8594                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8595                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8597                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8598                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8599         }
8600         if (ndr_flags & NDR_BUFFERS) {
8601                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8602         }
8603         return NDR_ERR_SUCCESS;
8604 }
8605
8606 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8607 {
8608         if (ndr_flags & NDR_SCALARS) {
8609                 NDR_CHECK(ndr_pull_align(ndr, 5));
8610                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8611                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8613                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8614                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8615         }
8616         if (ndr_flags & NDR_BUFFERS) {
8617                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8618         }
8619         return NDR_ERR_SUCCESS;
8620 }
8621
8622 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8623 {
8624         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8625         ndr->depth++;
8626         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8627         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8628         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8629         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8630         ndr->depth--;
8631 }
8632
8633 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8634 {
8635         if (ndr_flags & NDR_SCALARS) {
8636                 NDR_CHECK(ndr_push_align(ndr, 5));
8637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8638                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8639                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8640         }
8641         if (ndr_flags & NDR_BUFFERS) {
8642                 if (r->next) {
8643                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8644                 }
8645                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8646         }
8647         return NDR_ERR_SUCCESS;
8648 }
8649
8650 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8651 {
8652         uint32_t _ptr_next;
8653         TALLOC_CTX *_mem_save_next_0;
8654         if (ndr_flags & NDR_SCALARS) {
8655                 NDR_CHECK(ndr_pull_align(ndr, 5));
8656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8657                 if (_ptr_next) {
8658                         NDR_PULL_ALLOC(ndr, r->next);
8659                 } else {
8660                         r->next = NULL;
8661                 }
8662                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8663                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8664         }
8665         if (ndr_flags & NDR_BUFFERS) {
8666                 if (r->next) {
8667                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8668                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8669                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8670                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8671                 }
8672                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8673         }
8674         return NDR_ERR_SUCCESS;
8675 }
8676
8677 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8678 {
8679         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8680         ndr->depth++;
8681         ndr_print_ptr(ndr, "next", r->next);
8682         ndr->depth++;
8683         if (r->next) {
8684                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8685         }
8686         ndr->depth--;
8687         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8688         ndr->depth--;
8689 }
8690
8691 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8692 {
8693         if (ndr_flags & NDR_SCALARS) {
8694                 NDR_CHECK(ndr_push_align(ndr, 5));
8695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8696                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8697                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8698                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8699         }
8700         if (ndr_flags & NDR_BUFFERS) {
8701                 if (r->id) {
8702                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8703                 }
8704                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8705         }
8706         return NDR_ERR_SUCCESS;
8707 }
8708
8709 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8710 {
8711         uint32_t _ptr_id;
8712         TALLOC_CTX *_mem_save_id_0;
8713         if (ndr_flags & NDR_SCALARS) {
8714                 NDR_CHECK(ndr_pull_align(ndr, 5));
8715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8716                 if (_ptr_id) {
8717                         NDR_PULL_ALLOC(ndr, r->id);
8718                 } else {
8719                         r->id = NULL;
8720                 }
8721                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8722                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8723                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8724         }
8725         if (ndr_flags & NDR_BUFFERS) {
8726                 if (r->id) {
8727                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8728                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8729                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8730                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8731                 }
8732                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8733         }
8734         return NDR_ERR_SUCCESS;
8735 }
8736
8737 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8738 {
8739         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8740         ndr->depth++;
8741         ndr_print_ptr(ndr, "id", r->id);
8742         ndr->depth++;
8743         if (r->id) {
8744                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8745         }
8746         ndr->depth--;
8747         ndr_print_WERROR(ndr, "status", r->status);
8748         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8749         ndr->depth--;
8750 }
8751
8752 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8753 {
8754         if (ndr_flags & NDR_SCALARS) {
8755                 int level = ndr_push_get_switch_value(ndr, r);
8756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8757                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8758                 switch (level) {
8759                         case 1: {
8760                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8761                         break; }
8762
8763                         case 4: {
8764                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8765                         break; }
8766
8767                         case 5: {
8768                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8769                         break; }
8770
8771                         case 6: {
8772                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8773                         break; }
8774
8775                         case 7: {
8776                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8777                         break; }
8778
8779                         default:
8780                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8781                 }
8782         }
8783         if (ndr_flags & NDR_BUFFERS) {
8784                 int level = ndr_push_get_switch_value(ndr, r);
8785                 switch (level) {
8786                         case 1:
8787                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8788                         break;
8789
8790                         case 4:
8791                         break;
8792
8793                         case 5:
8794                         break;
8795
8796                         case 6:
8797                         break;
8798
8799                         case 7:
8800                         break;
8801
8802                         default:
8803                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8804                 }
8805         }
8806         return NDR_ERR_SUCCESS;
8807 }
8808
8809 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8810 {
8811         int level;
8812         uint32_t _level;
8813         level = ndr_pull_get_switch_value(ndr, r);
8814         if (ndr_flags & NDR_SCALARS) {
8815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8816                 if (_level != level) {
8817                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8818                 }
8819                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8820                 switch (level) {
8821                         case 1: {
8822                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8823                         break; }
8824
8825                         case 4: {
8826                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8827                         break; }
8828
8829                         case 5: {
8830                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8831                         break; }
8832
8833                         case 6: {
8834                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8835                         break; }
8836
8837                         case 7: {
8838                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8839                         break; }
8840
8841                         default:
8842                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8843                 }
8844         }
8845         if (ndr_flags & NDR_BUFFERS) {
8846                 switch (level) {
8847                         case 1:
8848                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8849                         break;
8850
8851                         case 4:
8852                         break;
8853
8854                         case 5:
8855                         break;
8856
8857                         case 6:
8858                         break;
8859
8860                         case 7:
8861                         break;
8862
8863                         default:
8864                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8865                 }
8866         }
8867         return NDR_ERR_SUCCESS;
8868 }
8869
8870 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8871 {
8872         int level;
8873         level = ndr_print_get_switch_value(ndr, r);
8874         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8875         switch (level) {
8876                 case 1:
8877                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8878                 break;
8879
8880                 case 4:
8881                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8882                 break;
8883
8884                 case 5:
8885                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8886                 break;
8887
8888                 case 6:
8889                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8890                 break;
8891
8892                 case 7:
8893                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8894                 break;
8895
8896                 default:
8897                         ndr_print_bad_level(ndr, name, level);
8898         }
8899 }
8900
8901 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8902 {
8903         if (ndr_flags & NDR_SCALARS) {
8904                 NDR_CHECK(ndr_push_align(ndr, 5));
8905                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8908                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8909         }
8910         if (ndr_flags & NDR_BUFFERS) {
8911                 if (r->info) {
8912                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8913                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8914                 }
8915         }
8916         return NDR_ERR_SUCCESS;
8917 }
8918
8919 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8920 {
8921         uint32_t _ptr_info;
8922         TALLOC_CTX *_mem_save_info_0;
8923         if (ndr_flags & NDR_SCALARS) {
8924                 NDR_CHECK(ndr_pull_align(ndr, 5));
8925                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8927                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8928                 if (_ptr_info) {
8929                         NDR_PULL_ALLOC(ndr, r->info);
8930                 } else {
8931                         r->info = NULL;
8932                 }
8933                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8934         }
8935         if (ndr_flags & NDR_BUFFERS) {
8936                 if (r->info) {
8937                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8938                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8939                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8940                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8942                 }
8943         }
8944         return NDR_ERR_SUCCESS;
8945 }
8946
8947 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8948 {
8949         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8950         ndr->depth++;
8951         ndr_print_WERROR(ndr, "status", r->status);
8952         ndr_print_uint32(ndr, "level", r->level);
8953         ndr_print_ptr(ndr, "info", r->info);
8954         ndr->depth++;
8955         if (r->info) {
8956                 ndr_print_set_switch_value(ndr, r->info, r->level);
8957                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8958         }
8959         ndr->depth--;
8960         ndr->depth--;
8961 }
8962
8963 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8964 {
8965         if (ndr_flags & NDR_SCALARS) {
8966                 int level = ndr_push_get_switch_value(ndr, r);
8967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8968                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8969                 switch (level) {
8970                         case 1: {
8971                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8972                         break; }
8973
8974                         default:
8975                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8976                 }
8977         }
8978         if (ndr_flags & NDR_BUFFERS) {
8979                 int level = ndr_push_get_switch_value(ndr, r);
8980                 switch (level) {
8981                         case 1:
8982                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8983                         break;
8984
8985                         default:
8986                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8987                 }
8988         }
8989         return NDR_ERR_SUCCESS;
8990 }
8991
8992 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8993 {
8994         int level;
8995         uint32_t _level;
8996         level = ndr_pull_get_switch_value(ndr, r);
8997         if (ndr_flags & NDR_SCALARS) {
8998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8999                 if (_level != level) {
9000                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9001                 }
9002                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9003                 switch (level) {
9004                         case 1: {
9005                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
9006                         break; }
9007
9008                         default:
9009                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9010                 }
9011         }
9012         if (ndr_flags & NDR_BUFFERS) {
9013                 switch (level) {
9014                         case 1:
9015                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
9016                         break;
9017
9018                         default:
9019                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9020                 }
9021         }
9022         return NDR_ERR_SUCCESS;
9023 }
9024
9025 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
9026 {
9027         int level;
9028         level = ndr_print_get_switch_value(ndr, r);
9029         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
9030         switch (level) {
9031                 case 1:
9032                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
9033                 break;
9034
9035                 default:
9036                         ndr_print_bad_level(ndr, name, level);
9037         }
9038 }
9039
9040 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9041 {
9042         if (ndr_flags & NDR_SCALARS) {
9043                 NDR_CHECK(ndr_push_align(ndr, 4));
9044                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
9045                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9046                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9047         }
9048         if (ndr_flags & NDR_BUFFERS) {
9049                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9050         }
9051         return NDR_ERR_SUCCESS;
9052 }
9053
9054 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
9055 {
9056         if (ndr_flags & NDR_SCALARS) {
9057                 NDR_CHECK(ndr_pull_align(ndr, 4));
9058                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
9059                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9060                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9061         }
9062         if (ndr_flags & NDR_BUFFERS) {
9063                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9064         }
9065         return NDR_ERR_SUCCESS;
9066 }
9067
9068 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9069 {
9070         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9071         ndr->depth++;
9072         ndr_print_GUID(ndr, "guid", &r->guid);
9073         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9074         ndr->depth--;
9075 }
9076
9077 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9078 {
9079         uint32_t cntr_objects_1;
9080         if (ndr_flags & NDR_SCALARS) {
9081                 NDR_CHECK(ndr_push_align(ndr, 5));
9082                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9084                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9087                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9088         }
9089         if (ndr_flags & NDR_BUFFERS) {
9090                 if (r->id) {
9091                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9092                 }
9093                 if (r->objects) {
9094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9095                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9096                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9097                         }
9098                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9099                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9100                         }
9101                 }
9102         }
9103         return NDR_ERR_SUCCESS;
9104 }
9105
9106 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9107 {
9108         uint32_t _ptr_id;
9109         TALLOC_CTX *_mem_save_id_0;
9110         uint32_t _ptr_objects;
9111         uint32_t cntr_objects_1;
9112         TALLOC_CTX *_mem_save_objects_0;
9113         TALLOC_CTX *_mem_save_objects_1;
9114         if (ndr_flags & NDR_SCALARS) {
9115                 NDR_CHECK(ndr_pull_align(ndr, 5));
9116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9117                 if (_ptr_id) {
9118                         NDR_PULL_ALLOC(ndr, r->id);
9119                 } else {
9120                         r->id = NULL;
9121                 }
9122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9123                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9125                 if (r->count > 10000) {
9126                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9127                 }
9128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9129                 if (_ptr_objects) {
9130                         NDR_PULL_ALLOC(ndr, r->objects);
9131                 } else {
9132                         r->objects = NULL;
9133                 }
9134                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9135         }
9136         if (ndr_flags & NDR_BUFFERS) {
9137                 if (r->id) {
9138                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9139                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9140                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9142                 }
9143                 if (r->objects) {
9144                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9145                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9146                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9147                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9148                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9149                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9150                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9151                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9152                         }
9153                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9154                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9155                         }
9156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9158                 }
9159                 if (r->objects) {
9160                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9161                 }
9162         }
9163         return NDR_ERR_SUCCESS;
9164 }
9165
9166 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9167 {
9168         uint32_t cntr_objects_1;
9169         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9170         ndr->depth++;
9171         ndr_print_ptr(ndr, "id", r->id);
9172         ndr->depth++;
9173         if (r->id) {
9174                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9175         }
9176         ndr->depth--;
9177         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9178         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9179         ndr_print_uint32(ndr, "count", r->count);
9180         ndr_print_ptr(ndr, "objects", r->objects);
9181         ndr->depth++;
9182         if (r->objects) {
9183                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9184                 ndr->depth++;
9185                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9186                         char *idx_1=NULL;
9187                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9188                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9189                                 free(idx_1);
9190                         }
9191                 }
9192                 ndr->depth--;
9193         }
9194         ndr->depth--;
9195         ndr->depth--;
9196 }
9197
9198 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9199 {
9200         uint32_t cntr_objects_1;
9201         if (ndr_flags & NDR_SCALARS) {
9202                 NDR_CHECK(ndr_push_align(ndr, 5));
9203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9205                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9207                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9208                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9209         }
9210         if (ndr_flags & NDR_BUFFERS) {
9211                 if (r->id) {
9212                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9213                 }
9214                 if (r->error) {
9215                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9216                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9217                 }
9218                 if (r->objects) {
9219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9220                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9221                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9222                         }
9223                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9224                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9225                         }
9226                 }
9227         }
9228         return NDR_ERR_SUCCESS;
9229 }
9230
9231 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9232 {
9233         uint32_t _ptr_id;
9234         TALLOC_CTX *_mem_save_id_0;
9235         uint32_t _ptr_error;
9236         TALLOC_CTX *_mem_save_error_0;
9237         uint32_t _ptr_objects;
9238         uint32_t cntr_objects_1;
9239         TALLOC_CTX *_mem_save_objects_0;
9240         TALLOC_CTX *_mem_save_objects_1;
9241         if (ndr_flags & NDR_SCALARS) {
9242                 NDR_CHECK(ndr_pull_align(ndr, 5));
9243                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9244                 if (_ptr_id) {
9245                         NDR_PULL_ALLOC(ndr, r->id);
9246                 } else {
9247                         r->id = NULL;
9248                 }
9249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9251                 if (_ptr_error) {
9252                         NDR_PULL_ALLOC(ndr, r->error);
9253                 } else {
9254                         r->error = NULL;
9255                 }
9256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9257                 if (r->count > 10000) {
9258                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9259                 }
9260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9261                 if (_ptr_objects) {
9262                         NDR_PULL_ALLOC(ndr, r->objects);
9263                 } else {
9264                         r->objects = NULL;
9265                 }
9266                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9267         }
9268         if (ndr_flags & NDR_BUFFERS) {
9269                 if (r->id) {
9270                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9271                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9272                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9274                 }
9275                 if (r->error) {
9276                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9277                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9278                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9279                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9281                 }
9282                 if (r->objects) {
9283                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9284                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9286                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9287                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9288                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9289                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9290                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9291                         }
9292                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9293                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9294                         }
9295                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9297                 }
9298                 if (r->objects) {
9299                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9300                 }
9301         }
9302         return NDR_ERR_SUCCESS;
9303 }
9304
9305 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9306 {
9307         uint32_t cntr_objects_1;
9308         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9309         ndr->depth++;
9310         ndr_print_ptr(ndr, "id", r->id);
9311         ndr->depth++;
9312         if (r->id) {
9313                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9314         }
9315         ndr->depth--;
9316         ndr_print_uint32(ndr, "level", r->level);
9317         ndr_print_ptr(ndr, "error", r->error);
9318         ndr->depth++;
9319         if (r->error) {
9320                 ndr_print_set_switch_value(ndr, r->error, r->level);
9321                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9322         }
9323         ndr->depth--;
9324         ndr_print_uint32(ndr, "count", r->count);
9325         ndr_print_ptr(ndr, "objects", r->objects);
9326         ndr->depth++;
9327         if (r->objects) {
9328                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9329                 ndr->depth++;
9330                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9331                         char *idx_1=NULL;
9332                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9333                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9334                                 free(idx_1);
9335                         }
9336                 }
9337                 ndr->depth--;
9338         }
9339         ndr->depth--;
9340         ndr->depth--;
9341 }
9342
9343 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9344 {
9345         if (ndr_flags & NDR_SCALARS) {
9346                 int level = ndr_push_get_switch_value(ndr, r);
9347                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9348                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9349                 switch (level) {
9350                         case 2: {
9351                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9352                         break; }
9353
9354                         case 3: {
9355                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9356                         break; }
9357
9358                         default:
9359                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9360                 }
9361         }
9362         if (ndr_flags & NDR_BUFFERS) {
9363                 int level = ndr_push_get_switch_value(ndr, r);
9364                 switch (level) {
9365                         case 2:
9366                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9367                         break;
9368
9369                         case 3:
9370                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9371                         break;
9372
9373                         default:
9374                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9375                 }
9376         }
9377         return NDR_ERR_SUCCESS;
9378 }
9379
9380 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9381 {
9382         int level;
9383         int32_t _level;
9384         level = ndr_pull_get_switch_value(ndr, r);
9385         if (ndr_flags & NDR_SCALARS) {
9386                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9387                 if (_level != level) {
9388                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9389                 }
9390                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9391                 switch (level) {
9392                         case 2: {
9393                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9394                         break; }
9395
9396                         case 3: {
9397                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9398                         break; }
9399
9400                         default:
9401                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9402                 }
9403         }
9404         if (ndr_flags & NDR_BUFFERS) {
9405                 switch (level) {
9406                         case 2:
9407                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9408                         break;
9409
9410                         case 3:
9411                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9412                         break;
9413
9414                         default:
9415                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9416                 }
9417         }
9418         return NDR_ERR_SUCCESS;
9419 }
9420
9421 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9422 {
9423         int level;
9424         level = ndr_print_get_switch_value(ndr, r);
9425         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9426         switch (level) {
9427                 case 2:
9428                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9429                 break;
9430
9431                 case 3:
9432                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9433                 break;
9434
9435                 default:
9436                         ndr_print_bad_level(ndr, name, level);
9437         }
9438 }
9439
9440 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9441 {
9442         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9443         return NDR_ERR_SUCCESS;
9444 }
9445
9446 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9447 {
9448         uint32_t v;
9449         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9450         *r = v;
9451         return NDR_ERR_SUCCESS;
9452 }
9453
9454 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9455 {
9456         ndr_print_uint32(ndr, name, r);
9457         ndr->depth++;
9458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9460         ndr->depth--;
9461 }
9462
9463 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9464 {
9465         if (ndr_flags & NDR_SCALARS) {
9466                 NDR_CHECK(ndr_push_align(ndr, 4));
9467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9468                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9469                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9470         }
9471         if (ndr_flags & NDR_BUFFERS) {
9472         }
9473         return NDR_ERR_SUCCESS;
9474 }
9475
9476 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9477 {
9478         if (ndr_flags & NDR_SCALARS) {
9479                 NDR_CHECK(ndr_pull_align(ndr, 4));
9480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9481                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9482                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9483         }
9484         if (ndr_flags & NDR_BUFFERS) {
9485         }
9486         return NDR_ERR_SUCCESS;
9487 }
9488
9489 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9490 {
9491         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9492         ndr->depth++;
9493         ndr_print_uint32(ndr, "taskID", r->taskID);
9494         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9495         ndr->depth--;
9496 }
9497
9498 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9499 {
9500         if (ndr_flags & NDR_SCALARS) {
9501                 int level = ndr_push_get_switch_value(ndr, r);
9502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9503                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9504                 switch (level) {
9505                         case 1: {
9506                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9507                         break; }
9508
9509                         default:
9510                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9511                 }
9512         }
9513         if (ndr_flags & NDR_BUFFERS) {
9514                 int level = ndr_push_get_switch_value(ndr, r);
9515                 switch (level) {
9516                         case 1:
9517                         break;
9518
9519                         default:
9520                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9521                 }
9522         }
9523         return NDR_ERR_SUCCESS;
9524 }
9525
9526 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9527 {
9528         int level;
9529         uint32_t _level;
9530         level = ndr_pull_get_switch_value(ndr, r);
9531         if (ndr_flags & NDR_SCALARS) {
9532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9533                 if (_level != level) {
9534                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9535                 }
9536                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9537                 switch (level) {
9538                         case 1: {
9539                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9540                         break; }
9541
9542                         default:
9543                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9544                 }
9545         }
9546         if (ndr_flags & NDR_BUFFERS) {
9547                 switch (level) {
9548                         case 1:
9549                         break;
9550
9551                         default:
9552                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9553                 }
9554         }
9555         return NDR_ERR_SUCCESS;
9556 }
9557
9558 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9559 {
9560         int level;
9561         level = ndr_print_get_switch_value(ndr, r);
9562         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9563         switch (level) {
9564                 case 1:
9565                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9566                 break;
9567
9568                 default:
9569                         ndr_print_bad_level(ndr, name, level);
9570         }
9571 }
9572
9573 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9574 {
9575         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9576         return NDR_ERR_SUCCESS;
9577 }
9578
9579 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9580 {
9581         uint32_t v;
9582         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9583         *r = v;
9584         return NDR_ERR_SUCCESS;
9585 }
9586
9587 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9588 {
9589         const char *val = NULL;
9590
9591         switch (r) {
9592                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9593                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9594         }
9595         ndr_print_enum(ndr, name, "ENUM", val, r);
9596 }
9597
9598 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9599 {
9600         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9601         return NDR_ERR_SUCCESS;
9602 }
9603
9604 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9605 {
9606         uint32_t v;
9607         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9608         *r = v;
9609         return NDR_ERR_SUCCESS;
9610 }
9611
9612 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9613 {
9614         const char *val = NULL;
9615
9616         switch (r) {
9617                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9618                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9619                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9620                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9621                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9622                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9623                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9624                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9625                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9626                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9627                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9628                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9629                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9630                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9631                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9632         }
9633         ndr_print_enum(ndr, name, "ENUM", val, r);
9634 }
9635
9636 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9637 {
9638         if (ndr_flags & NDR_SCALARS) {
9639                 NDR_CHECK(ndr_push_align(ndr, 5));
9640                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9642                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9643                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9644         }
9645         if (ndr_flags & NDR_BUFFERS) {
9646                 if (r->object_dn) {
9647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9650                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9651                 }
9652         }
9653         return NDR_ERR_SUCCESS;
9654 }
9655
9656 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9657 {
9658         uint32_t _ptr_object_dn;
9659         TALLOC_CTX *_mem_save_object_dn_0;
9660         if (ndr_flags & NDR_SCALARS) {
9661                 NDR_CHECK(ndr_pull_align(ndr, 5));
9662                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9663                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9664                 if (_ptr_object_dn) {
9665                         NDR_PULL_ALLOC(ndr, r->object_dn);
9666                 } else {
9667                         r->object_dn = NULL;
9668                 }
9669                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9670                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9671         }
9672         if (ndr_flags & NDR_BUFFERS) {
9673                 if (r->object_dn) {
9674                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9675                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9676                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9677                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9678                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9679                                 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));
9680                         }
9681                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9682                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9683                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9684                 }
9685         }
9686         return NDR_ERR_SUCCESS;
9687 }
9688
9689 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9690 {
9691         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9692         ndr->depth++;
9693         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9694         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9695         ndr->depth++;
9696         if (r->object_dn) {
9697                 ndr_print_string(ndr, "object_dn", r->object_dn);
9698         }
9699         ndr->depth--;
9700         ndr_print_GUID(ndr, "guid1", &r->guid1);
9701         ndr->depth--;
9702 }
9703
9704 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9705 {
9706         if (ndr_flags & NDR_SCALARS) {
9707                 NDR_CHECK(ndr_push_align(ndr, 5));
9708                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9710                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
9715                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9716         }
9717         if (ndr_flags & NDR_BUFFERS) {
9718                 if (r->object_dn) {
9719                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9722                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9723                 }
9724                 if (r->string1) {
9725                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9726                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9728                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9729                 }
9730                 if (r->string2) {
9731                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9732                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9734                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9735                 }
9736         }
9737         return NDR_ERR_SUCCESS;
9738 }
9739
9740 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9741 {
9742         uint32_t _ptr_object_dn;
9743         TALLOC_CTX *_mem_save_object_dn_0;
9744         uint32_t _ptr_string1;
9745         TALLOC_CTX *_mem_save_string1_0;
9746         uint32_t _ptr_string2;
9747         TALLOC_CTX *_mem_save_string2_0;
9748         if (ndr_flags & NDR_SCALARS) {
9749                 NDR_CHECK(ndr_pull_align(ndr, 5));
9750                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9752                 if (_ptr_object_dn) {
9753                         NDR_PULL_ALLOC(ndr, r->object_dn);
9754                 } else {
9755                         r->object_dn = NULL;
9756                 }
9757                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9758                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9759                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9760                 if (_ptr_string1) {
9761                         NDR_PULL_ALLOC(ndr, r->string1);
9762                 } else {
9763                         r->string1 = NULL;
9764                 }
9765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9766                 if (_ptr_string2) {
9767                         NDR_PULL_ALLOC(ndr, r->string2);
9768                 } else {
9769                         r->string2 = NULL;
9770                 }
9771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
9772                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9773         }
9774         if (ndr_flags & NDR_BUFFERS) {
9775                 if (r->object_dn) {
9776                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9777                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9780                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9781                                 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));
9782                         }
9783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9786                 }
9787                 if (r->string1) {
9788                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9789                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9790                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9791                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9792                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9793                                 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));
9794                         }
9795                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9796                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9798                 }
9799                 if (r->string2) {
9800                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9801                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9802                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9803                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9804                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9805                                 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));
9806                         }
9807                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9808                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9810                 }
9811         }
9812         return NDR_ERR_SUCCESS;
9813 }
9814
9815 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9816 {
9817         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9818         ndr->depth++;
9819         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9820         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9821         ndr->depth++;
9822         if (r->object_dn) {
9823                 ndr_print_string(ndr, "object_dn", r->object_dn);
9824         }
9825         ndr->depth--;
9826         ndr_print_GUID(ndr, "guid1", &r->guid1);
9827         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9828         ndr_print_ptr(ndr, "string1", r->string1);
9829         ndr->depth++;
9830         if (r->string1) {
9831                 ndr_print_string(ndr, "string1", r->string1);
9832         }
9833         ndr->depth--;
9834         ndr_print_ptr(ndr, "string2", r->string2);
9835         ndr->depth++;
9836         if (r->string2) {
9837                 ndr_print_string(ndr, "string2", r->string2);
9838         }
9839         ndr->depth--;
9840         ndr_print_uint32(ndr, "unknown2", r->unknown2);
9841         ndr->depth--;
9842 }
9843
9844 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9845 {
9846         if (ndr_flags & NDR_SCALARS) {
9847                 int level = ndr_push_get_switch_value(ndr, r);
9848                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9849                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9850                 switch (level) {
9851                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9852                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9853                         break; }
9854
9855                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9856                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9857                         break; }
9858
9859                         default:
9860                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9861                 }
9862         }
9863         if (ndr_flags & NDR_BUFFERS) {
9864                 int level = ndr_push_get_switch_value(ndr, r);
9865                 switch (level) {
9866                         case DRSUAPI_DS_REPLICA_GET_INFO:
9867                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9868                         break;
9869
9870                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9871                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9872                         break;
9873
9874                         default:
9875                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9876                 }
9877         }
9878         return NDR_ERR_SUCCESS;
9879 }
9880
9881 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9882 {
9883         int level;
9884         uint32_t _level;
9885         level = ndr_pull_get_switch_value(ndr, r);
9886         if (ndr_flags & NDR_SCALARS) {
9887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9888                 if (_level != level) {
9889                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9890                 }
9891                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9892                 switch (level) {
9893                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9894                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9895                         break; }
9896
9897                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9898                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9899                         break; }
9900
9901                         default:
9902                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9903                 }
9904         }
9905         if (ndr_flags & NDR_BUFFERS) {
9906                 switch (level) {
9907                         case DRSUAPI_DS_REPLICA_GET_INFO:
9908                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9909                         break;
9910
9911                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9912                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9913                         break;
9914
9915                         default:
9916                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9917                 }
9918         }
9919         return NDR_ERR_SUCCESS;
9920 }
9921
9922 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9923 {
9924         int level;
9925         level = ndr_print_get_switch_value(ndr, r);
9926         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9927         switch (level) {
9928                 case DRSUAPI_DS_REPLICA_GET_INFO:
9929                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9930                 break;
9931
9932                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9933                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9934                 break;
9935
9936                 default:
9937                         ndr_print_bad_level(ndr, name, level);
9938         }
9939 }
9940
9941 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9942 {
9943         if (ndr_flags & NDR_SCALARS) {
9944                 NDR_CHECK(ndr_push_align(ndr, 8));
9945                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9946                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9947                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9948                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9949                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
9950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9951                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9952                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9953                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9954                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9955                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9956                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9957                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9958                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9959                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9961                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9962         }
9963         if (ndr_flags & NDR_BUFFERS) {
9964                 if (r->naming_context_dn) {
9965                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9968                         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));
9969                 }
9970                 if (r->source_dsa_obj_dn) {
9971                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9974                         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));
9975                 }
9976                 if (r->source_dsa_address) {
9977                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9980                         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));
9981                 }
9982                 if (r->transport_obj_dn) {
9983                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9984                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9985                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9986                         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));
9987                 }
9988         }
9989         return NDR_ERR_SUCCESS;
9990 }
9991
9992 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9993 {
9994         uint32_t _ptr_naming_context_dn;
9995         TALLOC_CTX *_mem_save_naming_context_dn_0;
9996         uint32_t _ptr_source_dsa_obj_dn;
9997         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9998         uint32_t _ptr_source_dsa_address;
9999         TALLOC_CTX *_mem_save_source_dsa_address_0;
10000         uint32_t _ptr_transport_obj_dn;
10001         TALLOC_CTX *_mem_save_transport_obj_dn_0;
10002         if (ndr_flags & NDR_SCALARS) {
10003                 NDR_CHECK(ndr_pull_align(ndr, 8));
10004                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
10005                 if (_ptr_naming_context_dn) {
10006                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
10007                 } else {
10008                         r->naming_context_dn = NULL;
10009                 }
10010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
10011                 if (_ptr_source_dsa_obj_dn) {
10012                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
10013                 } else {
10014                         r->source_dsa_obj_dn = NULL;
10015                 }
10016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
10017                 if (_ptr_source_dsa_address) {
10018                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
10019                 } else {
10020                         r->source_dsa_address = NULL;
10021                 }
10022                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
10023                 if (_ptr_transport_obj_dn) {
10024                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
10025                 } else {
10026                         r->transport_obj_dn = NULL;
10027                 }
10028                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
10029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10030                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
10031                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
10032                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10033                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
10034                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
10035                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
10036                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
10037                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
10038                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
10039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
10040                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10041         }
10042         if (ndr_flags & NDR_BUFFERS) {
10043                 if (r->naming_context_dn) {
10044                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10045                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10046                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10047                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10048                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10049                                 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));
10050                         }
10051                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10052                         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));
10053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10054                 }
10055                 if (r->source_dsa_obj_dn) {
10056                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10057                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10058                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10059                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10060                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10061                                 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));
10062                         }
10063                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10064                         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));
10065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10066                 }
10067                 if (r->source_dsa_address) {
10068                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10069                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10070                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10071                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10072                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10073                                 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));
10074                         }
10075                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10076                         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));
10077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10078                 }
10079                 if (r->transport_obj_dn) {
10080                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10081                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10082                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10083                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10084                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10085                                 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));
10086                         }
10087                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10088                         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));
10089                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10090                 }
10091         }
10092         return NDR_ERR_SUCCESS;
10093 }
10094
10095 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10096 {
10097         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10098         ndr->depth++;
10099         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10100         ndr->depth++;
10101         if (r->naming_context_dn) {
10102                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10103         }
10104         ndr->depth--;
10105         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10106         ndr->depth++;
10107         if (r->source_dsa_obj_dn) {
10108                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10109         }
10110         ndr->depth--;
10111         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10112         ndr->depth++;
10113         if (r->source_dsa_address) {
10114                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10115         }
10116         ndr->depth--;
10117         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10118         ndr->depth++;
10119         if (r->transport_obj_dn) {
10120                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10121         }
10122         ndr->depth--;
10123         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
10124         ndr_print_uint32(ndr, "reserved", r->reserved);
10125         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10126         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10127         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10128         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10129         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10130         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10131         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10132         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10133         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10134         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10135         ndr->depth--;
10136 }
10137
10138 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10139 {
10140         uint32_t cntr_array_0;
10141         if (ndr_flags & NDR_SCALARS) {
10142                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10143                 NDR_CHECK(ndr_push_align(ndr, 8));
10144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10146                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10147                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10148                 }
10149                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10150         }
10151         if (ndr_flags & NDR_BUFFERS) {
10152                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10153                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10154                 }
10155         }
10156         return NDR_ERR_SUCCESS;
10157 }
10158
10159 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10160 {
10161         uint32_t cntr_array_0;
10162         TALLOC_CTX *_mem_save_array_0;
10163         if (ndr_flags & NDR_SCALARS) {
10164                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10165                 NDR_CHECK(ndr_pull_align(ndr, 8));
10166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10168                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10169                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10170                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10171                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10172                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10173                 }
10174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10175                 if (r->array) {
10176                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10177                 }
10178                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10179         }
10180         if (ndr_flags & NDR_BUFFERS) {
10181                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10182                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10183                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10184                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10185                 }
10186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10187         }
10188         return NDR_ERR_SUCCESS;
10189 }
10190
10191 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10192 {
10193         uint32_t cntr_array_0;
10194         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10195         ndr->depth++;
10196         ndr_print_uint32(ndr, "count", r->count);
10197         ndr_print_uint32(ndr, "reserved", r->reserved);
10198         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10199         ndr->depth++;
10200         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10201                 char *idx_0=NULL;
10202                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10203                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10204                         free(idx_0);
10205                 }
10206         }
10207         ndr->depth--;
10208         ndr->depth--;
10209 }
10210
10211 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10212 {
10213         uint32_t cntr_array_0;
10214         if (ndr_flags & NDR_SCALARS) {
10215                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10216                 NDR_CHECK(ndr_push_align(ndr, 8));
10217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10219                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10220                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10221                 }
10222                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10223         }
10224         if (ndr_flags & NDR_BUFFERS) {
10225         }
10226         return NDR_ERR_SUCCESS;
10227 }
10228
10229 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10230 {
10231         uint32_t cntr_array_0;
10232         TALLOC_CTX *_mem_save_array_0;
10233         if (ndr_flags & NDR_SCALARS) {
10234                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10235                 NDR_CHECK(ndr_pull_align(ndr, 8));
10236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10238                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10239                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10240                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10241                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10242                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10243                 }
10244                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10245                 if (r->array) {
10246                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10247                 }
10248                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10249         }
10250         if (ndr_flags & NDR_BUFFERS) {
10251         }
10252         return NDR_ERR_SUCCESS;
10253 }
10254
10255 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10256 {
10257         uint32_t cntr_array_0;
10258         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10259         ndr->depth++;
10260         ndr_print_uint32(ndr, "count", r->count);
10261         ndr_print_uint32(ndr, "reserved", r->reserved);
10262         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10263         ndr->depth++;
10264         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10265                 char *idx_0=NULL;
10266                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10267                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10268                         free(idx_0);
10269                 }
10270         }
10271         ndr->depth--;
10272         ndr->depth--;
10273 }
10274
10275 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10276 {
10277         if (ndr_flags & NDR_SCALARS) {
10278                 NDR_CHECK(ndr_push_align(ndr, 8));
10279                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10281                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10282                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10283                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10284                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10285                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10286         }
10287         if (ndr_flags & NDR_BUFFERS) {
10288                 if (r->attribute_name) {
10289                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10292                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10293                 }
10294         }
10295         return NDR_ERR_SUCCESS;
10296 }
10297
10298 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10299 {
10300         uint32_t _ptr_attribute_name;
10301         TALLOC_CTX *_mem_save_attribute_name_0;
10302         if (ndr_flags & NDR_SCALARS) {
10303                 NDR_CHECK(ndr_pull_align(ndr, 8));
10304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10305                 if (_ptr_attribute_name) {
10306                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10307                 } else {
10308                         r->attribute_name = NULL;
10309                 }
10310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10311                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10312                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10313                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10314                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10315                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10316         }
10317         if (ndr_flags & NDR_BUFFERS) {
10318                 if (r->attribute_name) {
10319                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10320                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10323                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10324                                 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));
10325                         }
10326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10329                 }
10330         }
10331         return NDR_ERR_SUCCESS;
10332 }
10333
10334 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10335 {
10336         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10337         ndr->depth++;
10338         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10339         ndr->depth++;
10340         if (r->attribute_name) {
10341                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10342         }
10343         ndr->depth--;
10344         ndr_print_uint32(ndr, "version", r->version);
10345         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10346         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10347         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10348         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10349         ndr->depth--;
10350 }
10351
10352 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10353 {
10354         uint32_t cntr_array_0;
10355         if (ndr_flags & NDR_SCALARS) {
10356                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10357                 NDR_CHECK(ndr_push_align(ndr, 8));
10358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10360                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10361                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10362                 }
10363                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10364         }
10365         if (ndr_flags & NDR_BUFFERS) {
10366                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10367                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10368                 }
10369         }
10370         return NDR_ERR_SUCCESS;
10371 }
10372
10373 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10374 {
10375         uint32_t cntr_array_0;
10376         TALLOC_CTX *_mem_save_array_0;
10377         if (ndr_flags & NDR_SCALARS) {
10378                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10379                 NDR_CHECK(ndr_pull_align(ndr, 8));
10380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10382                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10383                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10384                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10385                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10386                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10387                 }
10388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10389                 if (r->array) {
10390                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10391                 }
10392                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10393         }
10394         if (ndr_flags & NDR_BUFFERS) {
10395                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10396                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10397                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10398                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10399                 }
10400                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10401         }
10402         return NDR_ERR_SUCCESS;
10403 }
10404
10405 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10406 {
10407         uint32_t cntr_array_0;
10408         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10409         ndr->depth++;
10410         ndr_print_uint32(ndr, "count", r->count);
10411         ndr_print_uint32(ndr, "reserved", r->reserved);
10412         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10413         ndr->depth++;
10414         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10415                 char *idx_0=NULL;
10416                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10417                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10418                         free(idx_0);
10419                 }
10420         }
10421         ndr->depth--;
10422         ndr->depth--;
10423 }
10424
10425 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10426 {
10427         if (ndr_flags & NDR_SCALARS) {
10428                 NDR_CHECK(ndr_push_align(ndr, 5));
10429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10430                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10431                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10433                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10434                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10435         }
10436         if (ndr_flags & NDR_BUFFERS) {
10437                 if (r->dsa_obj_dn) {
10438                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10440                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10441                         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));
10442                 }
10443         }
10444         return NDR_ERR_SUCCESS;
10445 }
10446
10447 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10448 {
10449         uint32_t _ptr_dsa_obj_dn;
10450         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10451         if (ndr_flags & NDR_SCALARS) {
10452                 NDR_CHECK(ndr_pull_align(ndr, 5));
10453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10454                 if (_ptr_dsa_obj_dn) {
10455                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10456                 } else {
10457                         r->dsa_obj_dn = NULL;
10458                 }
10459                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10460                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10462                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10463                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10464         }
10465         if (ndr_flags & NDR_BUFFERS) {
10466                 if (r->dsa_obj_dn) {
10467                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10468                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10469                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10470                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10471                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10472                                 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));
10473                         }
10474                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10475                         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));
10476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10477                 }
10478         }
10479         return NDR_ERR_SUCCESS;
10480 }
10481
10482 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10483 {
10484         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10485         ndr->depth++;
10486         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10487         ndr->depth++;
10488         if (r->dsa_obj_dn) {
10489                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10490         }
10491         ndr->depth--;
10492         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10493         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10494         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10495         ndr_print_WERROR(ndr, "last_result", r->last_result);
10496         ndr->depth--;
10497 }
10498
10499 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10500 {
10501         uint32_t cntr_array_0;
10502         if (ndr_flags & NDR_SCALARS) {
10503                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10504                 NDR_CHECK(ndr_push_align(ndr, 5));
10505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10507                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10508                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10509                 }
10510                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10511         }
10512         if (ndr_flags & NDR_BUFFERS) {
10513                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10514                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10515                 }
10516         }
10517         return NDR_ERR_SUCCESS;
10518 }
10519
10520 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10521 {
10522         uint32_t cntr_array_0;
10523         TALLOC_CTX *_mem_save_array_0;
10524         if (ndr_flags & NDR_SCALARS) {
10525                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10526                 NDR_CHECK(ndr_pull_align(ndr, 5));
10527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10529                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10530                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10531                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10532                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10533                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10534                 }
10535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10536                 if (r->array) {
10537                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10538                 }
10539                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10540         }
10541         if (ndr_flags & NDR_BUFFERS) {
10542                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10543                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10544                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10545                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10546                 }
10547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10548         }
10549         return NDR_ERR_SUCCESS;
10550 }
10551
10552 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10553 {
10554         uint32_t cntr_array_0;
10555         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10556         ndr->depth++;
10557         ndr_print_uint32(ndr, "count", r->count);
10558         ndr_print_uint32(ndr, "reserved", r->reserved);
10559         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10560         ndr->depth++;
10561         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10562                 char *idx_0=NULL;
10563                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10564                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10565                         free(idx_0);
10566                 }
10567         }
10568         ndr->depth--;
10569         ndr->depth--;
10570 }
10571
10572 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10573 {
10574         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10575         return NDR_ERR_SUCCESS;
10576 }
10577
10578 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10579 {
10580         uint16_t v;
10581         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10582         *r = v;
10583         return NDR_ERR_SUCCESS;
10584 }
10585
10586 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10587 {
10588         const char *val = NULL;
10589
10590         switch (r) {
10591                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10592                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10593                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10594                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10595                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10596         }
10597         ndr_print_enum(ndr, name, "ENUM", val, r);
10598 }
10599
10600 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10601 {
10602         if (ndr_flags & NDR_SCALARS) {
10603                 NDR_CHECK(ndr_push_align(ndr, 5));
10604                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10607                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10608                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
10609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10610                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10612                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10613                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10614                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10615         }
10616         if (ndr_flags & NDR_BUFFERS) {
10617                 if (r->nc_dn) {
10618                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10619                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10620                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10621                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10622                 }
10623                 if (r->remote_dsa_obj_dn) {
10624                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10625                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10626                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10627                         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));
10628                 }
10629                 if (r->remote_dsa_address) {
10630                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10631                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10632                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10633                         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));
10634                 }
10635         }
10636         return NDR_ERR_SUCCESS;
10637 }
10638
10639 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10640 {
10641         uint32_t _ptr_nc_dn;
10642         TALLOC_CTX *_mem_save_nc_dn_0;
10643         uint32_t _ptr_remote_dsa_obj_dn;
10644         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10645         uint32_t _ptr_remote_dsa_address;
10646         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10647         if (ndr_flags & NDR_SCALARS) {
10648                 NDR_CHECK(ndr_pull_align(ndr, 5));
10649                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10652                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10653                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
10654                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10655                 if (_ptr_nc_dn) {
10656                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10657                 } else {
10658                         r->nc_dn = NULL;
10659                 }
10660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10661                 if (_ptr_remote_dsa_obj_dn) {
10662                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10663                 } else {
10664                         r->remote_dsa_obj_dn = NULL;
10665                 }
10666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10667                 if (_ptr_remote_dsa_address) {
10668                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10669                 } else {
10670                         r->remote_dsa_address = NULL;
10671                 }
10672                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10673                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10674                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10675         }
10676         if (ndr_flags & NDR_BUFFERS) {
10677                 if (r->nc_dn) {
10678                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10679                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10680                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10681                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10682                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10683                                 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));
10684                         }
10685                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10686                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10688                 }
10689                 if (r->remote_dsa_obj_dn) {
10690                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10691                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10692                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10693                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10694                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10695                                 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));
10696                         }
10697                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10698                         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));
10699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10700                 }
10701                 if (r->remote_dsa_address) {
10702                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10703                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10704                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10705                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10706                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10707                                 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));
10708                         }
10709                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10710                         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));
10711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10712                 }
10713         }
10714         return NDR_ERR_SUCCESS;
10715 }
10716
10717 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10718 {
10719         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10720         ndr->depth++;
10721         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10722         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10723         ndr_print_uint32(ndr, "priority", r->priority);
10724         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10725         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
10726         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10727         ndr->depth++;
10728         if (r->nc_dn) {
10729                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10730         }
10731         ndr->depth--;
10732         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10733         ndr->depth++;
10734         if (r->remote_dsa_obj_dn) {
10735                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10736         }
10737         ndr->depth--;
10738         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10739         ndr->depth++;
10740         if (r->remote_dsa_address) {
10741                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10742         }
10743         ndr->depth--;
10744         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10745         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10746         ndr->depth--;
10747 }
10748
10749 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10750 {
10751         uint32_t cntr_array_0;
10752         if (ndr_flags & NDR_SCALARS) {
10753                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10754                 NDR_CHECK(ndr_push_align(ndr, 5));
10755                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10757                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10758                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10759                 }
10760                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10761         }
10762         if (ndr_flags & NDR_BUFFERS) {
10763                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10764                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10765                 }
10766         }
10767         return NDR_ERR_SUCCESS;
10768 }
10769
10770 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10771 {
10772         uint32_t cntr_array_0;
10773         TALLOC_CTX *_mem_save_array_0;
10774         if (ndr_flags & NDR_SCALARS) {
10775                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10776                 NDR_CHECK(ndr_pull_align(ndr, 5));
10777                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10779                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10780                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10781                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10782                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10783                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10784                 }
10785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10786                 if (r->array) {
10787                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10788                 }
10789                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10790         }
10791         if (ndr_flags & NDR_BUFFERS) {
10792                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10793                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10794                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10795                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10796                 }
10797                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10798         }
10799         return NDR_ERR_SUCCESS;
10800 }
10801
10802 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10803 {
10804         uint32_t cntr_array_0;
10805         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10806         ndr->depth++;
10807         ndr_print_NTTIME(ndr, "time", r->time);
10808         ndr_print_uint32(ndr, "count", r->count);
10809         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10810         ndr->depth++;
10811         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10812                 char *idx_0=NULL;
10813                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10814                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10815                         free(idx_0);
10816                 }
10817         }
10818         ndr->depth--;
10819         ndr->depth--;
10820 }
10821
10822 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10823 {
10824         if (ndr_flags & NDR_SCALARS) {
10825                 NDR_CHECK(ndr_push_align(ndr, 8));
10826                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10827                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10830                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10831                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10833                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10834                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10835                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10836                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10837                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10838         }
10839         if (ndr_flags & NDR_BUFFERS) {
10840                 if (r->attribute_name) {
10841                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10842                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10843                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10844                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10845                 }
10846                 if (r->object_dn) {
10847                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10848                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10849                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10850                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10851                 }
10852                 if (r->binary) {
10853                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10854                 }
10855         }
10856         return NDR_ERR_SUCCESS;
10857 }
10858
10859 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10860 {
10861         uint32_t _ptr_attribute_name;
10862         TALLOC_CTX *_mem_save_attribute_name_0;
10863         uint32_t _ptr_object_dn;
10864         TALLOC_CTX *_mem_save_object_dn_0;
10865         uint32_t _ptr_binary;
10866         TALLOC_CTX *_mem_save_binary_0;
10867         if (ndr_flags & NDR_SCALARS) {
10868                 NDR_CHECK(ndr_pull_align(ndr, 8));
10869                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10870                 if (_ptr_attribute_name) {
10871                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10872                 } else {
10873                         r->attribute_name = NULL;
10874                 }
10875                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10876                 if (_ptr_object_dn) {
10877                         NDR_PULL_ALLOC(ndr, r->object_dn);
10878                 } else {
10879                         r->object_dn = NULL;
10880                 }
10881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10883                 if (_ptr_binary) {
10884                         NDR_PULL_ALLOC(ndr, r->binary);
10885                 } else {
10886                         r->binary = NULL;
10887                 }
10888                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10889                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10891                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10892                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10893                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10894                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10895                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10896         }
10897         if (ndr_flags & NDR_BUFFERS) {
10898                 if (r->attribute_name) {
10899                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10900                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10901                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10902                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10903                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10904                                 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));
10905                         }
10906                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10907                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10909                 }
10910                 if (r->object_dn) {
10911                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10912                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10914                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10915                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10916                                 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));
10917                         }
10918                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10919                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10921                 }
10922                 if (r->binary) {
10923                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10924                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10925                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10927                 }
10928         }
10929         return NDR_ERR_SUCCESS;
10930 }
10931
10932 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10933 {
10934         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10935         ndr->depth++;
10936         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10937         ndr->depth++;
10938         if (r->attribute_name) {
10939                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10940         }
10941         ndr->depth--;
10942         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10943         ndr->depth++;
10944         if (r->object_dn) {
10945                 ndr_print_string(ndr, "object_dn", r->object_dn);
10946         }
10947         ndr->depth--;
10948         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);
10949         ndr_print_ptr(ndr, "binary", r->binary);
10950         ndr->depth++;
10951         if (r->binary) {
10952                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10953         }
10954         ndr->depth--;
10955         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10956         ndr_print_NTTIME(ndr, "created", r->created);
10957         ndr_print_uint32(ndr, "version", r->version);
10958         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10959         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10960         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10961         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10962         ndr->depth--;
10963 }
10964
10965 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10966 {
10967         uint32_t cntr_array_0;
10968         if (ndr_flags & NDR_SCALARS) {
10969                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10970                 NDR_CHECK(ndr_push_align(ndr, 8));
10971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10972                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10973                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10974                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10975                 }
10976                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10977         }
10978         if (ndr_flags & NDR_BUFFERS) {
10979                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10980                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10981                 }
10982         }
10983         return NDR_ERR_SUCCESS;
10984 }
10985
10986 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10987 {
10988         uint32_t cntr_array_0;
10989         TALLOC_CTX *_mem_save_array_0;
10990         if (ndr_flags & NDR_SCALARS) {
10991                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10992                 NDR_CHECK(ndr_pull_align(ndr, 8));
10993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10994                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10995                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10996                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10997                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10998                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10999                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11000                 }
11001                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11002                 if (r->array) {
11003                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11004                 }
11005                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11006         }
11007         if (ndr_flags & NDR_BUFFERS) {
11008                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11009                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11010                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11011                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11012                 }
11013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11014         }
11015         return NDR_ERR_SUCCESS;
11016 }
11017
11018 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11019 {
11020         uint32_t cntr_array_0;
11021         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
11022         ndr->depth++;
11023         ndr_print_uint32(ndr, "count", r->count);
11024         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11025         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11026         ndr->depth++;
11027         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11028                 char *idx_0=NULL;
11029                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11030                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
11031                         free(idx_0);
11032                 }
11033         }
11034         ndr->depth--;
11035         ndr->depth--;
11036 }
11037
11038 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
11039 {
11040         uint32_t cntr_array_0;
11041         if (ndr_flags & NDR_SCALARS) {
11042                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11043                 NDR_CHECK(ndr_push_align(ndr, 8));
11044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11045                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11046                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11047                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11048                 }
11049                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11050         }
11051         if (ndr_flags & NDR_BUFFERS) {
11052         }
11053         return NDR_ERR_SUCCESS;
11054 }
11055
11056 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11057 {
11058         uint32_t cntr_array_0;
11059         TALLOC_CTX *_mem_save_array_0;
11060         if (ndr_flags & NDR_SCALARS) {
11061                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11062                 NDR_CHECK(ndr_pull_align(ndr, 8));
11063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11064                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11065                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11066                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11067                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11068                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11069                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11070                 }
11071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11072                 if (r->array) {
11073                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11074                 }
11075                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11076         }
11077         if (ndr_flags & NDR_BUFFERS) {
11078         }
11079         return NDR_ERR_SUCCESS;
11080 }
11081
11082 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11083 {
11084         uint32_t cntr_array_0;
11085         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11086         ndr->depth++;
11087         ndr_print_uint32(ndr, "count", r->count);
11088         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11089         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11090         ndr->depth++;
11091         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11092                 char *idx_0=NULL;
11093                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11094                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11095                         free(idx_0);
11096                 }
11097         }
11098         ndr->depth--;
11099         ndr->depth--;
11100 }
11101
11102 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11103 {
11104         if (ndr_flags & NDR_SCALARS) {
11105                 NDR_CHECK(ndr_push_align(ndr, 8));
11106                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11107                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11108                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11110                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11111         }
11112         if (ndr_flags & NDR_BUFFERS) {
11113                 if (r->source_dsa_obj_dn) {
11114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11115                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11116                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11117                         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));
11118                 }
11119         }
11120         return NDR_ERR_SUCCESS;
11121 }
11122
11123 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11124 {
11125         uint32_t _ptr_source_dsa_obj_dn;
11126         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11127         if (ndr_flags & NDR_SCALARS) {
11128                 NDR_CHECK(ndr_pull_align(ndr, 8));
11129                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11130                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11131                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11133                 if (_ptr_source_dsa_obj_dn) {
11134                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11135                 } else {
11136                         r->source_dsa_obj_dn = NULL;
11137                 }
11138                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11139         }
11140         if (ndr_flags & NDR_BUFFERS) {
11141                 if (r->source_dsa_obj_dn) {
11142                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11143                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11144                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11145                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11146                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11147                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_obj_dn), ndr_get_array_length(ndr, &r->source_dsa_obj_dn));
11148                         }
11149                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11150                         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));
11151                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11152                 }
11153         }
11154         return NDR_ERR_SUCCESS;
11155 }
11156
11157 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11158 {
11159         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11160         ndr->depth++;
11161         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11162         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11163         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11164         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11165         ndr->depth++;
11166         if (r->source_dsa_obj_dn) {
11167                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11168         }
11169         ndr->depth--;
11170         ndr->depth--;
11171 }
11172
11173 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11174 {
11175         uint32_t cntr_array_0;
11176         if (ndr_flags & NDR_SCALARS) {
11177                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11178                 NDR_CHECK(ndr_push_align(ndr, 8));
11179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11180                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11181                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11182                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11183                 }
11184                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11185         }
11186         if (ndr_flags & NDR_BUFFERS) {
11187                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11188                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11189                 }
11190         }
11191         return NDR_ERR_SUCCESS;
11192 }
11193
11194 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11195 {
11196         uint32_t cntr_array_0;
11197         TALLOC_CTX *_mem_save_array_0;
11198         if (ndr_flags & NDR_SCALARS) {
11199                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11200                 NDR_CHECK(ndr_pull_align(ndr, 8));
11201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11202                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11203                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11204                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11205                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11206                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11207                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11208                 }
11209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11210                 if (r->array) {
11211                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11212                 }
11213                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11214         }
11215         if (ndr_flags & NDR_BUFFERS) {
11216                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11217                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11218                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11219                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11220                 }
11221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11222         }
11223         return NDR_ERR_SUCCESS;
11224 }
11225
11226 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11227 {
11228         uint32_t cntr_array_0;
11229         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11230         ndr->depth++;
11231         ndr_print_uint32(ndr, "count", r->count);
11232         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11233         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11234         ndr->depth++;
11235         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11236                 char *idx_0=NULL;
11237                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11238                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11239                         free(idx_0);
11240                 }
11241         }
11242         ndr->depth--;
11243         ndr->depth--;
11244 }
11245
11246 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11247 {
11248         if (ndr_flags & NDR_SCALARS) {
11249                 NDR_CHECK(ndr_push_align(ndr, 8));
11250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11252                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11253                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11254                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11255                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11256                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11257                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11258         }
11259         if (ndr_flags & NDR_BUFFERS) {
11260                 if (r->attribute_name) {
11261                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11262                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11263                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11264                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11265                 }
11266                 if (r->originating_dsa_dn) {
11267                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11268                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11269                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11270                         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));
11271                 }
11272         }
11273         return NDR_ERR_SUCCESS;
11274 }
11275
11276 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11277 {
11278         uint32_t _ptr_attribute_name;
11279         TALLOC_CTX *_mem_save_attribute_name_0;
11280         uint32_t _ptr_originating_dsa_dn;
11281         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11282         if (ndr_flags & NDR_SCALARS) {
11283                 NDR_CHECK(ndr_pull_align(ndr, 8));
11284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11285                 if (_ptr_attribute_name) {
11286                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11287                 } else {
11288                         r->attribute_name = NULL;
11289                 }
11290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11291                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11292                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11293                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11294                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11296                 if (_ptr_originating_dsa_dn) {
11297                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11298                 } else {
11299                         r->originating_dsa_dn = NULL;
11300                 }
11301                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11302         }
11303         if (ndr_flags & NDR_BUFFERS) {
11304                 if (r->attribute_name) {
11305                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11306                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11307                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11308                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11309                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11310                                 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));
11311                         }
11312                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11313                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11314                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11315                 }
11316                 if (r->originating_dsa_dn) {
11317                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11318                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11319                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11320                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11321                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11322                                 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));
11323                         }
11324                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11325                         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));
11326                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11327                 }
11328         }
11329         return NDR_ERR_SUCCESS;
11330 }
11331
11332 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11333 {
11334         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11335         ndr->depth++;
11336         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11337         ndr->depth++;
11338         if (r->attribute_name) {
11339                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11340         }
11341         ndr->depth--;
11342         ndr_print_uint32(ndr, "version", r->version);
11343         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11344         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11345         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11346         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11347         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11348         ndr->depth++;
11349         if (r->originating_dsa_dn) {
11350                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11351         }
11352         ndr->depth--;
11353         ndr->depth--;
11354 }
11355
11356 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11357 {
11358         uint32_t cntr_array_0;
11359         if (ndr_flags & NDR_SCALARS) {
11360                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11361                 NDR_CHECK(ndr_push_align(ndr, 8));
11362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11363                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11364                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11365                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11366                 }
11367                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11368         }
11369         if (ndr_flags & NDR_BUFFERS) {
11370                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11371                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11372                 }
11373         }
11374         return NDR_ERR_SUCCESS;
11375 }
11376
11377 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11378 {
11379         uint32_t cntr_array_0;
11380         TALLOC_CTX *_mem_save_array_0;
11381         if (ndr_flags & NDR_SCALARS) {
11382                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11383                 NDR_CHECK(ndr_pull_align(ndr, 8));
11384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11385                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11386                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11387                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11388                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11389                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11390                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11391                 }
11392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11393                 if (r->array) {
11394                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11395                 }
11396                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11397         }
11398         if (ndr_flags & NDR_BUFFERS) {
11399                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11400                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11401                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11402                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11403                 }
11404                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11405         }
11406         return NDR_ERR_SUCCESS;
11407 }
11408
11409 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11410 {
11411         uint32_t cntr_array_0;
11412         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11413         ndr->depth++;
11414         ndr_print_uint32(ndr, "count", r->count);
11415         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11416         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11417         ndr->depth++;
11418         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11419                 char *idx_0=NULL;
11420                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11421                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11422                         free(idx_0);
11423                 }
11424         }
11425         ndr->depth--;
11426         ndr->depth--;
11427 }
11428
11429 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11430 {
11431         if (ndr_flags & NDR_SCALARS) {
11432                 NDR_CHECK(ndr_push_align(ndr, 8));
11433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11436                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11437                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11438                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11440                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11441                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11442                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11443                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11444                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11445                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11446         }
11447         if (ndr_flags & NDR_BUFFERS) {
11448                 if (r->attribute_name) {
11449                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11453                 }
11454                 if (r->object_dn) {
11455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11459                 }
11460                 if (r->binary) {
11461                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11462                 }
11463                 if (r->originating_dsa_dn) {
11464                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11465                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11467                         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));
11468                 }
11469         }
11470         return NDR_ERR_SUCCESS;
11471 }
11472
11473 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11474 {
11475         uint32_t _ptr_attribute_name;
11476         TALLOC_CTX *_mem_save_attribute_name_0;
11477         uint32_t _ptr_object_dn;
11478         TALLOC_CTX *_mem_save_object_dn_0;
11479         uint32_t _ptr_binary;
11480         TALLOC_CTX *_mem_save_binary_0;
11481         uint32_t _ptr_originating_dsa_dn;
11482         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11483         if (ndr_flags & NDR_SCALARS) {
11484                 NDR_CHECK(ndr_pull_align(ndr, 8));
11485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11486                 if (_ptr_attribute_name) {
11487                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11488                 } else {
11489                         r->attribute_name = NULL;
11490                 }
11491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11492                 if (_ptr_object_dn) {
11493                         NDR_PULL_ALLOC(ndr, r->object_dn);
11494                 } else {
11495                         r->object_dn = NULL;
11496                 }
11497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11499                 if (_ptr_binary) {
11500                         NDR_PULL_ALLOC(ndr, r->binary);
11501                 } else {
11502                         r->binary = NULL;
11503                 }
11504                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11505                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11507                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11508                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11509                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11510                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11511                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11512                 if (_ptr_originating_dsa_dn) {
11513                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11514                 } else {
11515                         r->originating_dsa_dn = NULL;
11516                 }
11517                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11518         }
11519         if (ndr_flags & NDR_BUFFERS) {
11520                 if (r->attribute_name) {
11521                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11522                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11523                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11524                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11525                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11526                                 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));
11527                         }
11528                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11529                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11531                 }
11532                 if (r->object_dn) {
11533                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11534                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11535                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11536                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11537                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11538                                 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));
11539                         }
11540                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11541                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11543                 }
11544                 if (r->binary) {
11545                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11546                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11547                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11549                 }
11550                 if (r->originating_dsa_dn) {
11551                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11552                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11553                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11554                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11555                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11556                                 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));
11557                         }
11558                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11559                         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));
11560                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11561                 }
11562         }
11563         return NDR_ERR_SUCCESS;
11564 }
11565
11566 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11567 {
11568         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11569         ndr->depth++;
11570         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11571         ndr->depth++;
11572         if (r->attribute_name) {
11573                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11574         }
11575         ndr->depth--;
11576         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11577         ndr->depth++;
11578         if (r->object_dn) {
11579                 ndr_print_string(ndr, "object_dn", r->object_dn);
11580         }
11581         ndr->depth--;
11582         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);
11583         ndr_print_ptr(ndr, "binary", r->binary);
11584         ndr->depth++;
11585         if (r->binary) {
11586                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11587         }
11588         ndr->depth--;
11589         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11590         ndr_print_NTTIME(ndr, "created", r->created);
11591         ndr_print_uint32(ndr, "version", r->version);
11592         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11593         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11594         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11595         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11596         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11597         ndr->depth++;
11598         if (r->originating_dsa_dn) {
11599                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11600         }
11601         ndr->depth--;
11602         ndr->depth--;
11603 }
11604
11605 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11606 {
11607         uint32_t cntr_array_0;
11608         if (ndr_flags & NDR_SCALARS) {
11609                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11610                 NDR_CHECK(ndr_push_align(ndr, 8));
11611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11612                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11613                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11614                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11615                 }
11616                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11617         }
11618         if (ndr_flags & NDR_BUFFERS) {
11619                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11620                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11621                 }
11622         }
11623         return NDR_ERR_SUCCESS;
11624 }
11625
11626 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11627 {
11628         uint32_t cntr_array_0;
11629         TALLOC_CTX *_mem_save_array_0;
11630         if (ndr_flags & NDR_SCALARS) {
11631                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11632                 NDR_CHECK(ndr_pull_align(ndr, 8));
11633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11634                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11635                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11636                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11637                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11638                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11639                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11640                 }
11641                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11642                 if (r->array) {
11643                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11644                 }
11645                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11646         }
11647         if (ndr_flags & NDR_BUFFERS) {
11648                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11649                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11650                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11651                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11652                 }
11653                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11654         }
11655         return NDR_ERR_SUCCESS;
11656 }
11657
11658 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11659 {
11660         uint32_t cntr_array_0;
11661         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11662         ndr->depth++;
11663         ndr_print_uint32(ndr, "count", r->count);
11664         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11665         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11666         ndr->depth++;
11667         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11668                 char *idx_0=NULL;
11669                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11670                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11671                         free(idx_0);
11672                 }
11673         }
11674         ndr->depth--;
11675         ndr->depth--;
11676 }
11677
11678 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11679 {
11680         if (ndr_flags & NDR_SCALARS) {
11681                 NDR_CHECK(ndr_push_align(ndr, 8));
11682                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11685                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11686                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11687                 {
11688                         uint32_t _flags_save_ipv4address = ndr->flags;
11689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11690                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11691                         ndr->flags = _flags_save_ipv4address;
11692                 }
11693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11694                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11695         }
11696         if (ndr_flags & NDR_BUFFERS) {
11697         }
11698         return NDR_ERR_SUCCESS;
11699 }
11700
11701 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11702 {
11703         if (ndr_flags & NDR_SCALARS) {
11704                 NDR_CHECK(ndr_pull_align(ndr, 8));
11705                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11708                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11709                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11710                 {
11711                         uint32_t _flags_save_ipv4address = ndr->flags;
11712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11713                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11714                         ndr->flags = _flags_save_ipv4address;
11715                 }
11716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11717                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11718         }
11719         if (ndr_flags & NDR_BUFFERS) {
11720         }
11721         return NDR_ERR_SUCCESS;
11722 }
11723
11724 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11725 {
11726         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11727         ndr->depth++;
11728         ndr_print_hyper(ndr, "u1", r->u1);
11729         ndr_print_uint32(ndr, "u2", r->u2);
11730         ndr_print_uint32(ndr, "u3", r->u3);
11731         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11732         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11733         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11734         ndr_print_uint32(ndr, "u5", r->u5);
11735         ndr->depth--;
11736 }
11737
11738 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11739 {
11740         uint32_t cntr_array_0;
11741         if (ndr_flags & NDR_SCALARS) {
11742                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11743                 NDR_CHECK(ndr_push_align(ndr, 8));
11744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11746                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11747                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11748                 }
11749                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11750         }
11751         if (ndr_flags & NDR_BUFFERS) {
11752         }
11753         return NDR_ERR_SUCCESS;
11754 }
11755
11756 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11757 {
11758         uint32_t cntr_array_0;
11759         TALLOC_CTX *_mem_save_array_0;
11760         if (ndr_flags & NDR_SCALARS) {
11761                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11762                 NDR_CHECK(ndr_pull_align(ndr, 8));
11763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11764                 if (r->count > 10000) {
11765                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11766                 }
11767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11768                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11769                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11770                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11771                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11772                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11773                 }
11774                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11775                 if (r->array) {
11776                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11777                 }
11778                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11779         }
11780         if (ndr_flags & NDR_BUFFERS) {
11781         }
11782         return NDR_ERR_SUCCESS;
11783 }
11784
11785 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11786 {
11787         uint32_t cntr_array_0;
11788         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11789         ndr->depth++;
11790         ndr_print_uint32(ndr, "count", r->count);
11791         ndr_print_uint32(ndr, "reserved", r->reserved);
11792         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11793         ndr->depth++;
11794         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11795                 char *idx_0=NULL;
11796                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11797                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11798                         free(idx_0);
11799                 }
11800         }
11801         ndr->depth--;
11802         ndr->depth--;
11803 }
11804
11805 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11806 {
11807         if (ndr_flags & NDR_SCALARS) {
11808                 NDR_CHECK(ndr_push_align(ndr, 8));
11809                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11815                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11817                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11818         }
11819         if (ndr_flags & NDR_BUFFERS) {
11820                 if (r->str1) {
11821                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11822                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11823                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11824                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11825                 }
11826         }
11827         return NDR_ERR_SUCCESS;
11828 }
11829
11830 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11831 {
11832         uint32_t _ptr_str1;
11833         TALLOC_CTX *_mem_save_str1_0;
11834         if (ndr_flags & NDR_SCALARS) {
11835                 NDR_CHECK(ndr_pull_align(ndr, 8));
11836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11837                 if (_ptr_str1) {
11838                         NDR_PULL_ALLOC(ndr, r->str1);
11839                 } else {
11840                         r->str1 = NULL;
11841                 }
11842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11847                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11849                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11850         }
11851         if (ndr_flags & NDR_BUFFERS) {
11852                 if (r->str1) {
11853                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11854                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11855                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11856                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11857                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11858                                 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));
11859                         }
11860                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11861                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11863                 }
11864         }
11865         return NDR_ERR_SUCCESS;
11866 }
11867
11868 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11869 {
11870         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11871         ndr->depth++;
11872         ndr_print_ptr(ndr, "str1", r->str1);
11873         ndr->depth++;
11874         if (r->str1) {
11875                 ndr_print_string(ndr, "str1", r->str1);
11876         }
11877         ndr->depth--;
11878         ndr_print_uint32(ndr, "u1", r->u1);
11879         ndr_print_uint32(ndr, "u2", r->u2);
11880         ndr_print_uint32(ndr, "u3", r->u3);
11881         ndr_print_uint32(ndr, "u4", r->u4);
11882         ndr_print_uint32(ndr, "u5", r->u5);
11883         ndr_print_hyper(ndr, "u6", r->u6);
11884         ndr_print_uint32(ndr, "u7", r->u7);
11885         ndr->depth--;
11886 }
11887
11888 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11889 {
11890         uint32_t cntr_array_0;
11891         if (ndr_flags & NDR_SCALARS) {
11892                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11893                 NDR_CHECK(ndr_push_align(ndr, 8));
11894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11896                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11897                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11898                 }
11899                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11900         }
11901         if (ndr_flags & NDR_BUFFERS) {
11902                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11903                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11904                 }
11905         }
11906         return NDR_ERR_SUCCESS;
11907 }
11908
11909 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11910 {
11911         uint32_t cntr_array_0;
11912         TALLOC_CTX *_mem_save_array_0;
11913         if (ndr_flags & NDR_SCALARS) {
11914                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11915                 NDR_CHECK(ndr_pull_align(ndr, 8));
11916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11917                 if (r->count > 256) {
11918                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11919                 }
11920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11921                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11922                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11923                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11924                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11925                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11926                 }
11927                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11928                 if (r->array) {
11929                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11930                 }
11931                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11932         }
11933         if (ndr_flags & NDR_BUFFERS) {
11934                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11935                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11936                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11937                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11938                 }
11939                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11940         }
11941         return NDR_ERR_SUCCESS;
11942 }
11943
11944 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11945 {
11946         uint32_t cntr_array_0;
11947         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11948         ndr->depth++;
11949         ndr_print_uint32(ndr, "count", r->count);
11950         ndr_print_uint32(ndr, "reserved", r->reserved);
11951         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11952         ndr->depth++;
11953         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11954                 char *idx_0=NULL;
11955                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11956                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11957                         free(idx_0);
11958                 }
11959         }
11960         ndr->depth--;
11961         ndr->depth--;
11962 }
11963
11964 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11965 {
11966         if (ndr_flags & NDR_SCALARS) {
11967                 int level = ndr_push_get_switch_value(ndr, r);
11968                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11969                 NDR_CHECK(ndr_push_union_align(ndr, 5));
11970                 switch (level) {
11971                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11972                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11973                         break; }
11974
11975                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11976                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11977                         break; }
11978
11979                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11980                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11981                         break; }
11982
11983                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11984                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11985                         break; }
11986
11987                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11988                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11989                         break; }
11990
11991                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11992                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11993                         break; }
11994
11995                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11996                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11997                         break; }
11998
11999                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12000                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
12001                         break; }
12002
12003                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12004                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
12005                         break; }
12006
12007                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12008                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
12009                         break; }
12010
12011                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12012                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
12013                         break; }
12014
12015                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12016                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
12017                         break; }
12018
12019                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12020                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
12021                         break; }
12022
12023                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12024                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
12025                         break; }
12026
12027                         case DRSUAPI_DS_REPLICA_INFO_06: {
12028                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
12029                         break; }
12030
12031                         default:
12032                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12033                 }
12034         }
12035         if (ndr_flags & NDR_BUFFERS) {
12036                 int level = ndr_push_get_switch_value(ndr, r);
12037                 switch (level) {
12038                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12039                                 if (r->neighbours) {
12040                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12041                                 }
12042                         break;
12043
12044                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12045                                 if (r->cursors) {
12046                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12047                                 }
12048                         break;
12049
12050                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12051                                 if (r->objmetadata) {
12052                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12053                                 }
12054                         break;
12055
12056                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12057                                 if (r->connectfailures) {
12058                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12059                                 }
12060                         break;
12061
12062                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12063                                 if (r->linkfailures) {
12064                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12065                                 }
12066                         break;
12067
12068                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12069                                 if (r->pendingops) {
12070                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12071                                 }
12072                         break;
12073
12074                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12075                                 if (r->attrvalmetadata) {
12076                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12077                                 }
12078                         break;
12079
12080                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12081                                 if (r->cursors2) {
12082                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12083                                 }
12084                         break;
12085
12086                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12087                                 if (r->cursors3) {
12088                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12089                                 }
12090                         break;
12091
12092                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12093                                 if (r->objmetadata2) {
12094                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12095                                 }
12096                         break;
12097
12098                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12099                                 if (r->attrvalmetadata2) {
12100                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12101                                 }
12102                         break;
12103
12104                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12105                                 if (r->neighbours02) {
12106                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12107                                 }
12108                         break;
12109
12110                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12111                                 if (r->connections04) {
12112                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12113                                 }
12114                         break;
12115
12116                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12117                                 if (r->cursors05) {
12118                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12119                                 }
12120                         break;
12121
12122                         case DRSUAPI_DS_REPLICA_INFO_06:
12123                                 if (r->i06) {
12124                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12125                                 }
12126                         break;
12127
12128                         default:
12129                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12130                 }
12131         }
12132         return NDR_ERR_SUCCESS;
12133 }
12134
12135 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12136 {
12137         int level;
12138         uint32_t _level;
12139         TALLOC_CTX *_mem_save_neighbours_0;
12140         TALLOC_CTX *_mem_save_cursors_0;
12141         TALLOC_CTX *_mem_save_objmetadata_0;
12142         TALLOC_CTX *_mem_save_connectfailures_0;
12143         TALLOC_CTX *_mem_save_linkfailures_0;
12144         TALLOC_CTX *_mem_save_pendingops_0;
12145         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12146         TALLOC_CTX *_mem_save_cursors2_0;
12147         TALLOC_CTX *_mem_save_cursors3_0;
12148         TALLOC_CTX *_mem_save_objmetadata2_0;
12149         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12150         TALLOC_CTX *_mem_save_neighbours02_0;
12151         TALLOC_CTX *_mem_save_connections04_0;
12152         TALLOC_CTX *_mem_save_cursors05_0;
12153         TALLOC_CTX *_mem_save_i06_0;
12154         level = ndr_pull_get_switch_value(ndr, r);
12155         if (ndr_flags & NDR_SCALARS) {
12156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12157                 if (_level != level) {
12158                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12159                 }
12160                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12161                 switch (level) {
12162                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12163                                 uint32_t _ptr_neighbours;
12164                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12165                                 if (_ptr_neighbours) {
12166                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12167                                 } else {
12168                                         r->neighbours = NULL;
12169                                 }
12170                         break; }
12171
12172                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12173                                 uint32_t _ptr_cursors;
12174                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12175                                 if (_ptr_cursors) {
12176                                         NDR_PULL_ALLOC(ndr, r->cursors);
12177                                 } else {
12178                                         r->cursors = NULL;
12179                                 }
12180                         break; }
12181
12182                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12183                                 uint32_t _ptr_objmetadata;
12184                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12185                                 if (_ptr_objmetadata) {
12186                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12187                                 } else {
12188                                         r->objmetadata = NULL;
12189                                 }
12190                         break; }
12191
12192                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12193                                 uint32_t _ptr_connectfailures;
12194                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12195                                 if (_ptr_connectfailures) {
12196                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12197                                 } else {
12198                                         r->connectfailures = NULL;
12199                                 }
12200                         break; }
12201
12202                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12203                                 uint32_t _ptr_linkfailures;
12204                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12205                                 if (_ptr_linkfailures) {
12206                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12207                                 } else {
12208                                         r->linkfailures = NULL;
12209                                 }
12210                         break; }
12211
12212                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12213                                 uint32_t _ptr_pendingops;
12214                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12215                                 if (_ptr_pendingops) {
12216                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12217                                 } else {
12218                                         r->pendingops = NULL;
12219                                 }
12220                         break; }
12221
12222                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12223                                 uint32_t _ptr_attrvalmetadata;
12224                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12225                                 if (_ptr_attrvalmetadata) {
12226                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12227                                 } else {
12228                                         r->attrvalmetadata = NULL;
12229                                 }
12230                         break; }
12231
12232                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12233                                 uint32_t _ptr_cursors2;
12234                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12235                                 if (_ptr_cursors2) {
12236                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12237                                 } else {
12238                                         r->cursors2 = NULL;
12239                                 }
12240                         break; }
12241
12242                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12243                                 uint32_t _ptr_cursors3;
12244                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12245                                 if (_ptr_cursors3) {
12246                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12247                                 } else {
12248                                         r->cursors3 = NULL;
12249                                 }
12250                         break; }
12251
12252                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12253                                 uint32_t _ptr_objmetadata2;
12254                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12255                                 if (_ptr_objmetadata2) {
12256                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12257                                 } else {
12258                                         r->objmetadata2 = NULL;
12259                                 }
12260                         break; }
12261
12262                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12263                                 uint32_t _ptr_attrvalmetadata2;
12264                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12265                                 if (_ptr_attrvalmetadata2) {
12266                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12267                                 } else {
12268                                         r->attrvalmetadata2 = NULL;
12269                                 }
12270                         break; }
12271
12272                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12273                                 uint32_t _ptr_neighbours02;
12274                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12275                                 if (_ptr_neighbours02) {
12276                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
12277                                 } else {
12278                                         r->neighbours02 = NULL;
12279                                 }
12280                         break; }
12281
12282                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12283                                 uint32_t _ptr_connections04;
12284                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12285                                 if (_ptr_connections04) {
12286                                         NDR_PULL_ALLOC(ndr, r->connections04);
12287                                 } else {
12288                                         r->connections04 = NULL;
12289                                 }
12290                         break; }
12291
12292                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12293                                 uint32_t _ptr_cursors05;
12294                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12295                                 if (_ptr_cursors05) {
12296                                         NDR_PULL_ALLOC(ndr, r->cursors05);
12297                                 } else {
12298                                         r->cursors05 = NULL;
12299                                 }
12300                         break; }
12301
12302                         case DRSUAPI_DS_REPLICA_INFO_06: {
12303                                 uint32_t _ptr_i06;
12304                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12305                                 if (_ptr_i06) {
12306                                         NDR_PULL_ALLOC(ndr, r->i06);
12307                                 } else {
12308                                         r->i06 = NULL;
12309                                 }
12310                         break; }
12311
12312                         default:
12313                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12314                 }
12315         }
12316         if (ndr_flags & NDR_BUFFERS) {
12317                 switch (level) {
12318                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12319                                 if (r->neighbours) {
12320                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12321                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12322                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12323                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12324                                 }
12325                         break;
12326
12327                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12328                                 if (r->cursors) {
12329                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12330                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12331                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12332                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12333                                 }
12334                         break;
12335
12336                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12337                                 if (r->objmetadata) {
12338                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12339                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12340                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12341                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12342                                 }
12343                         break;
12344
12345                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12346                                 if (r->connectfailures) {
12347                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12348                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12349                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12350                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12351                                 }
12352                         break;
12353
12354                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12355                                 if (r->linkfailures) {
12356                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12357                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12358                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12359                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12360                                 }
12361                         break;
12362
12363                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12364                                 if (r->pendingops) {
12365                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12366                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12367                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12368                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12369                                 }
12370                         break;
12371
12372                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12373                                 if (r->attrvalmetadata) {
12374                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12375                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12376                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12377                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12378                                 }
12379                         break;
12380
12381                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12382                                 if (r->cursors2) {
12383                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12384                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12385                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12386                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12387                                 }
12388                         break;
12389
12390                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12391                                 if (r->cursors3) {
12392                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12393                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12394                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12395                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12396                                 }
12397                         break;
12398
12399                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12400                                 if (r->objmetadata2) {
12401                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12402                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12403                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12404                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12405                                 }
12406                         break;
12407
12408                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12409                                 if (r->attrvalmetadata2) {
12410                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12411                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12412                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12413                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12414                                 }
12415                         break;
12416
12417                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12418                                 if (r->neighbours02) {
12419                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12420                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12421                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12422                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12423                                 }
12424                         break;
12425
12426                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12427                                 if (r->connections04) {
12428                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12429                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12430                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12431                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12432                                 }
12433                         break;
12434
12435                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12436                                 if (r->cursors05) {
12437                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12438                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12439                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12440                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12441                                 }
12442                         break;
12443
12444                         case DRSUAPI_DS_REPLICA_INFO_06:
12445                                 if (r->i06) {
12446                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12447                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12448                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12449                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12450                                 }
12451                         break;
12452
12453                         default:
12454                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12455                 }
12456         }
12457         return NDR_ERR_SUCCESS;
12458 }
12459
12460 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12461 {
12462         int level;
12463         level = ndr_print_get_switch_value(ndr, r);
12464         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12465         switch (level) {
12466                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12467                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12468                         ndr->depth++;
12469                         if (r->neighbours) {
12470                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12471                         }
12472                         ndr->depth--;
12473                 break;
12474
12475                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12476                         ndr_print_ptr(ndr, "cursors", r->cursors);
12477                         ndr->depth++;
12478                         if (r->cursors) {
12479                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12480                         }
12481                         ndr->depth--;
12482                 break;
12483
12484                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12485                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12486                         ndr->depth++;
12487                         if (r->objmetadata) {
12488                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12489                         }
12490                         ndr->depth--;
12491                 break;
12492
12493                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12494                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12495                         ndr->depth++;
12496                         if (r->connectfailures) {
12497                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12498                         }
12499                         ndr->depth--;
12500                 break;
12501
12502                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12503                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12504                         ndr->depth++;
12505                         if (r->linkfailures) {
12506                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12507                         }
12508                         ndr->depth--;
12509                 break;
12510
12511                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12512                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12513                         ndr->depth++;
12514                         if (r->pendingops) {
12515                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12516                         }
12517                         ndr->depth--;
12518                 break;
12519
12520                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12521                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12522                         ndr->depth++;
12523                         if (r->attrvalmetadata) {
12524                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12525                         }
12526                         ndr->depth--;
12527                 break;
12528
12529                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12530                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12531                         ndr->depth++;
12532                         if (r->cursors2) {
12533                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12534                         }
12535                         ndr->depth--;
12536                 break;
12537
12538                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12539                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12540                         ndr->depth++;
12541                         if (r->cursors3) {
12542                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12543                         }
12544                         ndr->depth--;
12545                 break;
12546
12547                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12548                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12549                         ndr->depth++;
12550                         if (r->objmetadata2) {
12551                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12552                         }
12553                         ndr->depth--;
12554                 break;
12555
12556                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12557                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12558                         ndr->depth++;
12559                         if (r->attrvalmetadata2) {
12560                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12561                         }
12562                         ndr->depth--;
12563                 break;
12564
12565                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12566                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12567                         ndr->depth++;
12568                         if (r->neighbours02) {
12569                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12570                         }
12571                         ndr->depth--;
12572                 break;
12573
12574                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12575                         ndr_print_ptr(ndr, "connections04", r->connections04);
12576                         ndr->depth++;
12577                         if (r->connections04) {
12578                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12579                         }
12580                         ndr->depth--;
12581                 break;
12582
12583                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12584                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12585                         ndr->depth++;
12586                         if (r->cursors05) {
12587                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12588                         }
12589                         ndr->depth--;
12590                 break;
12591
12592                 case DRSUAPI_DS_REPLICA_INFO_06:
12593                         ndr_print_ptr(ndr, "i06", r->i06);
12594                         ndr->depth++;
12595                         if (r->i06) {
12596                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12597                         }
12598                         ndr->depth--;
12599                 break;
12600
12601                 default:
12602                         ndr_print_bad_level(ndr, name, level);
12603         }
12604 }
12605
12606 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12607 {
12608         if (ndr_flags & NDR_SCALARS) {
12609                 int level = ndr_push_get_switch_value(ndr, r);
12610                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12611                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12612                 switch (level) {
12613                         case 1: {
12614                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12615                         break; }
12616
12617                         default:
12618                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12619                 }
12620         }
12621         if (ndr_flags & NDR_BUFFERS) {
12622                 int level = ndr_push_get_switch_value(ndr, r);
12623                 switch (level) {
12624                         case 1:
12625                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12626                         break;
12627
12628                         default:
12629                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12630                 }
12631         }
12632         return NDR_ERR_SUCCESS;
12633 }
12634
12635 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12636 {
12637         int level;
12638         int32_t _level;
12639         level = ndr_pull_get_switch_value(ndr, r);
12640         if (ndr_flags & NDR_SCALARS) {
12641                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12642                 if (_level != level) {
12643                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12644                 }
12645                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12646                 switch (level) {
12647                         case 1: {
12648                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12649                         break; }
12650
12651                         default:
12652                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12653                 }
12654         }
12655         if (ndr_flags & NDR_BUFFERS) {
12656                 switch (level) {
12657                         case 1:
12658                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12659                         break;
12660
12661                         default:
12662                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12663                 }
12664         }
12665         return NDR_ERR_SUCCESS;
12666 }
12667
12668 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12669 {
12670         int level;
12671         level = ndr_print_get_switch_value(ndr, r);
12672         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12673         switch (level) {
12674                 case 1:
12675                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12676                 break;
12677
12678                 default:
12679                         ndr_print_bad_level(ndr, name, level);
12680         }
12681 }
12682
12683 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12684 {
12685         uint32_t cntr_req_array_1;
12686         if (ndr_flags & NDR_SCALARS) {
12687                 NDR_CHECK(ndr_push_align(ndr, 5));
12688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12690                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12691         }
12692         if (ndr_flags & NDR_BUFFERS) {
12693                 if (r->req_array) {
12694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12695                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12696                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12697                         }
12698                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12699                                 if (r->req_array[cntr_req_array_1]) {
12700                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12701                                 }
12702                         }
12703                 }
12704         }
12705         return NDR_ERR_SUCCESS;
12706 }
12707
12708 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12709 {
12710         uint32_t _ptr_req_array;
12711         uint32_t cntr_req_array_1;
12712         TALLOC_CTX *_mem_save_req_array_0;
12713         TALLOC_CTX *_mem_save_req_array_1;
12714         TALLOC_CTX *_mem_save_req_array_2;
12715         if (ndr_flags & NDR_SCALARS) {
12716                 NDR_CHECK(ndr_pull_align(ndr, 5));
12717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12718                 if (r->num_req < 1 || r->num_req > 10000) {
12719                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12720                 }
12721                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12722                 if (_ptr_req_array) {
12723                         NDR_PULL_ALLOC(ndr, r->req_array);
12724                 } else {
12725                         r->req_array = NULL;
12726                 }
12727                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12728         }
12729         if (ndr_flags & NDR_BUFFERS) {
12730                 if (r->req_array) {
12731                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12732                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12733                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12734                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12735                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12736                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12737                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12738                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12739                                 if (_ptr_req_array) {
12740                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12741                                 } else {
12742                                         r->req_array[cntr_req_array_1] = NULL;
12743                                 }
12744                         }
12745                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12746                                 if (r->req_array[cntr_req_array_1]) {
12747                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12748                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12749                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12750                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12751                                 }
12752                         }
12753                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12754                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12755                 }
12756                 if (r->req_array) {
12757                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12758                 }
12759         }
12760         return NDR_ERR_SUCCESS;
12761 }
12762
12763 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12764 {
12765         uint32_t cntr_req_array_1;
12766         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12767         ndr->depth++;
12768         ndr_print_uint32(ndr, "num_req", r->num_req);
12769         ndr_print_ptr(ndr, "req_array", r->req_array);
12770         ndr->depth++;
12771         if (r->req_array) {
12772                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12773                 ndr->depth++;
12774                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12775                         char *idx_1=NULL;
12776                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12777                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12778                                 ndr->depth++;
12779                                 if (r->req_array[cntr_req_array_1]) {
12780                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12781                                 }
12782                                 ndr->depth--;
12783                                 free(idx_1);
12784                         }
12785                 }
12786                 ndr->depth--;
12787         }
12788         ndr->depth--;
12789         ndr->depth--;
12790 }
12791
12792 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12793 {
12794         if (ndr_flags & NDR_SCALARS) {
12795                 int level = ndr_push_get_switch_value(ndr, r);
12796                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12797                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12798                 switch (level) {
12799                         case 1: {
12800                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12801                         break; }
12802
12803                         default:
12804                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12805                 }
12806         }
12807         if (ndr_flags & NDR_BUFFERS) {
12808                 int level = ndr_push_get_switch_value(ndr, r);
12809                 switch (level) {
12810                         case 1:
12811                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12812                         break;
12813
12814                         default:
12815                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12816                 }
12817         }
12818         return NDR_ERR_SUCCESS;
12819 }
12820
12821 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12822 {
12823         int level;
12824         int32_t _level;
12825         level = ndr_pull_get_switch_value(ndr, r);
12826         if (ndr_flags & NDR_SCALARS) {
12827                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12828                 if (_level != level) {
12829                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12830                 }
12831                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12832                 switch (level) {
12833                         case 1: {
12834                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12835                         break; }
12836
12837                         default:
12838                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12839                 }
12840         }
12841         if (ndr_flags & NDR_BUFFERS) {
12842                 switch (level) {
12843                         case 1:
12844                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12845                         break;
12846
12847                         default:
12848                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12849                 }
12850         }
12851         return NDR_ERR_SUCCESS;
12852 }
12853
12854 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12855 {
12856         int level;
12857         level = ndr_print_get_switch_value(ndr, r);
12858         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12859         switch (level) {
12860                 case 1:
12861                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12862                 break;
12863
12864                 default:
12865                         ndr_print_bad_level(ndr, name, level);
12866         }
12867 }
12868
12869 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12870 {
12871         if (ndr_flags & NDR_SCALARS) {
12872                 NDR_CHECK(ndr_push_align(ndr, 4));
12873                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12875                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
12876         }
12877         if (ndr_flags & NDR_BUFFERS) {
12878         }
12879         return NDR_ERR_SUCCESS;
12880 }
12881
12882 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12883 {
12884         if (ndr_flags & NDR_SCALARS) {
12885                 NDR_CHECK(ndr_pull_align(ndr, 4));
12886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12888                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
12889         }
12890         if (ndr_flags & NDR_BUFFERS) {
12891         }
12892         return NDR_ERR_SUCCESS;
12893 }
12894
12895 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12896 {
12897         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12898         ndr->depth++;
12899         ndr_print_WERROR(ndr, "error_code", r->error_code);
12900         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12901         ndr->depth--;
12902 }
12903
12904 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12905 {
12906         uint32_t cntr_info_1;
12907         if (ndr_flags & NDR_SCALARS) {
12908                 NDR_CHECK(ndr_push_align(ndr, 5));
12909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12910                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12912                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12913         }
12914         if (ndr_flags & NDR_BUFFERS) {
12915                 if (r->info) {
12916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
12917                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12918                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12919                         }
12920                 }
12921         }
12922         return NDR_ERR_SUCCESS;
12923 }
12924
12925 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12926 {
12927         uint32_t _ptr_info;
12928         uint32_t cntr_info_1;
12929         TALLOC_CTX *_mem_save_info_0;
12930         TALLOC_CTX *_mem_save_info_1;
12931         if (ndr_flags & NDR_SCALARS) {
12932                 NDR_CHECK(ndr_pull_align(ndr, 5));
12933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12934                 if (r->num_info > 10000) {
12935                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12936                 }
12937                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12938                 if (_ptr_info) {
12939                         NDR_PULL_ALLOC(ndr, r->info);
12940                 } else {
12941                         r->info = NULL;
12942                 }
12943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12944                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12945         }
12946         if (ndr_flags & NDR_BUFFERS) {
12947                 if (r->info) {
12948                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12949                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12951                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12952                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12953                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12954                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12955                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12956                         }
12957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12959                 }
12960                 if (r->info) {
12961                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12962                 }
12963         }
12964         return NDR_ERR_SUCCESS;
12965 }
12966
12967 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12968 {
12969         uint32_t cntr_info_1;
12970         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12971         ndr->depth++;
12972         ndr_print_uint32(ndr, "num_info", r->num_info);
12973         ndr_print_ptr(ndr, "info", r->info);
12974         ndr->depth++;
12975         if (r->info) {
12976                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12977                 ndr->depth++;
12978                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12979                         char *idx_1=NULL;
12980                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12981                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12982                                 free(idx_1);
12983                         }
12984                 }
12985                 ndr->depth--;
12986         }
12987         ndr->depth--;
12988         ndr_print_uint32(ndr, "unknown", r->unknown);
12989         ndr->depth--;
12990 }
12991
12992 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12993 {
12994         if (ndr_flags & NDR_SCALARS) {
12995                 int level = ndr_push_get_switch_value(ndr, r);
12996                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12997                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12998                 switch (level) {
12999                         case 1: {
13000                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13001                         break; }
13002
13003                         default:
13004                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13005                 }
13006         }
13007         if (ndr_flags & NDR_BUFFERS) {
13008                 int level = ndr_push_get_switch_value(ndr, r);
13009                 switch (level) {
13010                         case 1:
13011                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13012                         break;
13013
13014                         default:
13015                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13016                 }
13017         }
13018         return NDR_ERR_SUCCESS;
13019 }
13020
13021 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
13022 {
13023         int level;
13024         int32_t _level;
13025         level = ndr_pull_get_switch_value(ndr, r);
13026         if (ndr_flags & NDR_SCALARS) {
13027                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13028                 if (_level != level) {
13029                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13030                 }
13031                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13032                 switch (level) {
13033                         case 1: {
13034                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13035                         break; }
13036
13037                         default:
13038                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13039                 }
13040         }
13041         if (ndr_flags & NDR_BUFFERS) {
13042                 switch (level) {
13043                         case 1:
13044                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13045                         break;
13046
13047                         default:
13048                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13049                 }
13050         }
13051         return NDR_ERR_SUCCESS;
13052 }
13053
13054 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
13055 {
13056         int level;
13057         level = ndr_print_get_switch_value(ndr, r);
13058         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
13059         switch (level) {
13060                 case 1:
13061                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13062                 break;
13063
13064                 default:
13065                         ndr_print_bad_level(ndr, name, level);
13066         }
13067 }
13068
13069 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13070 {
13071         uint32_t cntr_site_to_1;
13072         if (ndr_flags & NDR_SCALARS) {
13073                 NDR_CHECK(ndr_push_align(ndr, 5));
13074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13078                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13079         }
13080         if (ndr_flags & NDR_BUFFERS) {
13081                 if (r->site_from) {
13082                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13083                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13084                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13085                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13086                 }
13087                 if (r->site_to) {
13088                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13089                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13090                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13091                         }
13092                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13093                                 if (r->site_to[cntr_site_to_1]) {
13094                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13095                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13096                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13097                                         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));
13098                                 }
13099                         }
13100                 }
13101         }
13102         return NDR_ERR_SUCCESS;
13103 }
13104
13105 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13106 {
13107         uint32_t _ptr_site_from;
13108         TALLOC_CTX *_mem_save_site_from_0;
13109         uint32_t _ptr_site_to;
13110         uint32_t cntr_site_to_1;
13111         TALLOC_CTX *_mem_save_site_to_0;
13112         TALLOC_CTX *_mem_save_site_to_1;
13113         TALLOC_CTX *_mem_save_site_to_2;
13114         if (ndr_flags & NDR_SCALARS) {
13115                 NDR_CHECK(ndr_pull_align(ndr, 5));
13116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13117                 if (_ptr_site_from) {
13118                         NDR_PULL_ALLOC(ndr, r->site_from);
13119                 } else {
13120                         r->site_from = NULL;
13121                 }
13122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13123                 if (r->num_req < 1 || r->num_req > 10000) {
13124                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13125                 }
13126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13127                 if (_ptr_site_to) {
13128                         NDR_PULL_ALLOC(ndr, r->site_to);
13129                 } else {
13130                         r->site_to = NULL;
13131                 }
13132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13133                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13134         }
13135         if (ndr_flags & NDR_BUFFERS) {
13136                 if (r->site_from) {
13137                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13138                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13140                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13141                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13142                                 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));
13143                         }
13144                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13145                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13147                 }
13148                 if (r->site_to) {
13149                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13150                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13151                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13152                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13153                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13154                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13155                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13156                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13157                                 if (_ptr_site_to) {
13158                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13159                                 } else {
13160                                         r->site_to[cntr_site_to_1] = NULL;
13161                                 }
13162                         }
13163                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13164                                 if (r->site_to[cntr_site_to_1]) {
13165                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13166                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13167                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13168                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13169                                         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])) {
13170                                                 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]));
13171                                         }
13172                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13173                                         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));
13174                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13175                                 }
13176                         }
13177                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13179                 }
13180                 if (r->site_to) {
13181                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13182                 }
13183         }
13184         return NDR_ERR_SUCCESS;
13185 }
13186
13187 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13188 {
13189         uint32_t cntr_site_to_1;
13190         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13191         ndr->depth++;
13192         ndr_print_ptr(ndr, "site_from", r->site_from);
13193         ndr->depth++;
13194         if (r->site_from) {
13195                 ndr_print_string(ndr, "site_from", r->site_from);
13196         }
13197         ndr->depth--;
13198         ndr_print_uint32(ndr, "num_req", r->num_req);
13199         ndr_print_ptr(ndr, "site_to", r->site_to);
13200         ndr->depth++;
13201         if (r->site_to) {
13202                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13203                 ndr->depth++;
13204                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13205                         char *idx_1=NULL;
13206                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13207                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13208                                 ndr->depth++;
13209                                 if (r->site_to[cntr_site_to_1]) {
13210                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13211                                 }
13212                                 ndr->depth--;
13213                                 free(idx_1);
13214                         }
13215                 }
13216                 ndr->depth--;
13217         }
13218         ndr->depth--;
13219         ndr_print_uint32(ndr, "flags", r->flags);
13220         ndr->depth--;
13221 }
13222
13223 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13224 {
13225         if (ndr_flags & NDR_SCALARS) {
13226                 int level = ndr_push_get_switch_value(ndr, r);
13227                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13228                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13229                 switch (level) {
13230                         case 1: {
13231                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13232                         break; }
13233
13234                         default:
13235                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13236                 }
13237         }
13238         if (ndr_flags & NDR_BUFFERS) {
13239                 int level = ndr_push_get_switch_value(ndr, r);
13240                 switch (level) {
13241                         case 1:
13242                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13243                         break;
13244
13245                         default:
13246                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13247                 }
13248         }
13249         return NDR_ERR_SUCCESS;
13250 }
13251
13252 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13253 {
13254         int level;
13255         int32_t _level;
13256         level = ndr_pull_get_switch_value(ndr, r);
13257         if (ndr_flags & NDR_SCALARS) {
13258                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13259                 if (_level != level) {
13260                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13261                 }
13262                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13263                 switch (level) {
13264                         case 1: {
13265                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13266                         break; }
13267
13268                         default:
13269                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13270                 }
13271         }
13272         if (ndr_flags & NDR_BUFFERS) {
13273                 switch (level) {
13274                         case 1:
13275                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13276                         break;
13277
13278                         default:
13279                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13280                 }
13281         }
13282         return NDR_ERR_SUCCESS;
13283 }
13284
13285 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13286 {
13287         int level;
13288         level = ndr_print_get_switch_value(ndr, r);
13289         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13290         switch (level) {
13291                 case 1:
13292                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13293                 break;
13294
13295                 default:
13296                         ndr_print_bad_level(ndr, name, level);
13297         }
13298 }
13299
13300 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13301 {
13302         if (flags & NDR_IN) {
13303                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13304                 if (r->in.bind_guid) {
13305                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13306                 }
13307                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13308                 if (r->in.bind_info) {
13309                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13310                 }
13311         }
13312         if (flags & NDR_OUT) {
13313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13314                 if (r->out.bind_info) {
13315                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13316                 }
13317                 if (r->out.bind_handle == NULL) {
13318                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13319                 }
13320                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13321                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13322         }
13323         return NDR_ERR_SUCCESS;
13324 }
13325
13326 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13327 {
13328         uint32_t _ptr_bind_guid;
13329         uint32_t _ptr_bind_info;
13330         TALLOC_CTX *_mem_save_bind_guid_0;
13331         TALLOC_CTX *_mem_save_bind_info_0;
13332         TALLOC_CTX *_mem_save_bind_handle_0;
13333         if (flags & NDR_IN) {
13334                 ZERO_STRUCT(r->out);
13335
13336                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13337                 if (_ptr_bind_guid) {
13338                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13339                 } else {
13340                         r->in.bind_guid = NULL;
13341                 }
13342                 if (r->in.bind_guid) {
13343                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13344                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13345                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13347                 }
13348                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13349                 if (_ptr_bind_info) {
13350                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13351                 } else {
13352                         r->in.bind_info = NULL;
13353                 }
13354                 if (r->in.bind_info) {
13355                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13356                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13357                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13359                 }
13360                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13361                 ZERO_STRUCTP(r->out.bind_handle);
13362         }
13363         if (flags & NDR_OUT) {
13364                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13365                 if (_ptr_bind_info) {
13366                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13367                 } else {
13368                         r->out.bind_info = NULL;
13369                 }
13370                 if (r->out.bind_info) {
13371                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13372                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13373                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13374                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13375                 }
13376                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13377                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13378                 }
13379                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13380                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13381                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13383                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13384         }
13385         return NDR_ERR_SUCCESS;
13386 }
13387
13388 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13389 {
13390         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13391         ndr->depth++;
13392         if (flags & NDR_SET_VALUES) {
13393                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13394         }
13395         if (flags & NDR_IN) {
13396                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13397                 ndr->depth++;
13398                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13399                 ndr->depth++;
13400                 if (r->in.bind_guid) {
13401                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13402                 }
13403                 ndr->depth--;
13404                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13405                 ndr->depth++;
13406                 if (r->in.bind_info) {
13407                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13408                 }
13409                 ndr->depth--;
13410                 ndr->depth--;
13411         }
13412         if (flags & NDR_OUT) {
13413                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13414                 ndr->depth++;
13415                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13416                 ndr->depth++;
13417                 if (r->out.bind_info) {
13418                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13419                 }
13420                 ndr->depth--;
13421                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13422                 ndr->depth++;
13423                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13424                 ndr->depth--;
13425                 ndr_print_WERROR(ndr, "result", r->out.result);
13426                 ndr->depth--;
13427         }
13428         ndr->depth--;
13429 }
13430
13431 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13432 {
13433         if (flags & NDR_IN) {
13434                 if (r->in.bind_handle == NULL) {
13435                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13436                 }
13437                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13438         }
13439         if (flags & NDR_OUT) {
13440                 if (r->out.bind_handle == NULL) {
13441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13442                 }
13443                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13444                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13445         }
13446         return NDR_ERR_SUCCESS;
13447 }
13448
13449 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13450 {
13451         TALLOC_CTX *_mem_save_bind_handle_0;
13452         if (flags & NDR_IN) {
13453                 ZERO_STRUCT(r->out);
13454
13455                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13456                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13457                 }
13458                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13459                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13460                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13461                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13462                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13463                 *r->out.bind_handle = *r->in.bind_handle;
13464         }
13465         if (flags & NDR_OUT) {
13466                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13467                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13468                 }
13469                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13470                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13471                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13472                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13473                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13474         }
13475         return NDR_ERR_SUCCESS;
13476 }
13477
13478 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13479 {
13480         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13481         ndr->depth++;
13482         if (flags & NDR_SET_VALUES) {
13483                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13484         }
13485         if (flags & NDR_IN) {
13486                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13487                 ndr->depth++;
13488                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13489                 ndr->depth++;
13490                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13491                 ndr->depth--;
13492                 ndr->depth--;
13493         }
13494         if (flags & NDR_OUT) {
13495                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13496                 ndr->depth++;
13497                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13498                 ndr->depth++;
13499                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13500                 ndr->depth--;
13501                 ndr_print_WERROR(ndr, "result", r->out.result);
13502                 ndr->depth--;
13503         }
13504         ndr->depth--;
13505 }
13506
13507 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13508 {
13509         if (flags & NDR_IN) {
13510                 if (r->in.bind_handle == NULL) {
13511                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13512                 }
13513                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13514                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13515                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13516                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13517         }
13518         if (flags & NDR_OUT) {
13519                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13520         }
13521         return NDR_ERR_SUCCESS;
13522 }
13523
13524 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13525 {
13526         TALLOC_CTX *_mem_save_bind_handle_0;
13527         if (flags & NDR_IN) {
13528                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13529                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13530                 }
13531                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13532                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13533                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13534                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13535                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13536                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13537                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13538         }
13539         if (flags & NDR_OUT) {
13540                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13541         }
13542         return NDR_ERR_SUCCESS;
13543 }
13544
13545 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13546 {
13547         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13548         ndr->depth++;
13549         if (flags & NDR_SET_VALUES) {
13550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13551         }
13552         if (flags & NDR_IN) {
13553                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13554                 ndr->depth++;
13555                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13556                 ndr->depth++;
13557                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13558                 ndr->depth--;
13559                 ndr_print_int32(ndr, "level", r->in.level);
13560                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13561                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13562                 ndr->depth--;
13563         }
13564         if (flags & NDR_OUT) {
13565                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13566                 ndr->depth++;
13567                 ndr_print_WERROR(ndr, "result", r->out.result);
13568                 ndr->depth--;
13569         }
13570         ndr->depth--;
13571 }
13572
13573 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13574 {
13575         if (flags & NDR_IN) {
13576                 if (r->in.bind_handle == NULL) {
13577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13578                 }
13579                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13580                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13581                 if (r->in.req == NULL) {
13582                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13583                 }
13584                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13585                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13586         }
13587         if (flags & NDR_OUT) {
13588                 if (r->out.level_out == NULL) {
13589                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13590                 }
13591                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13592                 if (r->out.ctr == NULL) {
13593                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13594                 }
13595                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13596                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13597                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13598         }
13599         return NDR_ERR_SUCCESS;
13600 }
13601
13602 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13603 {
13604         TALLOC_CTX *_mem_save_bind_handle_0;
13605         TALLOC_CTX *_mem_save_req_0;
13606         TALLOC_CTX *_mem_save_level_out_0;
13607         TALLOC_CTX *_mem_save_ctr_0;
13608         if (flags & NDR_IN) {
13609                 ZERO_STRUCT(r->out);
13610
13611                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13612                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13613                 }
13614                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13615                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13616                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13617                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13618                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13619                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13620                         NDR_PULL_ALLOC(ndr, r->in.req);
13621                 }
13622                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13623                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13624                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13625                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13626                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13627                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13628                 ZERO_STRUCTP(r->out.level_out);
13629                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13630                 ZERO_STRUCTP(r->out.ctr);
13631         }
13632         if (flags & NDR_OUT) {
13633                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13634                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13635                 }
13636                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13637                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13638                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13639                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13640                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13641                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13642                 }
13643                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13644                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13645                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13646                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13647                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13648                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13649         }
13650         return NDR_ERR_SUCCESS;
13651 }
13652
13653 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13654 {
13655         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13656         ndr->depth++;
13657         if (flags & NDR_SET_VALUES) {
13658                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13659         }
13660         if (flags & NDR_IN) {
13661                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13662                 ndr->depth++;
13663                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13664                 ndr->depth++;
13665                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13666                 ndr->depth--;
13667                 ndr_print_int32(ndr, "level", r->in.level);
13668                 ndr_print_ptr(ndr, "req", r->in.req);
13669                 ndr->depth++;
13670                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13671                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13672                 ndr->depth--;
13673                 ndr->depth--;
13674         }
13675         if (flags & NDR_OUT) {
13676                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13677                 ndr->depth++;
13678                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13679                 ndr->depth++;
13680                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13681                 ndr->depth--;
13682                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13683                 ndr->depth++;
13684                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13685                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13686                 ndr->depth--;
13687                 ndr_print_WERROR(ndr, "result", r->out.result);
13688                 ndr->depth--;
13689         }
13690         ndr->depth--;
13691 }
13692
13693 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13694 {
13695         if (flags & NDR_IN) {
13696                 if (r->in.bind_handle == NULL) {
13697                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13698                 }
13699                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13700                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13701                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13702                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13703         }
13704         if (flags & NDR_OUT) {
13705                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13706         }
13707         return NDR_ERR_SUCCESS;
13708 }
13709
13710 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13711 {
13712         TALLOC_CTX *_mem_save_bind_handle_0;
13713         if (flags & NDR_IN) {
13714                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13715                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13716                 }
13717                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13718                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13719                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13720                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13721                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13722                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13723                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13724         }
13725         if (flags & NDR_OUT) {
13726                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13727         }
13728         return NDR_ERR_SUCCESS;
13729 }
13730
13731 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13732 {
13733         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13734         ndr->depth++;
13735         if (flags & NDR_SET_VALUES) {
13736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13737         }
13738         if (flags & NDR_IN) {
13739                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13740                 ndr->depth++;
13741                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13742                 ndr->depth++;
13743                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13744                 ndr->depth--;
13745                 ndr_print_int32(ndr, "level", r->in.level);
13746                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13747                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13748                 ndr->depth--;
13749         }
13750         if (flags & NDR_OUT) {
13751                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13752                 ndr->depth++;
13753                 ndr_print_WERROR(ndr, "result", r->out.result);
13754                 ndr->depth--;
13755         }
13756         ndr->depth--;
13757 }
13758
13759 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13760 {
13761         if (flags & NDR_IN) {
13762                 if (r->in.bind_handle == NULL) {
13763                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13764                 }
13765                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13766                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13767                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13768                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13769         }
13770         if (flags & NDR_OUT) {
13771                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13772         }
13773         return NDR_ERR_SUCCESS;
13774 }
13775
13776 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13777 {
13778         TALLOC_CTX *_mem_save_bind_handle_0;
13779         if (flags & NDR_IN) {
13780                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13781                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13782                 }
13783                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13784                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13785                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13786                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13787                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13788                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13789                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13790         }
13791         if (flags & NDR_OUT) {
13792                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13793         }
13794         return NDR_ERR_SUCCESS;
13795 }
13796
13797 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13798 {
13799         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13800         ndr->depth++;
13801         if (flags & NDR_SET_VALUES) {
13802                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13803         }
13804         if (flags & NDR_IN) {
13805                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13806                 ndr->depth++;
13807                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13808                 ndr->depth++;
13809                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13810                 ndr->depth--;
13811                 ndr_print_int32(ndr, "level", r->in.level);
13812                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13813                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13814                 ndr->depth--;
13815         }
13816         if (flags & NDR_OUT) {
13817                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13818                 ndr->depth++;
13819                 ndr_print_WERROR(ndr, "result", r->out.result);
13820                 ndr->depth--;
13821         }
13822         ndr->depth--;
13823 }
13824
13825 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13826 {
13827         if (flags & NDR_IN) {
13828                 if (r->in.bind_handle == NULL) {
13829                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13830                 }
13831                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13832                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13833                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13834                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13835         }
13836         if (flags & NDR_OUT) {
13837                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13838         }
13839         return NDR_ERR_SUCCESS;
13840 }
13841
13842 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13843 {
13844         TALLOC_CTX *_mem_save_bind_handle_0;
13845         if (flags & NDR_IN) {
13846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13847                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13848                 }
13849                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13850                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13851                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13852                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13853                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13854                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13855                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13856         }
13857         if (flags & NDR_OUT) {
13858                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13859         }
13860         return NDR_ERR_SUCCESS;
13861 }
13862
13863 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13864 {
13865         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13866         ndr->depth++;
13867         if (flags & NDR_SET_VALUES) {
13868                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13869         }
13870         if (flags & NDR_IN) {
13871                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13872                 ndr->depth++;
13873                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13874                 ndr->depth++;
13875                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13876                 ndr->depth--;
13877                 ndr_print_int32(ndr, "level", r->in.level);
13878                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13879                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13880                 ndr->depth--;
13881         }
13882         if (flags & NDR_OUT) {
13883                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13884                 ndr->depth++;
13885                 ndr_print_WERROR(ndr, "result", r->out.result);
13886                 ndr->depth--;
13887         }
13888         ndr->depth--;
13889 }
13890
13891 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13892 {
13893         if (flags & NDR_IN) {
13894                 if (r->in.bind_handle == NULL) {
13895                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13896                 }
13897                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13898                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13899                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13900                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13901         }
13902         if (flags & NDR_OUT) {
13903                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13904         }
13905         return NDR_ERR_SUCCESS;
13906 }
13907
13908 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13909 {
13910         TALLOC_CTX *_mem_save_bind_handle_0;
13911         if (flags & NDR_IN) {
13912                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13913                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13914                 }
13915                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13916                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13917                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13918                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13919                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13920                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13921                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13922         }
13923         if (flags & NDR_OUT) {
13924                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13925         }
13926         return NDR_ERR_SUCCESS;
13927 }
13928
13929 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13930 {
13931         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13932         ndr->depth++;
13933         if (flags & NDR_SET_VALUES) {
13934                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13935         }
13936         if (flags & NDR_IN) {
13937                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13938                 ndr->depth++;
13939                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13940                 ndr->depth++;
13941                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13942                 ndr->depth--;
13943                 ndr_print_int32(ndr, "level", r->in.level);
13944                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13945                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13946                 ndr->depth--;
13947         }
13948         if (flags & NDR_OUT) {
13949                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13950                 ndr->depth++;
13951                 ndr_print_WERROR(ndr, "result", r->out.result);
13952                 ndr->depth--;
13953         }
13954         ndr->depth--;
13955 }
13956
13957 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13958 {
13959         if (flags & NDR_IN) {
13960         }
13961         if (flags & NDR_OUT) {
13962                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13963         }
13964         return NDR_ERR_SUCCESS;
13965 }
13966
13967 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13968 {
13969         if (flags & NDR_IN) {
13970         }
13971         if (flags & NDR_OUT) {
13972                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13973         }
13974         return NDR_ERR_SUCCESS;
13975 }
13976
13977 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13978 {
13979         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13980         ndr->depth++;
13981         if (flags & NDR_SET_VALUES) {
13982                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13983         }
13984         if (flags & NDR_IN) {
13985                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13986                 ndr->depth++;
13987                 ndr->depth--;
13988         }
13989         if (flags & NDR_OUT) {
13990                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13991                 ndr->depth++;
13992                 ndr_print_WERROR(ndr, "result", r->out.result);
13993                 ndr->depth--;
13994         }
13995         ndr->depth--;
13996 }
13997
13998 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13999 {
14000         if (flags & NDR_IN) {
14001                 if (r->in.bind_handle == NULL) {
14002                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14003                 }
14004                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14005                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14006                 if (r->in.req == NULL) {
14007                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14008                 }
14009                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14010                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14011         }
14012         if (flags & NDR_OUT) {
14013                 if (r->out.level_out == NULL) {
14014                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14015                 }
14016                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14017                 if (r->out.ctr == NULL) {
14018                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14019                 }
14020                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14021                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14023         }
14024         return NDR_ERR_SUCCESS;
14025 }
14026
14027 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
14028 {
14029         TALLOC_CTX *_mem_save_bind_handle_0;
14030         TALLOC_CTX *_mem_save_req_0;
14031         TALLOC_CTX *_mem_save_level_out_0;
14032         TALLOC_CTX *_mem_save_ctr_0;
14033         if (flags & NDR_IN) {
14034                 ZERO_STRUCT(r->out);
14035
14036                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14037                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14038                 }
14039                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14040                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14041                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14042                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14043                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14044                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14045                         NDR_PULL_ALLOC(ndr, r->in.req);
14046                 }
14047                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14048                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14049                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14050                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14051                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14052                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14053                 ZERO_STRUCTP(r->out.level_out);
14054                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14055                 ZERO_STRUCTP(r->out.ctr);
14056         }
14057         if (flags & NDR_OUT) {
14058                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14059                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14060                 }
14061                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14062                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14063                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14064                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14066                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14067                 }
14068                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14069                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14070                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14071                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14072                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14073                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14074         }
14075         return NDR_ERR_SUCCESS;
14076 }
14077
14078 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14079 {
14080         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14081         ndr->depth++;
14082         if (flags & NDR_SET_VALUES) {
14083                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14084         }
14085         if (flags & NDR_IN) {
14086                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14087                 ndr->depth++;
14088                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14089                 ndr->depth++;
14090                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14091                 ndr->depth--;
14092                 ndr_print_int32(ndr, "level", r->in.level);
14093                 ndr_print_ptr(ndr, "req", r->in.req);
14094                 ndr->depth++;
14095                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14096                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14097                 ndr->depth--;
14098                 ndr->depth--;
14099         }
14100         if (flags & NDR_OUT) {
14101                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14102                 ndr->depth++;
14103                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14104                 ndr->depth++;
14105                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14106                 ndr->depth--;
14107                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14108                 ndr->depth++;
14109                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14110                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14111                 ndr->depth--;
14112                 ndr_print_WERROR(ndr, "result", r->out.result);
14113                 ndr->depth--;
14114         }
14115         ndr->depth--;
14116 }
14117
14118 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14119 {
14120         if (flags & NDR_IN) {
14121         }
14122         if (flags & NDR_OUT) {
14123                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14124         }
14125         return NDR_ERR_SUCCESS;
14126 }
14127
14128 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14129 {
14130         if (flags & NDR_IN) {
14131         }
14132         if (flags & NDR_OUT) {
14133                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14134         }
14135         return NDR_ERR_SUCCESS;
14136 }
14137
14138 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14139 {
14140         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14141         ndr->depth++;
14142         if (flags & NDR_SET_VALUES) {
14143                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14144         }
14145         if (flags & NDR_IN) {
14146                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14147                 ndr->depth++;
14148                 ndr->depth--;
14149         }
14150         if (flags & NDR_OUT) {
14151                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14152                 ndr->depth++;
14153                 ndr_print_WERROR(ndr, "result", r->out.result);
14154                 ndr->depth--;
14155         }
14156         ndr->depth--;
14157 }
14158
14159 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14160 {
14161         if (flags & NDR_IN) {
14162                 if (r->in.bind_handle == NULL) {
14163                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14164                 }
14165                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14167                 if (r->in.req == NULL) {
14168                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14169                 }
14170                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14171                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14172         }
14173         if (flags & NDR_OUT) {
14174                 if (r->out.level_out == NULL) {
14175                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14176                 }
14177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14178                 if (r->out.info == NULL) {
14179                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14180                 }
14181                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14182                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14183                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14184         }
14185         return NDR_ERR_SUCCESS;
14186 }
14187
14188 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14189 {
14190         TALLOC_CTX *_mem_save_bind_handle_0;
14191         TALLOC_CTX *_mem_save_req_0;
14192         TALLOC_CTX *_mem_save_level_out_0;
14193         TALLOC_CTX *_mem_save_info_0;
14194         if (flags & NDR_IN) {
14195                 ZERO_STRUCT(r->out);
14196
14197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14198                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14199                 }
14200                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14201                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14202                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14205                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14206                         NDR_PULL_ALLOC(ndr, r->in.req);
14207                 }
14208                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14209                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14210                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14211                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14212                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14213                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14214                 ZERO_STRUCTP(r->out.level_out);
14215                 NDR_PULL_ALLOC(ndr, r->out.info);
14216                 ZERO_STRUCTP(r->out.info);
14217         }
14218         if (flags & NDR_OUT) {
14219                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14220                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14221                 }
14222                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14223                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14226                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14227                         NDR_PULL_ALLOC(ndr, r->out.info);
14228                 }
14229                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14230                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14231                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14232                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14233                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14234                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14235         }
14236         return NDR_ERR_SUCCESS;
14237 }
14238
14239 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14240 {
14241         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14242         ndr->depth++;
14243         if (flags & NDR_SET_VALUES) {
14244                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14245         }
14246         if (flags & NDR_IN) {
14247                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14248                 ndr->depth++;
14249                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14250                 ndr->depth++;
14251                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14252                 ndr->depth--;
14253                 ndr_print_uint32(ndr, "level", r->in.level);
14254                 ndr_print_ptr(ndr, "req", r->in.req);
14255                 ndr->depth++;
14256                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14257                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14258                 ndr->depth--;
14259                 ndr->depth--;
14260         }
14261         if (flags & NDR_OUT) {
14262                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14263                 ndr->depth++;
14264                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14265                 ndr->depth++;
14266                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14267                 ndr->depth--;
14268                 ndr_print_ptr(ndr, "info", r->out.info);
14269                 ndr->depth++;
14270                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14271                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14272                 ndr->depth--;
14273                 ndr_print_WERROR(ndr, "result", r->out.result);
14274                 ndr->depth--;
14275         }
14276         ndr->depth--;
14277 }
14278
14279 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14280 {
14281         if (flags & NDR_IN) {
14282                 if (r->in.bind_handle == NULL) {
14283                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14284                 }
14285                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14286                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14287                 if (r->in.req == NULL) {
14288                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14289                 }
14290                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14291                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14292         }
14293         if (flags & NDR_OUT) {
14294                 if (r->out.level_out == NULL) {
14295                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14296                 }
14297                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14298                 if (r->out.ctr == NULL) {
14299                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14300                 }
14301                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14302                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14303                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14304         }
14305         return NDR_ERR_SUCCESS;
14306 }
14307
14308 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14309 {
14310         TALLOC_CTX *_mem_save_bind_handle_0;
14311         TALLOC_CTX *_mem_save_req_0;
14312         TALLOC_CTX *_mem_save_level_out_0;
14313         TALLOC_CTX *_mem_save_ctr_0;
14314         if (flags & NDR_IN) {
14315                 ZERO_STRUCT(r->out);
14316
14317                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14318                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14319                 }
14320                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14321                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14322                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14324                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14326                         NDR_PULL_ALLOC(ndr, r->in.req);
14327                 }
14328                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14329                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14330                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14331                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14332                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14333                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14334                 ZERO_STRUCTP(r->out.level_out);
14335                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14336                 ZERO_STRUCTP(r->out.ctr);
14337         }
14338         if (flags & NDR_OUT) {
14339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14340                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14341                 }
14342                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14343                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14344                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14346                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14347                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14348                 }
14349                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14350                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14351                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14352                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14353                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14354                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14355         }
14356         return NDR_ERR_SUCCESS;
14357 }
14358
14359 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14360 {
14361         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14362         ndr->depth++;
14363         if (flags & NDR_SET_VALUES) {
14364                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14365         }
14366         if (flags & NDR_IN) {
14367                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14368                 ndr->depth++;
14369                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14370                 ndr->depth++;
14371                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14372                 ndr->depth--;
14373                 ndr_print_int32(ndr, "level", r->in.level);
14374                 ndr_print_ptr(ndr, "req", r->in.req);
14375                 ndr->depth++;
14376                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14377                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14378                 ndr->depth--;
14379                 ndr->depth--;
14380         }
14381         if (flags & NDR_OUT) {
14382                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14383                 ndr->depth++;
14384                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14385                 ndr->depth++;
14386                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14387                 ndr->depth--;
14388                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14389                 ndr->depth++;
14390                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14391                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14392                 ndr->depth--;
14393                 ndr_print_WERROR(ndr, "result", r->out.result);
14394                 ndr->depth--;
14395         }
14396         ndr->depth--;
14397 }
14398
14399 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14400 {
14401         if (flags & NDR_IN) {
14402                 if (r->in.bind_handle == NULL) {
14403                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14404                 }
14405                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14406                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14407                 if (r->in.req == NULL) {
14408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14409                 }
14410                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14411                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14412         }
14413         if (flags & NDR_OUT) {
14414                 if (r->out.level_out == NULL) {
14415                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14416                 }
14417                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14418                 if (r->out.res == NULL) {
14419                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14420                 }
14421                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14422                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14423                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14424         }
14425         return NDR_ERR_SUCCESS;
14426 }
14427
14428 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14429 {
14430         TALLOC_CTX *_mem_save_bind_handle_0;
14431         TALLOC_CTX *_mem_save_req_0;
14432         TALLOC_CTX *_mem_save_level_out_0;
14433         TALLOC_CTX *_mem_save_res_0;
14434         if (flags & NDR_IN) {
14435                 ZERO_STRUCT(r->out);
14436
14437                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14438                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14439                 }
14440                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14441                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14442                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14443                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14444                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14446                         NDR_PULL_ALLOC(ndr, r->in.req);
14447                 }
14448                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14449                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14450                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14451                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14452                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14453                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14454                 ZERO_STRUCTP(r->out.level_out);
14455                 NDR_PULL_ALLOC(ndr, r->out.res);
14456                 ZERO_STRUCTP(r->out.res);
14457         }
14458         if (flags & NDR_OUT) {
14459                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14460                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14461                 }
14462                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14463                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14464                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14465                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14466                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14467                         NDR_PULL_ALLOC(ndr, r->out.res);
14468                 }
14469                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14470                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14471                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14472                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14474                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14475         }
14476         return NDR_ERR_SUCCESS;
14477 }
14478
14479 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14480 {
14481         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14482         ndr->depth++;
14483         if (flags & NDR_SET_VALUES) {
14484                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14485         }
14486         if (flags & NDR_IN) {
14487                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14488                 ndr->depth++;
14489                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14490                 ndr->depth++;
14491                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14492                 ndr->depth--;
14493                 ndr_print_int32(ndr, "level", r->in.level);
14494                 ndr_print_ptr(ndr, "req", r->in.req);
14495                 ndr->depth++;
14496                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14497                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14498                 ndr->depth--;
14499                 ndr->depth--;
14500         }
14501         if (flags & NDR_OUT) {
14502                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14503                 ndr->depth++;
14504                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14505                 ndr->depth++;
14506                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14507                 ndr->depth--;
14508                 ndr_print_ptr(ndr, "res", r->out.res);
14509                 ndr->depth++;
14510                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14511                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14512                 ndr->depth--;
14513                 ndr_print_WERROR(ndr, "result", r->out.result);
14514                 ndr->depth--;
14515         }
14516         ndr->depth--;
14517 }
14518
14519 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14520 {
14521         if (flags & NDR_IN) {
14522                 if (r->in.bind_handle == NULL) {
14523                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14524                 }
14525                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14526                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14527                 if (r->in.req == NULL) {
14528                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14529                 }
14530                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14531                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14532         }
14533         if (flags & NDR_OUT) {
14534                 if (r->out.level_out == NULL) {
14535                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14536                 }
14537                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14538                 if (r->out.res == NULL) {
14539                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14540                 }
14541                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14542                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14543                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14544         }
14545         return NDR_ERR_SUCCESS;
14546 }
14547
14548 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14549 {
14550         TALLOC_CTX *_mem_save_bind_handle_0;
14551         TALLOC_CTX *_mem_save_req_0;
14552         TALLOC_CTX *_mem_save_level_out_0;
14553         TALLOC_CTX *_mem_save_res_0;
14554         if (flags & NDR_IN) {
14555                 ZERO_STRUCT(r->out);
14556
14557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14558                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14559                 }
14560                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14561                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14562                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14564                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14565                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14566                         NDR_PULL_ALLOC(ndr, r->in.req);
14567                 }
14568                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14569                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14570                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14571                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14572                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14573                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14574                 ZERO_STRUCTP(r->out.level_out);
14575                 NDR_PULL_ALLOC(ndr, r->out.res);
14576                 ZERO_STRUCTP(r->out.res);
14577         }
14578         if (flags & NDR_OUT) {
14579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14580                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14581                 }
14582                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14583                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14584                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14586                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14587                         NDR_PULL_ALLOC(ndr, r->out.res);
14588                 }
14589                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14590                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14591                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14592                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14593                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14594                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14595         }
14596         return NDR_ERR_SUCCESS;
14597 }
14598
14599 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14600 {
14601         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14602         ndr->depth++;
14603         if (flags & NDR_SET_VALUES) {
14604                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14605         }
14606         if (flags & NDR_IN) {
14607                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14608                 ndr->depth++;
14609                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14610                 ndr->depth++;
14611                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14612                 ndr->depth--;
14613                 ndr_print_int32(ndr, "level", r->in.level);
14614                 ndr_print_ptr(ndr, "req", r->in.req);
14615                 ndr->depth++;
14616                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14617                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14618                 ndr->depth--;
14619                 ndr->depth--;
14620         }
14621         if (flags & NDR_OUT) {
14622                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14623                 ndr->depth++;
14624                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14625                 ndr->depth++;
14626                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14627                 ndr->depth--;
14628                 ndr_print_ptr(ndr, "res", r->out.res);
14629                 ndr->depth++;
14630                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14631                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14632                 ndr->depth--;
14633                 ndr_print_WERROR(ndr, "result", r->out.result);
14634                 ndr->depth--;
14635         }
14636         ndr->depth--;
14637 }
14638
14639 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14640 {
14641         if (flags & NDR_IN) {
14642         }
14643         if (flags & NDR_OUT) {
14644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14645         }
14646         return NDR_ERR_SUCCESS;
14647 }
14648
14649 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14650 {
14651         if (flags & NDR_IN) {
14652         }
14653         if (flags & NDR_OUT) {
14654                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14655         }
14656         return NDR_ERR_SUCCESS;
14657 }
14658
14659 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14660 {
14661         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14662         ndr->depth++;
14663         if (flags & NDR_SET_VALUES) {
14664                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14665         }
14666         if (flags & NDR_IN) {
14667                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14668                 ndr->depth++;
14669                 ndr->depth--;
14670         }
14671         if (flags & NDR_OUT) {
14672                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14673                 ndr->depth++;
14674                 ndr_print_WERROR(ndr, "result", r->out.result);
14675                 ndr->depth--;
14676         }
14677         ndr->depth--;
14678 }
14679
14680 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14681 {
14682         if (flags & NDR_IN) {
14683                 if (r->in.bind_handle == NULL) {
14684                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14685                 }
14686                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14687                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14688                 if (r->in.req == NULL) {
14689                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14690                 }
14691                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14692                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14693         }
14694         if (flags & NDR_OUT) {
14695                 if (r->out.level_out == NULL) {
14696                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14697                 }
14698                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14699                 if (r->out.ctr == NULL) {
14700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14701                 }
14702                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14703                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14704                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14705         }
14706         return NDR_ERR_SUCCESS;
14707 }
14708
14709 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14710 {
14711         TALLOC_CTX *_mem_save_bind_handle_0;
14712         TALLOC_CTX *_mem_save_req_0;
14713         TALLOC_CTX *_mem_save_level_out_0;
14714         TALLOC_CTX *_mem_save_ctr_0;
14715         if (flags & NDR_IN) {
14716                 ZERO_STRUCT(r->out);
14717
14718                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14719                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14720                 }
14721                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14722                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14723                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14724                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14725                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14726                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14727                         NDR_PULL_ALLOC(ndr, r->in.req);
14728                 }
14729                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14730                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14731                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14732                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14733                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14734                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14735                 ZERO_STRUCTP(r->out.level_out);
14736                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14737                 ZERO_STRUCTP(r->out.ctr);
14738         }
14739         if (flags & NDR_OUT) {
14740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14741                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14742                 }
14743                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14744                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14745                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14747                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14748                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14749                 }
14750                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14751                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14752                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14753                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14754                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14755                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14756         }
14757         return NDR_ERR_SUCCESS;
14758 }
14759
14760 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14761 {
14762         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14763         ndr->depth++;
14764         if (flags & NDR_SET_VALUES) {
14765                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14766         }
14767         if (flags & NDR_IN) {
14768                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14769                 ndr->depth++;
14770                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14771                 ndr->depth++;
14772                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14773                 ndr->depth--;
14774                 ndr_print_int32(ndr, "level", r->in.level);
14775                 ndr_print_ptr(ndr, "req", r->in.req);
14776                 ndr->depth++;
14777                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14778                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14779                 ndr->depth--;
14780                 ndr->depth--;
14781         }
14782         if (flags & NDR_OUT) {
14783                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14784                 ndr->depth++;
14785                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14786                 ndr->depth++;
14787                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14788                 ndr->depth--;
14789                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14790                 ndr->depth++;
14791                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14792                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14793                 ndr->depth--;
14794                 ndr_print_WERROR(ndr, "result", r->out.result);
14795                 ndr->depth--;
14796         }
14797         ndr->depth--;
14798 }
14799
14800 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14801 {
14802         if (flags & NDR_IN) {
14803                 if (r->in.bind_handle == NULL) {
14804                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14805                 }
14806                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14807                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14808                 if (r->in.req == NULL) {
14809                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14810                 }
14811                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14812                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14813         }
14814         if (flags & NDR_OUT) {
14815                 if (r->out.level_out == NULL) {
14816                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14817                 }
14818                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14819                 if (r->out.ctr == NULL) {
14820                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14821                 }
14822                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14823                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14824                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14825         }
14826         return NDR_ERR_SUCCESS;
14827 }
14828
14829 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14830 {
14831         TALLOC_CTX *_mem_save_bind_handle_0;
14832         TALLOC_CTX *_mem_save_req_0;
14833         TALLOC_CTX *_mem_save_level_out_0;
14834         TALLOC_CTX *_mem_save_ctr_0;
14835         if (flags & NDR_IN) {
14836                 ZERO_STRUCT(r->out);
14837
14838                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14839                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14840                 }
14841                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14842                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14843                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14844                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14845                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14847                         NDR_PULL_ALLOC(ndr, r->in.req);
14848                 }
14849                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14850                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14851                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14852                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14853                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14854                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14855                 ZERO_STRUCTP(r->out.level_out);
14856                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14857                 ZERO_STRUCTP(r->out.ctr);
14858         }
14859         if (flags & NDR_OUT) {
14860                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14861                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14862                 }
14863                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14864                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14865                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14866                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14867                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14868                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14869                 }
14870                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14871                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14872                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14873                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14874                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14875                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14876         }
14877         return NDR_ERR_SUCCESS;
14878 }
14879
14880 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14881 {
14882         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14883         ndr->depth++;
14884         if (flags & NDR_SET_VALUES) {
14885                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14886         }
14887         if (flags & NDR_IN) {
14888                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14889                 ndr->depth++;
14890                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14891                 ndr->depth++;
14892                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14893                 ndr->depth--;
14894                 ndr_print_int32(ndr, "level", r->in.level);
14895                 ndr_print_ptr(ndr, "req", r->in.req);
14896                 ndr->depth++;
14897                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14898                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14899                 ndr->depth--;
14900                 ndr->depth--;
14901         }
14902         if (flags & NDR_OUT) {
14903                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14904                 ndr->depth++;
14905                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14906                 ndr->depth++;
14907                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14908                 ndr->depth--;
14909                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14910                 ndr->depth++;
14911                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14912                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14913                 ndr->depth--;
14914                 ndr_print_WERROR(ndr, "result", r->out.result);
14915                 ndr->depth--;
14916         }
14917         ndr->depth--;
14918 }
14919
14920 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
14921 {
14922         if (flags & NDR_IN) {
14923                 if (r->in.bind_handle == NULL) {
14924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14925                 }
14926                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14928                 if (r->in.req == NULL) {
14929                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14930                 }
14931                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14932                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14933         }
14934         if (flags & NDR_OUT) {
14935                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14936         }
14937         return NDR_ERR_SUCCESS;
14938 }
14939
14940 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
14941 {
14942         TALLOC_CTX *_mem_save_bind_handle_0;
14943         TALLOC_CTX *_mem_save_req_0;
14944         if (flags & NDR_IN) {
14945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14946                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14947                 }
14948                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14949                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14950                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14953                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14954                         NDR_PULL_ALLOC(ndr, r->in.req);
14955                 }
14956                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14957                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14958                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14959                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14960                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14961         }
14962         if (flags & NDR_OUT) {
14963                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14964         }
14965         return NDR_ERR_SUCCESS;
14966 }
14967
14968 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
14969 {
14970         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
14971         ndr->depth++;
14972         if (flags & NDR_SET_VALUES) {
14973                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14974         }
14975         if (flags & NDR_IN) {
14976                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
14977                 ndr->depth++;
14978                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14979                 ndr->depth++;
14980                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14981                 ndr->depth--;
14982                 ndr_print_uint32(ndr, "level", r->in.level);
14983                 ndr_print_ptr(ndr, "req", r->in.req);
14984                 ndr->depth++;
14985                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14986                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
14987                 ndr->depth--;
14988                 ndr->depth--;
14989         }
14990         if (flags & NDR_OUT) {
14991                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
14992                 ndr->depth++;
14993                 ndr_print_WERROR(ndr, "result", r->out.result);
14994                 ndr->depth--;
14995         }
14996         ndr->depth--;
14997 }
14998
14999 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15000 {
15001         if (flags & NDR_IN) {
15002                 if (r->in.bind_handle == NULL) {
15003                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15004                 }
15005                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15006                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
15007                 if (r->in.req == NULL) {
15008                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15009                 }
15010                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15011                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15012         }
15013         if (flags & NDR_OUT) {
15014                 if (r->out.info_type == NULL) {
15015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15016                 }
15017                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
15018                 if (r->out.info == NULL) {
15019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15020                 }
15021                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
15022                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15023                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15024         }
15025         return NDR_ERR_SUCCESS;
15026 }
15027
15028 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
15029 {
15030         TALLOC_CTX *_mem_save_bind_handle_0;
15031         TALLOC_CTX *_mem_save_req_0;
15032         TALLOC_CTX *_mem_save_info_type_0;
15033         TALLOC_CTX *_mem_save_info_0;
15034         if (flags & NDR_IN) {
15035                 ZERO_STRUCT(r->out);
15036
15037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15038                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15039                 }
15040                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15041                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15042                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15044                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
15045                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15046                         NDR_PULL_ALLOC(ndr, r->in.req);
15047                 }
15048                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15049                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15050                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15051                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15053                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15054                 ZERO_STRUCTP(r->out.info_type);
15055                 NDR_PULL_ALLOC(ndr, r->out.info);
15056                 ZERO_STRUCTP(r->out.info);
15057         }
15058         if (flags & NDR_OUT) {
15059                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15060                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15061                 }
15062                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15063                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15064                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15065                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15066                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15067                         NDR_PULL_ALLOC(ndr, r->out.info);
15068                 }
15069                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15070                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15071                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15072                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15073                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15074                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15075         }
15076         return NDR_ERR_SUCCESS;
15077 }
15078
15079 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15080 {
15081         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15082         ndr->depth++;
15083         if (flags & NDR_SET_VALUES) {
15084                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15085         }
15086         if (flags & NDR_IN) {
15087                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15088                 ndr->depth++;
15089                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15090                 ndr->depth++;
15091                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15092                 ndr->depth--;
15093                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15094                 ndr_print_ptr(ndr, "req", r->in.req);
15095                 ndr->depth++;
15096                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15097                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15098                 ndr->depth--;
15099                 ndr->depth--;
15100         }
15101         if (flags & NDR_OUT) {
15102                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15103                 ndr->depth++;
15104                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15105                 ndr->depth++;
15106                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15107                 ndr->depth--;
15108                 ndr_print_ptr(ndr, "info", r->out.info);
15109                 ndr->depth++;
15110                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15111                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15112                 ndr->depth--;
15113                 ndr_print_WERROR(ndr, "result", r->out.result);
15114                 ndr->depth--;
15115         }
15116         ndr->depth--;
15117 }
15118
15119 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15120 {
15121         if (flags & NDR_IN) {
15122         }
15123         if (flags & NDR_OUT) {
15124                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15125         }
15126         return NDR_ERR_SUCCESS;
15127 }
15128
15129 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15130 {
15131         if (flags & NDR_IN) {
15132         }
15133         if (flags & NDR_OUT) {
15134                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15135         }
15136         return NDR_ERR_SUCCESS;
15137 }
15138
15139 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15140 {
15141         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15142         ndr->depth++;
15143         if (flags & NDR_SET_VALUES) {
15144                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15145         }
15146         if (flags & NDR_IN) {
15147                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15148                 ndr->depth++;
15149                 ndr->depth--;
15150         }
15151         if (flags & NDR_OUT) {
15152                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15153                 ndr->depth++;
15154                 ndr_print_WERROR(ndr, "result", r->out.result);
15155                 ndr->depth--;
15156         }
15157         ndr->depth--;
15158 }
15159
15160 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15161 {
15162         if (flags & NDR_IN) {
15163                 if (r->in.bind_handle == NULL) {
15164                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15165                 }
15166                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15167                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15168                 if (r->in.req == NULL) {
15169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15170                 }
15171                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15172                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15173         }
15174         if (flags & NDR_OUT) {
15175                 if (r->out.level_out == NULL) {
15176                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15177                 }
15178                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15179                 if (r->out.ctr == NULL) {
15180                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15181                 }
15182                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15183                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15184                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15185         }
15186         return NDR_ERR_SUCCESS;
15187 }
15188
15189 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15190 {
15191         TALLOC_CTX *_mem_save_bind_handle_0;
15192         TALLOC_CTX *_mem_save_req_0;
15193         TALLOC_CTX *_mem_save_level_out_0;
15194         TALLOC_CTX *_mem_save_ctr_0;
15195         if (flags & NDR_IN) {
15196                 ZERO_STRUCT(r->out);
15197
15198                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15199                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15200                 }
15201                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15202                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15203                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15205                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15206                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15207                         NDR_PULL_ALLOC(ndr, r->in.req);
15208                 }
15209                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15210                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15211                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15212                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15214                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15215                 ZERO_STRUCTP(r->out.level_out);
15216                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15217                 ZERO_STRUCTP(r->out.ctr);
15218         }
15219         if (flags & NDR_OUT) {
15220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15221                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15222                 }
15223                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15224                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15225                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15227                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15228                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15229                 }
15230                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15231                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15232                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15233                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15235                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15236         }
15237         return NDR_ERR_SUCCESS;
15238 }
15239
15240 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15241 {
15242         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15243         ndr->depth++;
15244         if (flags & NDR_SET_VALUES) {
15245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15246         }
15247         if (flags & NDR_IN) {
15248                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15249                 ndr->depth++;
15250                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15251                 ndr->depth++;
15252                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15253                 ndr->depth--;
15254                 ndr_print_int32(ndr, "level", r->in.level);
15255                 ndr_print_ptr(ndr, "req", r->in.req);
15256                 ndr->depth++;
15257                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15258                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15259                 ndr->depth--;
15260                 ndr->depth--;
15261         }
15262         if (flags & NDR_OUT) {
15263                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15264                 ndr->depth++;
15265                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15266                 ndr->depth++;
15267                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15268                 ndr->depth--;
15269                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15270                 ndr->depth++;
15271                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15272                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15273                 ndr->depth--;
15274                 ndr_print_WERROR(ndr, "result", r->out.result);
15275                 ndr->depth--;
15276         }
15277         ndr->depth--;
15278 }
15279
15280 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15281 {
15282         if (flags & NDR_IN) {
15283         }
15284         if (flags & NDR_OUT) {
15285                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15286         }
15287         return NDR_ERR_SUCCESS;
15288 }
15289
15290 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15291 {
15292         if (flags & NDR_IN) {
15293         }
15294         if (flags & NDR_OUT) {
15295                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15296         }
15297         return NDR_ERR_SUCCESS;
15298 }
15299
15300 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15301 {
15302         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15303         ndr->depth++;
15304         if (flags & NDR_SET_VALUES) {
15305                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15306         }
15307         if (flags & NDR_IN) {
15308                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15309                 ndr->depth++;
15310                 ndr->depth--;
15311         }
15312         if (flags & NDR_OUT) {
15313                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15314                 ndr->depth++;
15315                 ndr_print_WERROR(ndr, "result", r->out.result);
15316                 ndr->depth--;
15317         }
15318         ndr->depth--;
15319 }
15320
15321 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15322 {
15323         if (flags & NDR_IN) {
15324         }
15325         if (flags & NDR_OUT) {
15326                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15327         }
15328         return NDR_ERR_SUCCESS;
15329 }
15330
15331 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15332 {
15333         if (flags & NDR_IN) {
15334         }
15335         if (flags & NDR_OUT) {
15336                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15337         }
15338         return NDR_ERR_SUCCESS;
15339 }
15340
15341 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15342 {
15343         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15344         ndr->depth++;
15345         if (flags & NDR_SET_VALUES) {
15346                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15347         }
15348         if (flags & NDR_IN) {
15349                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15350                 ndr->depth++;
15351                 ndr->depth--;
15352         }
15353         if (flags & NDR_OUT) {
15354                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15355                 ndr->depth++;
15356                 ndr_print_WERROR(ndr, "result", r->out.result);
15357                 ndr->depth--;
15358         }
15359         ndr->depth--;
15360 }
15361
15362 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15363 {
15364         if (flags & NDR_IN) {
15365                 if (r->in.bind_handle == NULL) {
15366                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15367                 }
15368                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15369                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15370                 if (r->in.req == NULL) {
15371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15372                 }
15373                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15374                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15375         }
15376         if (flags & NDR_OUT) {
15377                 if (r->out.level_out == NULL) {
15378                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15379                 }
15380                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15381                 if (r->out.ctr == NULL) {
15382                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15383                 }
15384                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15385                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15386                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15387         }
15388         return NDR_ERR_SUCCESS;
15389 }
15390
15391 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15392 {
15393         TALLOC_CTX *_mem_save_bind_handle_0;
15394         TALLOC_CTX *_mem_save_req_0;
15395         TALLOC_CTX *_mem_save_level_out_0;
15396         TALLOC_CTX *_mem_save_ctr_0;
15397         if (flags & NDR_IN) {
15398                 ZERO_STRUCT(r->out);
15399
15400                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15401                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15402                 }
15403                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15404                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15405                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15406                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15407                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15408                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15409                         NDR_PULL_ALLOC(ndr, r->in.req);
15410                 }
15411                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15412                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15413                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15414                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15416                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15417                 ZERO_STRUCTP(r->out.level_out);
15418                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15419                 ZERO_STRUCTP(r->out.ctr);
15420         }
15421         if (flags & NDR_OUT) {
15422                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15423                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15424                 }
15425                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15426                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15427                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15428                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15429                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15430                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15431                 }
15432                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15433                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15434                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15435                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15436                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15437                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15438         }
15439         return NDR_ERR_SUCCESS;
15440 }
15441
15442 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15443 {
15444         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15445         ndr->depth++;
15446         if (flags & NDR_SET_VALUES) {
15447                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15448         }
15449         if (flags & NDR_IN) {
15450                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15451                 ndr->depth++;
15452                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15453                 ndr->depth++;
15454                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15455                 ndr->depth--;
15456                 ndr_print_int32(ndr, "level", r->in.level);
15457                 ndr_print_ptr(ndr, "req", r->in.req);
15458                 ndr->depth++;
15459                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15460                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15461                 ndr->depth--;
15462                 ndr->depth--;
15463         }
15464         if (flags & NDR_OUT) {
15465                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15466                 ndr->depth++;
15467                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15468                 ndr->depth++;
15469                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15470                 ndr->depth--;
15471                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15472                 ndr->depth++;
15473                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15474                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15475                 ndr->depth--;
15476                 ndr_print_WERROR(ndr, "result", r->out.result);
15477                 ndr->depth--;
15478         }
15479         ndr->depth--;
15480 }
15481
15482 static const struct ndr_interface_call drsuapi_calls[] = {
15483         {
15484                 "drsuapi_DsBind",
15485                 sizeof(struct drsuapi_DsBind),
15486                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15487                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15488                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15489                 false,
15490         },
15491         {
15492                 "drsuapi_DsUnbind",
15493                 sizeof(struct drsuapi_DsUnbind),
15494                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15495                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15496                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15497                 false,
15498         },
15499         {
15500                 "drsuapi_DsReplicaSync",
15501                 sizeof(struct drsuapi_DsReplicaSync),
15502                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15503                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15504                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15505                 false,
15506         },
15507         {
15508                 "drsuapi_DsGetNCChanges",
15509                 sizeof(struct drsuapi_DsGetNCChanges),
15510                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15511                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15512                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15513                 false,
15514         },
15515         {
15516                 "drsuapi_DsReplicaUpdateRefs",
15517                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15518                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15519                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15520                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15521                 false,
15522         },
15523         {
15524                 "drsuapi_DsReplicaAdd",
15525                 sizeof(struct drsuapi_DsReplicaAdd),
15526                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15527                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15528                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15529                 false,
15530         },
15531         {
15532                 "drsuapi_DsReplicaDel",
15533                 sizeof(struct drsuapi_DsReplicaDel),
15534                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15535                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15536                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15537                 false,
15538         },
15539         {
15540                 "drsuapi_DsReplicaMod",
15541                 sizeof(struct drsuapi_DsReplicaMod),
15542                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15543                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15544                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15545                 false,
15546         },
15547         {
15548                 "DRSUAPI_VERIFY_NAMES",
15549                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15550                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15551                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15552                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15553                 false,
15554         },
15555         {
15556                 "drsuapi_DsGetMemberships",
15557                 sizeof(struct drsuapi_DsGetMemberships),
15558                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15559                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15560                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15561                 false,
15562         },
15563         {
15564                 "DRSUAPI_INTER_DOMAIN_MOVE",
15565                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15566                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15567                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15568                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15569                 false,
15570         },
15571         {
15572                 "drsuapi_DsGetNT4ChangeLog",
15573                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15574                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15575                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15576                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15577                 false,
15578         },
15579         {
15580                 "drsuapi_DsCrackNames",
15581                 sizeof(struct drsuapi_DsCrackNames),
15582                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15583                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15584                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15585                 false,
15586         },
15587         {
15588                 "drsuapi_DsWriteAccountSpn",
15589                 sizeof(struct drsuapi_DsWriteAccountSpn),
15590                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15591                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15592                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15593                 false,
15594         },
15595         {
15596                 "drsuapi_DsRemoveDSServer",
15597                 sizeof(struct drsuapi_DsRemoveDSServer),
15598                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15599                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15600                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15601                 false,
15602         },
15603         {
15604                 "DRSUAPI_REMOVE_DS_DOMAIN",
15605                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15606                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15607                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15608                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15609                 false,
15610         },
15611         {
15612                 "drsuapi_DsGetDomainControllerInfo",
15613                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15614                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15615                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15616                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15617                 false,
15618         },
15619         {
15620                 "drsuapi_DsAddEntry",
15621                 sizeof(struct drsuapi_DsAddEntry),
15622                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15623                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15624                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15625                 false,
15626         },
15627         {
15628                 "drsuapi_DsExecuteKCC",
15629                 sizeof(struct drsuapi_DsExecuteKCC),
15630                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15631                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15632                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15633                 false,
15634         },
15635         {
15636                 "drsuapi_DsReplicaGetInfo",
15637                 sizeof(struct drsuapi_DsReplicaGetInfo),
15638                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15639                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15640                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15641                 false,
15642         },
15643         {
15644                 "DRSUAPI_ADD_SID_HISTORY",
15645                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15646                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15647                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15648                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15649                 false,
15650         },
15651         {
15652                 "drsuapi_DsGetMemberships2",
15653                 sizeof(struct drsuapi_DsGetMemberships2),
15654                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15655                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15656                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15657                 false,
15658         },
15659         {
15660                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15661                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15662                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15663                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15664                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15665                 false,
15666         },
15667         {
15668                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15669                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15670                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15671                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15672                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15673                 false,
15674         },
15675         {
15676                 "drsuapi_QuerySitesByCost",
15677                 sizeof(struct drsuapi_QuerySitesByCost),
15678                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15679                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15680                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15681                 false,
15682         },
15683         { NULL, 0, NULL, NULL, NULL, false }
15684 };
15685
15686 static const char * const drsuapi_endpoint_strings[] = {
15687         "ncacn_np:[\\pipe\\lsass]",
15688         "ncacn_np:[\\pipe\\protected_storage]",
15689         "ncacn_ip_tcp:",
15690         "ncalrpc:",
15691 };
15692
15693 static const struct ndr_interface_string_array drsuapi_endpoints = {
15694         .count  = 4,
15695         .names  = drsuapi_endpoint_strings
15696 };
15697
15698 static const char * const drsuapi_authservice_strings[] = {
15699         "ldap",
15700 };
15701
15702 static const struct ndr_interface_string_array drsuapi_authservices = {
15703         .count  = 1,
15704         .names  = drsuapi_authservice_strings
15705 };
15706
15707
15708 const struct ndr_interface_table ndr_table_drsuapi = {
15709         .name           = "drsuapi",
15710         .syntax_id      = {
15711                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15712                 NDR_DRSUAPI_VERSION
15713         },
15714         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15715         .num_calls      = 25,
15716         .calls          = drsuapi_calls,
15717         .endpoints      = &drsuapi_endpoints,
15718         .authservices   = &drsuapi_authservices
15719 };
15720