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 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(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 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensions(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_SupportedExtensions(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_SUPPORTED_EXTENSION_BASE", DRSUAPI_SUPPORTED_EXTENSION_BASE, r);
  29         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION, r);
  30         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI", DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI, r);
  31         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2", DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2, r);
  32         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS, r);
  33         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1, r);
  34         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION", DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION, r);
  35         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00000080", DRSUAPI_SUPPORTED_EXTENSION_00000080, r);
  36         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE", DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE, r);
  37         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2, r);
  38         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION, r);
  39         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2, r);
  40         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);
  41         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND", DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND, r);
  42         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO", DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO, r);
  43         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION", DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION, r);
  44         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01, r);
  45         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP", DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP, r);
  46         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY", DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY, r);
  47         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3", DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3, r);
  48         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00100000", DRSUAPI_SUPPORTED_EXTENSION_00100000, r);
  49         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2", DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2, r);
  50         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6, r);
  51         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS", DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS, r);
  52         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8, r);
  53         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5, r);
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT", DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT, r);
  58         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS, r);
  59         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_20000000", DRSUAPI_SUPPORTED_EXTENSION_20000000, r);
  60         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_40000000", DRSUAPI_SUPPORTED_EXTENSION_40000000, r);
  61         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_80000000", DRSUAPI_SUPPORTED_EXTENSION_80000000, r);
  62         ndr->depth--;
  63 }
  64
  65 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensionsExt(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  66 {
  67         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  68         return NDR_ERR_SUCCESS;
  69 }
  70
  71 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensionsExt(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  72 {
  73         uint32_t v;
  74         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  75         *r = v;
  76         return NDR_ERR_SUCCESS;
  77 }
  78
  79 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensionsExt(struct ndr_print *ndr, const char *name, uint32_t r)
  80 {
  81         ndr_print_uint32(ndr, name, r);
  82         ndr->depth++;
  83         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADAM", DRSUAPI_SUPPORTED_EXTENSION_ADAM, r);
  84         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2", DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2, r);
  85         ndr->depth--;
  86 }
  87
  88 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo24 *r)
  89 {
  90         if (ndr_flags & NDR_SCALARS) {
  91                 NDR_CHECK(ndr_push_align(ndr, 4));
  92                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
  93                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
  94                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
  95                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  96         }
  97         if (ndr_flags & NDR_BUFFERS) {
  98         }
  99         return NDR_ERR_SUCCESS;
 100 }
 101
 102 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo24 *r)
 103 {
 104         if (ndr_flags & NDR_SCALARS) {
 105                 NDR_CHECK(ndr_pull_align(ndr, 4));
 106                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 107                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 109                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 110         }
 111         if (ndr_flags & NDR_BUFFERS) {
 112         }
 113         return NDR_ERR_SUCCESS;
 114 }
 115
 116 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r)
 117 {
 118         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo24");
 119         ndr->depth++;
 120         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 121         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 122         ndr_print_uint32(ndr, "pid", r->pid);
 123         ndr->depth--;
 124 }
 125
 126 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo28 *r)
 127 {
 128         if (ndr_flags & NDR_SCALARS) {
 129                 NDR_CHECK(ndr_push_align(ndr, 4));
 130                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 131                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 134                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 135         }
 136         if (ndr_flags & NDR_BUFFERS) {
 137         }
 138         return NDR_ERR_SUCCESS;
 139 }
 140
 141 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo28 *r)
 142 {
 143         if (ndr_flags & NDR_SCALARS) {
 144                 NDR_CHECK(ndr_pull_align(ndr, 4));
 145                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 146                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 149                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 150         }
 151         if (ndr_flags & NDR_BUFFERS) {
 152         }
 153         return NDR_ERR_SUCCESS;
 154 }
 155
 156 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo28(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo28 *r)
 157 {
 158         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo28");
 159         ndr->depth++;
 160         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 161         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 162         ndr_print_uint32(ndr, "pid", r->pid);
 163         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 164         ndr->depth--;
 165 }
 166
 167 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo48 *r)
 168 {
 169         if (ndr_flags & NDR_SCALARS) {
 170                 NDR_CHECK(ndr_push_align(ndr, 4));
 171                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 172                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 175                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
 176                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 177                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 178         }
 179         if (ndr_flags & NDR_BUFFERS) {
 180         }
 181         return NDR_ERR_SUCCESS;
 182 }
 183
 184 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo48 *r)
 185 {
 186         if (ndr_flags & NDR_SCALARS) {
 187                 NDR_CHECK(ndr_pull_align(ndr, 4));
 188                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 189                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 192                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
 193                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 194                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 195         }
 196         if (ndr_flags & NDR_BUFFERS) {
 197         }
 198         return NDR_ERR_SUCCESS;
 199 }
 200
 201 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo48(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo48 *r)
 202 {
 203         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo48");
 204         ndr->depth++;
 205         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 206         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 207         ndr_print_uint32(ndr, "pid", r->pid);
 208         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 209         ndr_print_drsuapi_SupportedExtensionsExt(ndr, "supported_extensions_ext", r->supported_extensions_ext);
 210         ndr_print_GUID(ndr, "config_dn_guid", &r->config_dn_guid);
 211         ndr->depth--;
 212 }
 213
 214 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoFallBack *r)
 215 {
 216         if (ndr_flags & NDR_SCALARS) {
 217                 NDR_CHECK(ndr_push_align(ndr, 4));
 218                 {
 219                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 220                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 221                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
 222                         ndr->flags = _flags_save_DATA_BLOB;
 223                 }
 224                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 225         }
 226         if (ndr_flags & NDR_BUFFERS) {
 227         }
 228         return NDR_ERR_SUCCESS;
 229 }
 230
 231 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoFallBack *r)
 232 {
 233         if (ndr_flags & NDR_SCALARS) {
 234                 NDR_CHECK(ndr_pull_align(ndr, 4));
 235                 {
 236                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 238                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
 239                         ndr->flags = _flags_save_DATA_BLOB;
 240                 }
 241                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 242         }
 243         if (ndr_flags & NDR_BUFFERS) {
 244         }
 245         return NDR_ERR_SUCCESS;
 246 }
 247
 248 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoFallBack(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoFallBack *r)
 249 {
 250         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoFallBack");
 251         ndr->depth++;
 252         ndr_print_DATA_BLOB(ndr, "info", r->info);
 253         ndr->depth--;
 254 }
 255
 256 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
 257 {
 258         if (ndr_flags & NDR_SCALARS) {
 259                 int level = ndr_push_get_switch_value(ndr, r);
 260                 NDR_CHECK(ndr_push_union_align(ndr, 1));
 261                 switch (level) {
 262                         case 24: {
 263                                 {
 264                                         struct ndr_push *_ndr_info24;
 265                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 4, -1));
 266                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 267                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 4, -1));
 268                                 }
 269                         break; }
 270
 271                         case 28: {
 272                                 {
 273                                         struct ndr_push *_ndr_info28;
 274                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 4, -1));
 275                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 276                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 4, -1));
 277                                 }
 278                         break; }
 279
 280                         case 48: {
 281                                 {
 282                                         struct ndr_push *_ndr_info48;
 283                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 4, -1));
 284                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 285                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 4, -1));
 286                                 }
 287                         break; }
 288
 289                         default: {
 290                                 {
 291                                         struct ndr_push *_ndr_FallBack;
 292                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 293                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 294                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 295                                 }
 296                         break; }
 297
 298                 }
 299         }
 300         if (ndr_flags & NDR_BUFFERS) {
 301                 int level = ndr_push_get_switch_value(ndr, r);
 302                 switch (level) {
 303                         case 24:
 304                         break;
 305
 306                         case 28:
 307                         break;
 308
 309                         case 48:
 310                         break;
 311
 312                         default:
 313                         break;
 314
 315                 }
 316         }
 317         return NDR_ERR_SUCCESS;
 318 }
 319
 320 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
 321 {
 322         int level;
 323         level = ndr_pull_get_switch_value(ndr, r);
 324         if (ndr_flags & NDR_SCALARS) {
 325                 NDR_CHECK(ndr_pull_union_align(ndr, 1));
 326                 switch (level) {
 327                         case 24: {
 328                                 {
 329                                         struct ndr_pull *_ndr_info24;
 330                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 4, -1));
 331                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 332                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 4, -1));
 333                                 }
 334                         break; }
 335
 336                         case 28: {
 337                                 {
 338                                         struct ndr_pull *_ndr_info28;
 339                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 4, -1));
 340                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 341                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 4, -1));
 342                                 }
 343                         break; }
 344
 345                         case 48: {
 346                                 {
 347                                         struct ndr_pull *_ndr_info48;
 348                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 4, -1));
 349                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 350                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 4, -1));
 351                                 }
 352                         break; }
 353
 354                         default: {
 355                                 {
 356                                         struct ndr_pull *_ndr_FallBack;
 357                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 358                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 359                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 360                                 }
 361                         break; }
 362
 363                 }
 364         }
 365         if (ndr_flags & NDR_BUFFERS) {
 366                 switch (level) {
 367                         case 24:
 368                         break;
 369
 370                         case 28:
 371                         break;
 372
 373                         case 48:
 374                         break;
 375
 376                         default:
 377                         break;
 378
 379                 }
 380         }
 381         return NDR_ERR_SUCCESS;
 382 }
 383
 384 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
 385 {
 386         int level;
 387         level = ndr_print_get_switch_value(ndr, r);
 388         ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
 389         switch (level) {
 390                 case 24:
 391                         ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
 392                 break;
 393
 394                 case 28:
 395                         ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
 396                 break;
 397
 398                 case 48:
 399                         ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
 400                 break;
 401
 402                 default:
 403                         ndr_print_drsuapi_DsBindInfoFallBack(ndr, "FallBack", &r->FallBack);
 404                 break;
 405
 406         }
 407 }
 408
 409 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoCtr *r)
 410 {
 411         if (ndr_flags & NDR_SCALARS) {
 412                 NDR_CHECK(ndr_push_align(ndr, 4));
 413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 414                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
 415                 NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 416                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 417         }
 418         if (ndr_flags & NDR_BUFFERS) {
 419         }
 420         return NDR_ERR_SUCCESS;
 421 }
 422
 423 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoCtr *r)
 424 {
 425         if (ndr_flags & NDR_SCALARS) {
 426                 NDR_CHECK(ndr_pull_align(ndr, 4));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 428                 if (r->length < 1 || r->length > 10000) {
 429                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 430                 }
 431                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
 432                 NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 433                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 434         }
 435         if (ndr_flags & NDR_BUFFERS) {
 436         }
 437         return NDR_ERR_SUCCESS;
 438 }
 439
 440 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoCtr *r)
 441 {
 442         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoCtr");
 443         ndr->depth++;
 444         ndr_print_uint32(ndr, "length", r->length);
 445         ndr_print_set_switch_value(ndr, &r->info, r->length);
 446         ndr_print_drsuapi_DsBindInfo(ndr, "info", &r->info);
 447         ndr->depth--;
 448 }
 449
 450 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 451 {
 452         if (ndr_flags & NDR_SCALARS) {
 453                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
 454                 NDR_CHECK(ndr_push_align(ndr, 4));
 455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4));
 456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
 457                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 458                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
 460                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
 461                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 462         }
 463         if (ndr_flags & NDR_BUFFERS) {
 464                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier *r)
 470 {
 471         if (ndr_flags & NDR_SCALARS) {
 472                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dn));
 473                 NDR_CHECK(ndr_pull_align(ndr, 4));
 474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
 475                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
 476                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 477                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
 479                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, ndr_get_array_size(ndr, &r->dn), sizeof(uint16_t), CH_UTF16));
 480                 if (r->dn) {
 481                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
 482                 }
 483                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 484         }
 485         if (ndr_flags & NDR_BUFFERS) {
 486                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 487         }
 488         return NDR_ERR_SUCCESS;
 489 }
 490
 491 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier *r)
 492 {
 493         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier");
 494         ndr->depth++;
 495         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);
 496         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);
 497         ndr_print_GUID(ndr, "guid", &r->guid);
 498         ndr_print_dom_sid28(ndr, "sid", &r->sid);
 499         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
 500         ndr_print_string(ndr, "dn", r->dn);
 501         ndr->depth--;
 502 }
 503
 504 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, struct smb_iconv_convenience *ic, int flags)
 505 {
 506         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier, ic);
 507 }
 508
 509 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 510 {
 511         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 512         return NDR_ERR_SUCCESS;
 513 }
 514
 515 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 516 {
 517         uint32_t v;
 518         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 519         *r = v;
 520         return NDR_ERR_SUCCESS;
 521 }
 522
 523 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, const char *name, uint32_t r)
 524 {
 525         ndr_print_uint32(ndr, name, r);
 526         ndr->depth++;
 527         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION, r);
 528         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_WRITEABLE", DRSUAPI_DS_REPLICA_SYNC_WRITEABLE, r);
 529         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PERIODIC", DRSUAPI_DS_REPLICA_SYNC_PERIODIC, r);
 530         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING", DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING, r);
 531         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES", DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES, r);
 532         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL", DRSUAPI_DS_REPLICA_SYNC_FULL, r);
 533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_URGENT", DRSUAPI_DS_REPLICA_SYNC_URGENT, r);
 534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD", DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD, r);
 535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FORCE", DRSUAPI_DS_REPLICA_SYNC_FORCE, r);
 536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE", DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE, r);
 537         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED", DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED, r);
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_TWO_WAY", DRSUAPI_DS_REPLICA_SYNC_TWO_WAY, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY", DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL", DRSUAPI_DS_REPLICA_SYNC_INITIAL, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION", DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ABANDONED", DRSUAPI_DS_REPLICA_SYNC_ABANDONED, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_REQUEUE", DRSUAPI_DS_REPLICA_SYNC_REQUEUE, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION", DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_CRITICAL", DRSUAPI_DS_REPLICA_SYNC_CRITICAL, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PREEMPTED", DRSUAPI_DS_REPLICA_SYNC_PREEMPTED, r);
 551         ndr->depth--;
 552 }
 553
 554 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 555 {
 556         if (ndr_flags & NDR_SCALARS) {
 557                 NDR_CHECK(ndr_push_align(ndr, 5));
 558                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
 559                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 560                 {
 561                         uint32_t _flags_save_string = ndr->flags;
 562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 563                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
 564                         ndr->flags = _flags_save_string;
 565                 }
 566                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->options));
 567                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 568         }
 569         if (ndr_flags & NDR_BUFFERS) {
 570                 if (r->naming_context) {
 571                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 572                 }
 573                 {
 574                         uint32_t _flags_save_string = ndr->flags;
 575                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 576                         if (r->other_info) {
 577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->other_info));
 578                         }
 579                         ndr->flags = _flags_save_string;
 580                 }
 581         }
 582         return NDR_ERR_SUCCESS;
 583 }
 584
 585 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 586 {
 587         uint32_t _ptr_naming_context;
 588         TALLOC_CTX *_mem_save_naming_context_0;
 589         uint32_t _ptr_other_info;
 590         TALLOC_CTX *_mem_save_other_info_0;
 591         if (ndr_flags & NDR_SCALARS) {
 592                 NDR_CHECK(ndr_pull_align(ndr, 5));
 593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
 594                 if (_ptr_naming_context) {
 595                         NDR_PULL_ALLOC(ndr, r->naming_context);
 596                 } else {
 597                         r->naming_context = NULL;
 598                 }
 599                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 600                 {
 601                         uint32_t _flags_save_string = ndr->flags;
 602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 603                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 604                         if (_ptr_other_info) {
 605                                 NDR_PULL_ALLOC(ndr, r->other_info);
 606                         } else {
 607                                 r->other_info = NULL;
 608                         }
 609                         ndr->flags = _flags_save_string;
 610                 }
 611                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->options));
 612                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 613         }
 614         if (ndr_flags & NDR_BUFFERS) {
 615                 if (r->naming_context) {
 616                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 617                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 618                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 620                 }
 621                 {
 622                         uint32_t _flags_save_string = ndr->flags;
 623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 624                         if (r->other_info) {
 625                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 626                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 627                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->other_info));
 628                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 629                         }
 630                         ndr->flags = _flags_save_string;
 631                 }
 632         }
 633         return NDR_ERR_SUCCESS;
 634 }
 635
 636 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 637 {
 638         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 639         ndr->depth++;
 640         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 641         ndr->depth++;
 642         if (r->naming_context) {
 643                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 644         }
 645         ndr->depth--;
 646         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 647         ndr_print_ptr(ndr, "other_info", r->other_info);
 648         ndr->depth++;
 649         if (r->other_info) {
 650                 ndr_print_string(ndr, "other_info", r->other_info);
 651         }
 652         ndr->depth--;
 653         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "options", r->options);
 654         ndr->depth--;
 655 }
 656
 657 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 658 {
 659         if (ndr_flags & NDR_SCALARS) {
 660                 int level = ndr_push_get_switch_value(ndr, r);
 661                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
 662                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 663                 switch (level) {
 664                         case 1: {
 665                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 666                         break; }
 667
 668                         default:
 669                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 670                 }
 671         }
 672         if (ndr_flags & NDR_BUFFERS) {
 673                 int level = ndr_push_get_switch_value(ndr, r);
 674                 switch (level) {
 675                         case 1:
 676                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 677                         break;
 678
 679                         default:
 680                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 681                 }
 682         }
 683         return NDR_ERR_SUCCESS;
 684 }
 685
 686 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaSyncRequest *r)
 687 {
 688         int level;
 689         int32_t _level;
 690         level = ndr_pull_get_switch_value(ndr, r);
 691         if (ndr_flags & NDR_SCALARS) {
 692                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
 693                 if (_level != level) {
 694                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 695                 }
 696                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 697                 switch (level) {
 698                         case 1: {
 699                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 700                         break; }
 701
 702                         default:
 703                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 704                 }
 705         }
 706         if (ndr_flags & NDR_BUFFERS) {
 707                 switch (level) {
 708                         case 1:
 709                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 710                         break;
 711
 712                         default:
 713                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 714                 }
 715         }
 716         return NDR_ERR_SUCCESS;
 717 }
 718
 719 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 720 {
 721         int level;
 722         level = ndr_print_get_switch_value(ndr, r);
 723         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 724         switch (level) {
 725                 case 1:
 726                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 727                 break;
 728
 729                 default:
 730                         ndr_print_bad_level(ndr, name, level);
 731         }
 732 }
 733
 734 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 735 {
 736         if (ndr_flags & NDR_SCALARS) {
 737                 NDR_CHECK(ndr_push_align(ndr, 8));
 738                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 739                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 740                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 741                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 742         }
 743         if (ndr_flags & NDR_BUFFERS) {
 744         }
 745         return NDR_ERR_SUCCESS;
 746 }
 747
 748 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 749 {
 750         if (ndr_flags & NDR_SCALARS) {
 751                 NDR_CHECK(ndr_pull_align(ndr, 8));
 752                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 753                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 754                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 755                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 756         }
 757         if (ndr_flags & NDR_BUFFERS) {
 758         }
 759         return NDR_ERR_SUCCESS;
 760 }
 761
 762 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 763 {
 764         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 765         ndr->depth++;
 766         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 767         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 768         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 769         ndr->depth--;
 770 }
 771
 772 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 773 {
 774         if (ndr_flags & NDR_SCALARS) {
 775                 NDR_CHECK(ndr_push_align(ndr, 8));
 776                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 777                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 778                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 779         }
 780         if (ndr_flags & NDR_BUFFERS) {
 781         }
 782         return NDR_ERR_SUCCESS;
 783 }
 784
 785 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 786 {
 787         if (ndr_flags & NDR_SCALARS) {
 788                 NDR_CHECK(ndr_pull_align(ndr, 8));
 789                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 790                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 791                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 792         }
 793         if (ndr_flags & NDR_BUFFERS) {
 794         }
 795         return NDR_ERR_SUCCESS;
 796 }
 797
 798 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 799 {
 800         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 801         ndr->depth++;
 802         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 803         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 804         ndr->depth--;
 805 }
 806
 807 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 808 {
 809         uint32_t cntr_cursors_0;
 810         if (ndr_flags & NDR_SCALARS) {
 811                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 812                 NDR_CHECK(ndr_push_align(ndr, 8));
 813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 817                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 818                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 819                 }
 820                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 821         }
 822         if (ndr_flags & NDR_BUFFERS) {
 823         }
 824         return NDR_ERR_SUCCESS;
 825 }
 826
 827 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 828 {
 829         uint32_t cntr_cursors_0;
 830         TALLOC_CTX *_mem_save_cursors_0;
 831         if (ndr_flags & NDR_SCALARS) {
 832                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 833                 NDR_CHECK(ndr_pull_align(ndr, 8));
 834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 837                 if (r->count > 0x100000) {
 838                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 839                 }
 840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 841                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
 842                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 843                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 844                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 845                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 846                 }
 847                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 848                 if (r->cursors) {
 849                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 850                 }
 851                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 852         }
 853         if (ndr_flags & NDR_BUFFERS) {
 854         }
 855         return NDR_ERR_SUCCESS;
 856 }
 857
 858 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 859 {
 860         uint32_t cntr_cursors_0;
 861         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 862         ndr->depth++;
 863         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 864         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 865         ndr_print_uint32(ndr, "count", r->count);
 866         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 867         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 868         ndr->depth++;
 869         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 870                 char *idx_0=NULL;
 871                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 872                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 873                         free(idx_0);
 874                 }
 875         }
 876         ndr->depth--;
 877         ndr->depth--;
 878 }
 879
 880 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 881 {
 882         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 887 {
 888         uint32_t v;
 889         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 890         *r = v;
 891         return NDR_ERR_SUCCESS;
 892 }
 893
 894 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 895 {
 896         ndr_print_uint32(ndr, name, r);
 897         ndr->depth++;
 898         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE", DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE, r);
 899         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP", DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP, r);
 900         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS", DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS, r);
 901         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);
 902         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP", DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP, r);
 903         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_ERROR", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_ERROR, r);
 904         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC, r);
 905         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY", DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY, r);
 906         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS", DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS, r);
 907         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS, r);
 908         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET, r);
 909         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED", DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED, r);
 910         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING", DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING, r);
 911         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED", DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED, r);
 912         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS, r);
 913         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC, r);
 914         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES", DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES, r);
 915         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS, r);
 916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET, r);
 917         ndr->depth--;
 918 }
 919
 920 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 921 {
 922         {
 923                 uint32_t _flags_save_ENUM = ndr->flags;
 924                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 925                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 926                 ndr->flags = _flags_save_ENUM;
 927         }
 928         return NDR_ERR_SUCCESS;
 929 }
 930
 931 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 932 {
 933         uint32_t v;
 934         {
 935                 uint32_t _flags_save_ENUM = ndr->flags;
 936                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 937                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 938                 *r = v;
 939                 ndr->flags = _flags_save_ENUM;
 940         }
 941         return NDR_ERR_SUCCESS;
 942 }
 943
 944 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 945 {
 946         const char *val = NULL;
 947
 948         {
 949                 uint32_t _flags_save_ENUM = ndr->flags;
 950                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 951                 switch (r) {
 952                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
 953                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
 954                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
 955                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
 956                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
 957                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
 958                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
 959                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
 960                 }
 961                 ndr_print_enum(ndr, name, "ENUM", val, r);
 962                 ndr->flags = _flags_save_ENUM;
 963         }
 964 }
 965
 966 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
 967 {
 968         {
 969                 uint32_t _flags_save_ENUM = ndr->flags;
 970                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 971                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 972                 ndr->flags = _flags_save_ENUM;
 973         }
 974         return NDR_ERR_SUCCESS;
 975 }
 976
 977 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
 978 {
 979         uint32_t v;
 980         {
 981                 uint32_t _flags_save_ENUM = ndr->flags;
 982                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 983                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 984                 *r = v;
 985                 ndr->flags = _flags_save_ENUM;
 986         }
 987         return NDR_ERR_SUCCESS;
 988 }
 989
 990 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
 991 {
 992         const char *val = NULL;
 993
 994         {
 995                 uint32_t _flags_save_ENUM = ndr->flags;
 996                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 997                 switch (r) {
 998                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
 999                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
1000                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
1001                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
1002                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
1003                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
1004                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
1005                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
1006                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
1007                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
1008                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
1009                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
1010                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
1011                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
1012                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
1013                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
1014                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
1015                 }
1016                 ndr_print_enum(ndr, name, "ENUM", val, r);
1017                 ndr->flags = _flags_save_ENUM;
1018         }
1019 }
1020
1021 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
1022 {
1023         if (ndr_flags & NDR_SCALARS) {
1024                 NDR_CHECK(ndr_push_align(ndr, 8));
1025                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1026                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1027                 if (r->naming_context == NULL) {
1028                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1029                 }
1030                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1031                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1033                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1036                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1037                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1038                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1039         }
1040         if (ndr_flags & NDR_BUFFERS) {
1041                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1042                 if (r->uptodateness_vector) {
1043                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1044                 }
1045         }
1046         return NDR_ERR_SUCCESS;
1047 }
1048
1049 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1050 {
1051         uint32_t _ptr_naming_context;
1052         TALLOC_CTX *_mem_save_naming_context_0;
1053         uint32_t _ptr_uptodateness_vector;
1054         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1055         if (ndr_flags & NDR_SCALARS) {
1056                 NDR_CHECK(ndr_pull_align(ndr, 8));
1057                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1058                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1059                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1060                 if (_ptr_naming_context) {
1061                         NDR_PULL_ALLOC(ndr, r->naming_context);
1062                 } else {
1063                         r->naming_context = NULL;
1064                 }
1065                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1066                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1067                 if (_ptr_uptodateness_vector) {
1068                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1069                 } else {
1070                         r->uptodateness_vector = NULL;
1071                 }
1072                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1075                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1076                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1077                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1078         }
1079         if (ndr_flags & NDR_BUFFERS) {
1080                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1081                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1082                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1083                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1084                 if (r->uptodateness_vector) {
1085                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1086                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1087                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1088                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1089                 }
1090         }
1091         return NDR_ERR_SUCCESS;
1092 }
1093
1094 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1095 {
1096         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1097         ndr->depth++;
1098         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1099         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1100         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1101         ndr->depth++;
1102         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1103         ndr->depth--;
1104         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1105         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1106         ndr->depth++;
1107         if (r->uptodateness_vector) {
1108                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1109         }
1110         ndr->depth--;
1111         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1112         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1113         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1114         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1115         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1116         ndr->depth--;
1117 }
1118
1119 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
1120 {
1121         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
1122         ndr->depth++;
1123         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaOID_oid(r->oid, 0):r->__ndr_size);
1124         ndr_print_ptr(ndr, "oid", r->oid);
1125         ndr->depth++;
1126         if (r->oid) {
1127                 ndr_print_string(ndr, "oid", r->oid);
1128         }
1129         ndr->depth--;
1130         ndr->depth--;
1131 }
1132
1133 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1134 {
1135         if (ndr_flags & NDR_SCALARS) {
1136                 NDR_CHECK(ndr_push_align(ndr, 5));
1137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1138                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1139                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1140         }
1141         if (ndr_flags & NDR_BUFFERS) {
1142                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1143         }
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1148 {
1149         if (ndr_flags & NDR_SCALARS) {
1150                 NDR_CHECK(ndr_pull_align(ndr, 5));
1151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1152                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1153                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1154         }
1155         if (ndr_flags & NDR_BUFFERS) {
1156                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1157         }
1158         return NDR_ERR_SUCCESS;
1159 }
1160
1161 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1162 {
1163         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1164         ndr->depth++;
1165         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1166         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1167         ndr->depth--;
1168 }
1169
1170 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1171 {
1172         uint32_t cntr_mappings_1;
1173         if (ndr_flags & NDR_SCALARS) {
1174                 NDR_CHECK(ndr_push_align(ndr, 5));
1175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1176                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1177                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1178         }
1179         if (ndr_flags & NDR_BUFFERS) {
1180                 if (r->mappings) {
1181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
1182                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1183                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1184                         }
1185                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1186                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1187                         }
1188                 }
1189         }
1190         return NDR_ERR_SUCCESS;
1191 }
1192
1193 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1194 {
1195         uint32_t _ptr_mappings;
1196         uint32_t cntr_mappings_1;
1197         TALLOC_CTX *_mem_save_mappings_0;
1198         TALLOC_CTX *_mem_save_mappings_1;
1199         if (ndr_flags & NDR_SCALARS) {
1200                 NDR_CHECK(ndr_pull_align(ndr, 5));
1201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1202                 if (r->num_mappings > 0x100000) {
1203                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1204                 }
1205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1206                 if (_ptr_mappings) {
1207                         NDR_PULL_ALLOC(ndr, r->mappings);
1208                 } else {
1209                         r->mappings = NULL;
1210                 }
1211                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1212         }
1213         if (ndr_flags & NDR_BUFFERS) {
1214                 if (r->mappings) {
1215                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1216                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1217                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1218                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1219                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1220                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1221                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1222                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1223                         }
1224                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1225                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1226                         }
1227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1229                 }
1230                 if (r->mappings) {
1231                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1232                 }
1233         }
1234         return NDR_ERR_SUCCESS;
1235 }
1236
1237 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1238 {
1239         uint32_t cntr_mappings_1;
1240         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1241         ndr->depth++;
1242         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1243         ndr_print_ptr(ndr, "mappings", r->mappings);
1244         ndr->depth++;
1245         if (r->mappings) {
1246                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1247                 ndr->depth++;
1248                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1249                         char *idx_1=NULL;
1250                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1251                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1252                                 free(idx_1);
1253                         }
1254                 }
1255                 ndr->depth--;
1256         }
1257         ndr->depth--;
1258         ndr->depth--;
1259 }
1260
1261 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1262 {
1263         {
1264                 uint32_t _flags_save_ENUM = ndr->flags;
1265                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1266                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1267                 ndr->flags = _flags_save_ENUM;
1268         }
1269         return NDR_ERR_SUCCESS;
1270 }
1271
1272 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1273 {
1274         uint32_t v;
1275         {
1276                 uint32_t _flags_save_ENUM = ndr->flags;
1277                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1278                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1279                 *r = v;
1280                 ndr->flags = _flags_save_ENUM;
1281         }
1282         return NDR_ERR_SUCCESS;
1283 }
1284
1285 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1286 {
1287         const char *val = NULL;
1288
1289         {
1290                 uint32_t _flags_save_ENUM = ndr->flags;
1291                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1292                 switch (r) {
1293                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1294                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1295                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1296                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1297                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1298                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1299                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1300                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1301                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1302                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1303                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1304                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1305                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1306                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1307                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1308                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1309                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1310                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1311                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1312                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1313                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1314                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1315                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1316                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1317                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1318                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1319                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1320                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1321                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1322                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1323                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1324                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1325                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1326                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1327                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1328                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1329                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1330                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1331                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1332                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1333                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1334                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1335                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1336                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1337                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1338                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1339                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1340                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1341                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1342                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1343                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1344                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1345                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1346                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1347                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1348                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1349                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1350                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1351                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1352                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1353                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1354                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1355                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1356                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1357                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1358                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1359                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1360                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1361                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1362                 }
1363                 ndr_print_enum(ndr, name, "ENUM", val, r);
1364                 ndr->flags = _flags_save_ENUM;
1365         }
1366 }
1367
1368 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1369 {
1370         uint32_t cntr_attids_0;
1371         if (ndr_flags & NDR_SCALARS) {
1372                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1373                 NDR_CHECK(ndr_push_align(ndr, 4));
1374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1377                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1378                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1379                 }
1380                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1381         }
1382         if (ndr_flags & NDR_BUFFERS) {
1383         }
1384         return NDR_ERR_SUCCESS;
1385 }
1386
1387 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1388 {
1389         uint32_t cntr_attids_0;
1390         TALLOC_CTX *_mem_save_attids_0;
1391         if (ndr_flags & NDR_SCALARS) {
1392                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1393                 NDR_CHECK(ndr_pull_align(ndr, 4));
1394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1397                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1398                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1399                 }
1400                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1401                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1402                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1403                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1404                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1405                 }
1406                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1407                 if (r->attids) {
1408                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1409                 }
1410                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1411         }
1412         if (ndr_flags & NDR_BUFFERS) {
1413         }
1414         return NDR_ERR_SUCCESS;
1415 }
1416
1417 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1418 {
1419         uint32_t cntr_attids_0;
1420         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1421         ndr->depth++;
1422         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1423         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1424         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1425         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1426         ndr->depth++;
1427         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1428                 char *idx_0=NULL;
1429                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1430                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1431                         free(idx_0);
1432                 }
1433         }
1434         ndr->depth--;
1435         ndr->depth--;
1436 }
1437
1438 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1439 {
1440         if (ndr_flags & NDR_SCALARS) {
1441                 NDR_CHECK(ndr_push_align(ndr, 8));
1442                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1443                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1444                 if (r->naming_context == NULL) {
1445                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1446                 }
1447                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1448                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1450                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1453                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1454                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1455                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1456                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1457                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1458                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1459         }
1460         if (ndr_flags & NDR_BUFFERS) {
1461                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1462                 if (r->uptodateness_vector) {
1463                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1464                 }
1465                 if (r->partial_attribute_set) {
1466                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1467                 }
1468                 if (r->partial_attribute_set_ex) {
1469                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1470                 }
1471                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1472         }
1473         return NDR_ERR_SUCCESS;
1474 }
1475
1476 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1477 {
1478         uint32_t _ptr_naming_context;
1479         TALLOC_CTX *_mem_save_naming_context_0;
1480         uint32_t _ptr_uptodateness_vector;
1481         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1482         uint32_t _ptr_partial_attribute_set;
1483         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1484         uint32_t _ptr_partial_attribute_set_ex;
1485         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1486         if (ndr_flags & NDR_SCALARS) {
1487                 NDR_CHECK(ndr_pull_align(ndr, 8));
1488                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1489                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1490                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1491                 if (_ptr_naming_context) {
1492                         NDR_PULL_ALLOC(ndr, r->naming_context);
1493                 } else {
1494                         r->naming_context = NULL;
1495                 }
1496                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1498                 if (_ptr_uptodateness_vector) {
1499                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1500                 } else {
1501                         r->uptodateness_vector = NULL;
1502                 }
1503                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1506                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1507                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1509                 if (_ptr_partial_attribute_set) {
1510                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1511                 } else {
1512                         r->partial_attribute_set = NULL;
1513                 }
1514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1515                 if (_ptr_partial_attribute_set_ex) {
1516                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1517                 } else {
1518                         r->partial_attribute_set_ex = NULL;
1519                 }
1520                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1521                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1522         }
1523         if (ndr_flags & NDR_BUFFERS) {
1524                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1525                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1526                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1528                 if (r->uptodateness_vector) {
1529                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1530                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1531                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1533                 }
1534                 if (r->partial_attribute_set) {
1535                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1536                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1537                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1539                 }
1540                 if (r->partial_attribute_set_ex) {
1541                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1542                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1543                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1545                 }
1546                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1547         }
1548         return NDR_ERR_SUCCESS;
1549 }
1550
1551 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1552 {
1553         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1554         ndr->depth++;
1555         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1556         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1557         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1558         ndr->depth++;
1559         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1560         ndr->depth--;
1561         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1562         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1563         ndr->depth++;
1564         if (r->uptodateness_vector) {
1565                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1566         }
1567         ndr->depth--;
1568         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1569         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1570         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1571         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1572         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1573         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1574         ndr->depth++;
1575         if (r->partial_attribute_set) {
1576                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1577         }
1578         ndr->depth--;
1579         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1580         ndr->depth++;
1581         if (r->partial_attribute_set_ex) {
1582                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1583         }
1584         ndr->depth--;
1585         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1586         ndr->depth--;
1587 }
1588
1589 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1590 {
1591         if (ndr_flags & NDR_SCALARS) {
1592                 NDR_CHECK(ndr_push_align(ndr, 8));
1593                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1594                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1595                 if (r->naming_context == NULL) {
1596                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1597                 }
1598                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1599                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1601                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1604                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1605                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1608                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1610                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1611         }
1612         if (ndr_flags & NDR_BUFFERS) {
1613                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1614                 if (r->uptodateness_vector) {
1615                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1616                 }
1617                 if (r->partial_attribute_set) {
1618                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1619                 }
1620                 if (r->partial_attribute_set_ex) {
1621                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1622                 }
1623                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1624         }
1625         return NDR_ERR_SUCCESS;
1626 }
1627
1628 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1629 {
1630         uint32_t _ptr_naming_context;
1631         TALLOC_CTX *_mem_save_naming_context_0;
1632         uint32_t _ptr_uptodateness_vector;
1633         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1634         uint32_t _ptr_partial_attribute_set;
1635         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1636         uint32_t _ptr_partial_attribute_set_ex;
1637         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1638         if (ndr_flags & NDR_SCALARS) {
1639                 NDR_CHECK(ndr_pull_align(ndr, 8));
1640                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1641                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1642                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1643                 if (_ptr_naming_context) {
1644                         NDR_PULL_ALLOC(ndr, r->naming_context);
1645                 } else {
1646                         r->naming_context = NULL;
1647                 }
1648                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1649                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1650                 if (_ptr_uptodateness_vector) {
1651                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1652                 } else {
1653                         r->uptodateness_vector = NULL;
1654                 }
1655                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1658                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1659                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1661                 if (_ptr_partial_attribute_set) {
1662                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1663                 } else {
1664                         r->partial_attribute_set = NULL;
1665                 }
1666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1667                 if (_ptr_partial_attribute_set_ex) {
1668                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1669                 } else {
1670                         r->partial_attribute_set_ex = NULL;
1671                 }
1672                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1674                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1675         }
1676         if (ndr_flags & NDR_BUFFERS) {
1677                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1678                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1679                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1681                 if (r->uptodateness_vector) {
1682                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1683                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1684                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1686                 }
1687                 if (r->partial_attribute_set) {
1688                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1689                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1690                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1692                 }
1693                 if (r->partial_attribute_set_ex) {
1694                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1695                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1696                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1698                 }
1699                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1700         }
1701         return NDR_ERR_SUCCESS;
1702 }
1703
1704 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1705 {
1706         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1707         ndr->depth++;
1708         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1709         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1710         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1711         ndr->depth++;
1712         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1713         ndr->depth--;
1714         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1715         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1716         ndr->depth++;
1717         if (r->uptodateness_vector) {
1718                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1719         }
1720         ndr->depth--;
1721         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1722         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1723         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1724         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1725         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1726         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1727         ndr->depth++;
1728         if (r->partial_attribute_set) {
1729                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1730         }
1731         ndr->depth--;
1732         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1733         ndr->depth++;
1734         if (r->partial_attribute_set_ex) {
1735                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1736         }
1737         ndr->depth--;
1738         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1739         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1740         ndr->depth--;
1741 }
1742
1743 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1744 {
1745         if (ndr_flags & NDR_SCALARS) {
1746                 int level = ndr_push_get_switch_value(ndr, r);
1747                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1748                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1749                 switch (level) {
1750                         case 5: {
1751                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1752                         break; }
1753
1754                         case 8: {
1755                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1756                         break; }
1757
1758                         case 10: {
1759                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1760                         break; }
1761
1762                         default:
1763                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1764                 }
1765         }
1766         if (ndr_flags & NDR_BUFFERS) {
1767                 int level = ndr_push_get_switch_value(ndr, r);
1768                 switch (level) {
1769                         case 5:
1770                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1771                         break;
1772
1773                         case 8:
1774                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1775                         break;
1776
1777                         case 10:
1778                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1779                         break;
1780
1781                         default:
1782                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1783                 }
1784         }
1785         return NDR_ERR_SUCCESS;
1786 }
1787
1788 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1789 {
1790         int level;
1791         int32_t _level;
1792         level = ndr_pull_get_switch_value(ndr, r);
1793         if (ndr_flags & NDR_SCALARS) {
1794                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1795                 if (_level != level) {
1796                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1797                 }
1798                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1799                 switch (level) {
1800                         case 5: {
1801                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1802                         break; }
1803
1804                         case 8: {
1805                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1806                         break; }
1807
1808                         case 10: {
1809                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1810                         break; }
1811
1812                         default:
1813                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1814                 }
1815         }
1816         if (ndr_flags & NDR_BUFFERS) {
1817                 switch (level) {
1818                         case 5:
1819                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1820                         break;
1821
1822                         case 8:
1823                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1824                         break;
1825
1826                         case 10:
1827                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1828                         break;
1829
1830                         default:
1831                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1832                 }
1833         }
1834         return NDR_ERR_SUCCESS;
1835 }
1836
1837 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1838 {
1839         int level;
1840         level = ndr_print_get_switch_value(ndr, r);
1841         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1842         switch (level) {
1843                 case 5:
1844                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1845                 break;
1846
1847                 case 8:
1848                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1849                 break;
1850
1851                 case 10:
1852                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1853                 break;
1854
1855                 default:
1856                         ndr_print_bad_level(ndr, name, level);
1857         }
1858 }
1859
1860 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1861 {
1862         if (ndr_flags & NDR_SCALARS) {
1863                 NDR_CHECK(ndr_push_align(ndr, 8));
1864                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1865                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1866                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1867                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1868         }
1869         if (ndr_flags & NDR_BUFFERS) {
1870         }
1871         return NDR_ERR_SUCCESS;
1872 }
1873
1874 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1875 {
1876         if (ndr_flags & NDR_SCALARS) {
1877                 NDR_CHECK(ndr_pull_align(ndr, 8));
1878                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1879                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1880                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1881                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1882         }
1883         if (ndr_flags & NDR_BUFFERS) {
1884         }
1885         return NDR_ERR_SUCCESS;
1886 }
1887
1888 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1889 {
1890         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1891         ndr->depth++;
1892         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1893         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1894         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1895         ndr->depth--;
1896 }
1897
1898 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1899 {
1900         uint32_t cntr_cursors_0;
1901         if (ndr_flags & NDR_SCALARS) {
1902                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1903                 NDR_CHECK(ndr_push_align(ndr, 8));
1904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1908                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1909                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1910                 }
1911                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1912         }
1913         if (ndr_flags & NDR_BUFFERS) {
1914         }
1915         return NDR_ERR_SUCCESS;
1916 }
1917
1918 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1919 {
1920         uint32_t cntr_cursors_0;
1921         TALLOC_CTX *_mem_save_cursors_0;
1922         if (ndr_flags & NDR_SCALARS) {
1923                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1924                 NDR_CHECK(ndr_pull_align(ndr, 8));
1925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1928                 if (r->count > 0x100000) {
1929                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1930                 }
1931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1932                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1933                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1934                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1935                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1936                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1937                 }
1938                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
1939                 if (r->cursors) {
1940                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
1941                 }
1942                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1943         }
1944         if (ndr_flags & NDR_BUFFERS) {
1945         }
1946         return NDR_ERR_SUCCESS;
1947 }
1948
1949 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1950 {
1951         uint32_t cntr_cursors_0;
1952         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
1953         ndr->depth++;
1954         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
1955         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1956         ndr_print_uint32(ndr, "count", r->count);
1957         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
1958         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
1959         ndr->depth++;
1960         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
1961                 char *idx_0=NULL;
1962                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
1963                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
1964                         free(idx_0);
1965                 }
1966         }
1967         ndr->depth--;
1968         ndr->depth--;
1969 }
1970
1971 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
1972 {
1973         if (ndr_flags & NDR_SCALARS) {
1974                 NDR_CHECK(ndr_push_align(ndr, 5));
1975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
1976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
1977                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1978         }
1979         if (ndr_flags & NDR_BUFFERS) {
1980                 if (r->blob) {
1981                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
1982                 }
1983         }
1984         return NDR_ERR_SUCCESS;
1985 }
1986
1987 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
1988 {
1989         uint32_t _ptr_blob;
1990         TALLOC_CTX *_mem_save_blob_0;
1991         if (ndr_flags & NDR_SCALARS) {
1992                 NDR_CHECK(ndr_pull_align(ndr, 5));
1993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1994                 if (r->__ndr_size > 10485760) {
1995                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1996                 }
1997                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
1998                 if (_ptr_blob) {
1999                         NDR_PULL_ALLOC(ndr, r->blob);
2000                 } else {
2001                         r->blob = NULL;
2002                 }
2003                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2004         }
2005         if (ndr_flags & NDR_BUFFERS) {
2006                 if (r->blob) {
2007                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2008                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2009                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2011                 }
2012         }
2013         return NDR_ERR_SUCCESS;
2014 }
2015
2016 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2017 {
2018         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2019         ndr->depth++;
2020         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2021         ndr_print_ptr(ndr, "blob", r->blob);
2022         ndr->depth++;
2023         if (r->blob) {
2024                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2025         }
2026         ndr->depth--;
2027         ndr->depth--;
2028 }
2029
2030 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2031 {
2032         uint32_t cntr_values_1;
2033         if (ndr_flags & NDR_SCALARS) {
2034                 NDR_CHECK(ndr_push_align(ndr, 5));
2035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2037                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2038         }
2039         if (ndr_flags & NDR_BUFFERS) {
2040                 if (r->values) {
2041                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2042                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2043                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2044                         }
2045                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2046                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2047                         }
2048                 }
2049         }
2050         return NDR_ERR_SUCCESS;
2051 }
2052
2053 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2054 {
2055         uint32_t _ptr_values;
2056         uint32_t cntr_values_1;
2057         TALLOC_CTX *_mem_save_values_0;
2058         TALLOC_CTX *_mem_save_values_1;
2059         if (ndr_flags & NDR_SCALARS) {
2060                 NDR_CHECK(ndr_pull_align(ndr, 5));
2061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2062                 if (r->num_values > 10485760) {
2063                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2064                 }
2065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2066                 if (_ptr_values) {
2067                         NDR_PULL_ALLOC(ndr, r->values);
2068                 } else {
2069                         r->values = NULL;
2070                 }
2071                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2072         }
2073         if (ndr_flags & NDR_BUFFERS) {
2074                 if (r->values) {
2075                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2076                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2077                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2078                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2079                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2080                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2081                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2082                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2083                         }
2084                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2085                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2086                         }
2087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2088                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2089                 }
2090                 if (r->values) {
2091                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2092                 }
2093         }
2094         return NDR_ERR_SUCCESS;
2095 }
2096
2097 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2098 {
2099         uint32_t cntr_values_1;
2100         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2101         ndr->depth++;
2102         ndr_print_uint32(ndr, "num_values", r->num_values);
2103         ndr_print_ptr(ndr, "values", r->values);
2104         ndr->depth++;
2105         if (r->values) {
2106                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2107                 ndr->depth++;
2108                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2109                         char *idx_1=NULL;
2110                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2111                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2112                                 free(idx_1);
2113                         }
2114                 }
2115                 ndr->depth--;
2116         }
2117         ndr->depth--;
2118         ndr->depth--;
2119 }
2120
2121 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2122 {
2123         if (ndr_flags & NDR_SCALARS) {
2124                 NDR_CHECK(ndr_push_align(ndr, 4));
2125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2127                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2128                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2130                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2131                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2132         }
2133         if (ndr_flags & NDR_BUFFERS) {
2134                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2135         }
2136         return NDR_ERR_SUCCESS;
2137 }
2138
2139 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2140 {
2141         if (ndr_flags & NDR_SCALARS) {
2142                 NDR_CHECK(ndr_pull_align(ndr, 4));
2143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2145                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2146                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2148                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2149                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2150         }
2151         if (ndr_flags & NDR_BUFFERS) {
2152                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2153         }
2154         return NDR_ERR_SUCCESS;
2155 }
2156
2157 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2158 {
2159         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2160         ndr->depth++;
2161         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);
2162         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);
2163         ndr_print_GUID(ndr, "guid", &r->guid);
2164         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2165         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2166         ndr_print_string(ndr, "dn", r->dn);
2167         ndr->depth--;
2168 }
2169
2170 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2171 {
2172         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2173 }
2174
2175 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2176 {
2177         if (ndr_flags & NDR_SCALARS) {
2178                 NDR_CHECK(ndr_push_align(ndr, 4));
2179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2181                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2182                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2184                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2186                 {
2187                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2189                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2190                         ndr->flags = _flags_save_DATA_BLOB;
2191                 }
2192                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2193         }
2194         if (ndr_flags & NDR_BUFFERS) {
2195                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2196         }
2197         return NDR_ERR_SUCCESS;
2198 }
2199
2200 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2201 {
2202         if (ndr_flags & NDR_SCALARS) {
2203                 NDR_CHECK(ndr_pull_align(ndr, 4));
2204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2206                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2207                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2209                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2211                 {
2212                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2214                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2215                         ndr->flags = _flags_save_DATA_BLOB;
2216                 }
2217                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2218         }
2219         if (ndr_flags & NDR_BUFFERS) {
2220                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2221         }
2222         return NDR_ERR_SUCCESS;
2223 }
2224
2225 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2226 {
2227         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2228         ndr->depth++;
2229         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);
2230         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);
2231         ndr_print_GUID(ndr, "guid", &r->guid);
2232         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2233         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2234         ndr_print_string(ndr, "dn", r->dn);
2235         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2236         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2237         ndr->depth--;
2238 }
2239
2240 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, struct smb_iconv_convenience *ic, int flags)
2241 {
2242         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary, ic);
2243 }
2244
2245 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2246 {
2247         if (ndr_flags & NDR_SCALARS) {
2248                 NDR_CHECK(ndr_push_align(ndr, 5));
2249                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2250                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2251                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2252         }
2253         if (ndr_flags & NDR_BUFFERS) {
2254                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2255         }
2256         return NDR_ERR_SUCCESS;
2257 }
2258
2259 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2260 {
2261         if (ndr_flags & NDR_SCALARS) {
2262                 NDR_CHECK(ndr_pull_align(ndr, 5));
2263                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2264                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2265                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2266         }
2267         if (ndr_flags & NDR_BUFFERS) {
2268                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2269         }
2270         return NDR_ERR_SUCCESS;
2271 }
2272
2273 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2274 {
2275         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2276         ndr->depth++;
2277         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2278         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2279         ndr->depth--;
2280 }
2281
2282 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2283 {
2284         uint32_t cntr_attributes_1;
2285         if (ndr_flags & NDR_SCALARS) {
2286                 NDR_CHECK(ndr_push_align(ndr, 5));
2287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2289                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2290         }
2291         if (ndr_flags & NDR_BUFFERS) {
2292                 if (r->attributes) {
2293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2294                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2295                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2296                         }
2297                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2298                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2299                         }
2300                 }
2301         }
2302         return NDR_ERR_SUCCESS;
2303 }
2304
2305 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2306 {
2307         uint32_t _ptr_attributes;
2308         uint32_t cntr_attributes_1;
2309         TALLOC_CTX *_mem_save_attributes_0;
2310         TALLOC_CTX *_mem_save_attributes_1;
2311         if (ndr_flags & NDR_SCALARS) {
2312                 NDR_CHECK(ndr_pull_align(ndr, 5));
2313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2314                 if (r->num_attributes > 1048576) {
2315                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2316                 }
2317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2318                 if (_ptr_attributes) {
2319                         NDR_PULL_ALLOC(ndr, r->attributes);
2320                 } else {
2321                         r->attributes = NULL;
2322                 }
2323                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2324         }
2325         if (ndr_flags & NDR_BUFFERS) {
2326                 if (r->attributes) {
2327                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2328                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2330                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2331                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2332                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2333                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2334                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2335                         }
2336                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2337                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2338                         }
2339                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2341                 }
2342                 if (r->attributes) {
2343                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2344                 }
2345         }
2346         return NDR_ERR_SUCCESS;
2347 }
2348
2349 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2350 {
2351         uint32_t cntr_attributes_1;
2352         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2353         ndr->depth++;
2354         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2355         ndr_print_ptr(ndr, "attributes", r->attributes);
2356         ndr->depth++;
2357         if (r->attributes) {
2358                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2359                 ndr->depth++;
2360                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2361                         char *idx_1=NULL;
2362                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2363                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2364                                 free(idx_1);
2365                         }
2366                 }
2367                 ndr->depth--;
2368         }
2369         ndr->depth--;
2370         ndr->depth--;
2371 }
2372
2373 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2374 {
2375         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2376         return NDR_ERR_SUCCESS;
2377 }
2378
2379 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2380 {
2381         uint32_t v;
2382         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2383         *r = v;
2384         return NDR_ERR_SUCCESS;
2385 }
2386
2387 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2388 {
2389         ndr_print_uint32(ndr, name, r);
2390         ndr->depth++;
2391         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2392         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2393         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2394         ndr->depth--;
2395 }
2396
2397 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2398 {
2399         if (ndr_flags & NDR_SCALARS) {
2400                 NDR_CHECK(ndr_push_align(ndr, 5));
2401                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2402                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2403                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2404                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2405         }
2406         if (ndr_flags & NDR_BUFFERS) {
2407                 if (r->identifier) {
2408                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2409                 }
2410                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2411         }
2412         return NDR_ERR_SUCCESS;
2413 }
2414
2415 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2416 {
2417         uint32_t _ptr_identifier;
2418         TALLOC_CTX *_mem_save_identifier_0;
2419         if (ndr_flags & NDR_SCALARS) {
2420                 NDR_CHECK(ndr_pull_align(ndr, 5));
2421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2422                 if (_ptr_identifier) {
2423                         NDR_PULL_ALLOC(ndr, r->identifier);
2424                 } else {
2425                         r->identifier = NULL;
2426                 }
2427                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2428                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2429                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2430         }
2431         if (ndr_flags & NDR_BUFFERS) {
2432                 if (r->identifier) {
2433                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2434                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2435                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2437                 }
2438                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2439         }
2440         return NDR_ERR_SUCCESS;
2441 }
2442
2443 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2444 {
2445         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2446         ndr->depth++;
2447         ndr_print_ptr(ndr, "identifier", r->identifier);
2448         ndr->depth++;
2449         if (r->identifier) {
2450                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2451         }
2452         ndr->depth--;
2453         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2454         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2455         ndr->depth--;
2456 }
2457
2458 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2459 {
2460         if (ndr_flags & NDR_SCALARS) {
2461                 NDR_CHECK(ndr_push_align(ndr, 8));
2462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2463                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2464                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2465                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2466                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2467         }
2468         if (ndr_flags & NDR_BUFFERS) {
2469         }
2470         return NDR_ERR_SUCCESS;
2471 }
2472
2473 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2474 {
2475         if (ndr_flags & NDR_SCALARS) {
2476                 NDR_CHECK(ndr_pull_align(ndr, 8));
2477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2478                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2479                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2480                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2481                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2482         }
2483         if (ndr_flags & NDR_BUFFERS) {
2484         }
2485         return NDR_ERR_SUCCESS;
2486 }
2487
2488 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2489 {
2490         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2491         ndr->depth++;
2492         ndr_print_uint32(ndr, "version", r->version);
2493         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2494         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2495         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2496         ndr->depth--;
2497 }
2498
2499 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2500 {
2501         uint32_t cntr_meta_data_0;
2502         if (ndr_flags & NDR_SCALARS) {
2503                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2504                 NDR_CHECK(ndr_push_align(ndr, 8));
2505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2506                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2507                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2508                 }
2509                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2510         }
2511         if (ndr_flags & NDR_BUFFERS) {
2512         }
2513         return NDR_ERR_SUCCESS;
2514 }
2515
2516 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2517 {
2518         uint32_t cntr_meta_data_0;
2519         TALLOC_CTX *_mem_save_meta_data_0;
2520         if (ndr_flags & NDR_SCALARS) {
2521                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2522                 NDR_CHECK(ndr_pull_align(ndr, 8));
2523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2524                 if (r->count > 1048576) {
2525                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2526                 }
2527                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2528                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2529                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2530                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2531                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2532                 }
2533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2534                 if (r->meta_data) {
2535                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2536                 }
2537                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2538         }
2539         if (ndr_flags & NDR_BUFFERS) {
2540         }
2541         return NDR_ERR_SUCCESS;
2542 }
2543
2544 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2545 {
2546         uint32_t cntr_meta_data_0;
2547         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2548         ndr->depth++;
2549         ndr_print_uint32(ndr, "count", r->count);
2550         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2551         ndr->depth++;
2552         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2553                 char *idx_0=NULL;
2554                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2555                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2556                         free(idx_0);
2557                 }
2558         }
2559         ndr->depth--;
2560         ndr->depth--;
2561 }
2562
2563 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2564 {
2565         if (ndr_flags & NDR_SCALARS) {
2566                 NDR_CHECK(ndr_push_align(ndr, 5));
2567                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2568                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2570                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2572                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2573         }
2574         if (ndr_flags & NDR_BUFFERS) {
2575                 if (r->next_object) {
2576                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2577                 }
2578                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2579                 if (r->parent_object_guid) {
2580                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2581                 }
2582                 if (r->meta_data_ctr) {
2583                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2584                 }
2585         }
2586         return NDR_ERR_SUCCESS;
2587 }
2588
2589 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2590 {
2591         uint32_t _ptr_next_object;
2592         TALLOC_CTX *_mem_save_next_object_0;
2593         uint32_t _ptr_parent_object_guid;
2594         TALLOC_CTX *_mem_save_parent_object_guid_0;
2595         uint32_t _ptr_meta_data_ctr;
2596         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2597         if (ndr_flags & NDR_SCALARS) {
2598                 NDR_CHECK(ndr_pull_align(ndr, 5));
2599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2600                 if (_ptr_next_object) {
2601                         NDR_PULL_ALLOC(ndr, r->next_object);
2602                 } else {
2603                         r->next_object = NULL;
2604                 }
2605                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2608                 if (_ptr_parent_object_guid) {
2609                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2610                 } else {
2611                         r->parent_object_guid = NULL;
2612                 }
2613                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2614                 if (_ptr_meta_data_ctr) {
2615                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2616                 } else {
2617                         r->meta_data_ctr = NULL;
2618                 }
2619                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2620         }
2621         if (ndr_flags & NDR_BUFFERS) {
2622                 if (r->next_object) {
2623                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2624                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2625                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2627                 }
2628                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2629                 if (r->parent_object_guid) {
2630                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2631                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2632                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2634                 }
2635                 if (r->meta_data_ctr) {
2636                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2637                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2638                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2640                 }
2641         }
2642         return NDR_ERR_SUCCESS;
2643 }
2644
2645 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2646 {
2647         if (ndr_flags & NDR_SCALARS) {
2648                 NDR_CHECK(ndr_push_align(ndr, 8));
2649                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2650                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2651                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2652                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2653                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2654                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2655                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2656                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2661                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2662         }
2663         if (ndr_flags & NDR_BUFFERS) {
2664                 if (r->naming_context) {
2665                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2666                 }
2667                 if (r->uptodateness_vector) {
2668                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2669                 }
2670                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2671                 if (r->first_object) {
2672                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2673                 }
2674         }
2675         return NDR_ERR_SUCCESS;
2676 }
2677
2678 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2679 {
2680         uint32_t _ptr_naming_context;
2681         TALLOC_CTX *_mem_save_naming_context_0;
2682         uint32_t _ptr_uptodateness_vector;
2683         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2684         uint32_t _ptr_first_object;
2685         TALLOC_CTX *_mem_save_first_object_0;
2686         if (ndr_flags & NDR_SCALARS) {
2687                 NDR_CHECK(ndr_pull_align(ndr, 8));
2688                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2689                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2690                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2691                 if (_ptr_naming_context) {
2692                         NDR_PULL_ALLOC(ndr, r->naming_context);
2693                 } else {
2694                         r->naming_context = NULL;
2695                 }
2696                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2697                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2699                 if (_ptr_uptodateness_vector) {
2700                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2701                 } else {
2702                         r->uptodateness_vector = NULL;
2703                 }
2704                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2705                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2709                 if (_ptr_first_object) {
2710                         NDR_PULL_ALLOC(ndr, r->first_object);
2711                 } else {
2712                         r->first_object = NULL;
2713                 }
2714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2715                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2716         }
2717         if (ndr_flags & NDR_BUFFERS) {
2718                 if (r->naming_context) {
2719                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2720                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2721                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2722                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2723                 }
2724                 if (r->uptodateness_vector) {
2725                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2726                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2727                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2729                 }
2730                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2731                 if (r->first_object) {
2732                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2733                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2734                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2736                 }
2737         }
2738         return NDR_ERR_SUCCESS;
2739 }
2740
2741 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2742 {
2743         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2744         ndr->depth++;
2745         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2746         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2747         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2748         ndr->depth++;
2749         if (r->naming_context) {
2750                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2751         }
2752         ndr->depth--;
2753         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2754         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2755         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2756         ndr->depth++;
2757         if (r->uptodateness_vector) {
2758                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2759         }
2760         ndr->depth--;
2761         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2762         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2763         ndr_print_uint32(ndr, "object_count", r->object_count);
2764         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);
2765         ndr_print_ptr(ndr, "first_object", r->first_object);
2766         ndr->depth++;
2767         if (r->first_object) {
2768                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2769         }
2770         ndr->depth--;
2771         ndr_print_uint32(ndr, "more_data", r->more_data);
2772         ndr->depth--;
2773 }
2774
2775 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2776 {
2777         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2778 }
2779
2780 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2781 {
2782         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2783         return NDR_ERR_SUCCESS;
2784 }
2785
2786 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2787 {
2788         uint32_t v;
2789         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2790         *r = v;
2791         return NDR_ERR_SUCCESS;
2792 }
2793
2794 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2795 {
2796         ndr_print_uint32(ndr, name, r);
2797         ndr->depth++;
2798         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2799         ndr->depth--;
2800 }
2801
2802 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2803 {
2804         if (ndr_flags & NDR_SCALARS) {
2805                 NDR_CHECK(ndr_push_align(ndr, 8));
2806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2807                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2808                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2809                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2810                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2811                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2812                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2813         }
2814         if (ndr_flags & NDR_BUFFERS) {
2815                 if (r->identifier) {
2816                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2817                 }
2818                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2819         }
2820         return NDR_ERR_SUCCESS;
2821 }
2822
2823 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2824 {
2825         uint32_t _ptr_identifier;
2826         TALLOC_CTX *_mem_save_identifier_0;
2827         if (ndr_flags & NDR_SCALARS) {
2828                 NDR_CHECK(ndr_pull_align(ndr, 8));
2829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2830                 if (_ptr_identifier) {
2831                         NDR_PULL_ALLOC(ndr, r->identifier);
2832                 } else {
2833                         r->identifier = NULL;
2834                 }
2835                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2836                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2837                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2838                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2839                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2840                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2841         }
2842         if (ndr_flags & NDR_BUFFERS) {
2843                 if (r->identifier) {
2844                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2845                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2846                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2848                 }
2849                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2850         }
2851         return NDR_ERR_SUCCESS;
2852 }
2853
2854 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2855 {
2856         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2857         ndr->depth++;
2858         ndr_print_ptr(ndr, "identifier", r->identifier);
2859         ndr->depth++;
2860         if (r->identifier) {
2861                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2862         }
2863         ndr->depth--;
2864         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2865         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2866         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2867         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2868         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2869         ndr->depth--;
2870 }
2871
2872 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2873 {
2874         uint32_t cntr_linked_attributes_1;
2875         if (ndr_flags & NDR_SCALARS) {
2876                 NDR_CHECK(ndr_push_align(ndr, 8));
2877                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2878                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2879                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2880                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2881                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2882                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2883                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2884                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2891                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2893                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2894                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2895         }
2896         if (ndr_flags & NDR_BUFFERS) {
2897                 if (r->naming_context) {
2898                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2899                 }
2900                 if (r->uptodateness_vector) {
2901                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2902                 }
2903                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2904                 if (r->first_object) {
2905                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2906                 }
2907                 if (r->linked_attributes) {
2908                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2909                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2910                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2911                         }
2912                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2913                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2914                         }
2915                 }
2916         }
2917         return NDR_ERR_SUCCESS;
2918 }
2919
2920 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2921 {
2922         uint32_t _ptr_naming_context;
2923         TALLOC_CTX *_mem_save_naming_context_0;
2924         uint32_t _ptr_uptodateness_vector;
2925         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2926         uint32_t _ptr_first_object;
2927         TALLOC_CTX *_mem_save_first_object_0;
2928         uint32_t _ptr_linked_attributes;
2929         uint32_t cntr_linked_attributes_1;
2930         TALLOC_CTX *_mem_save_linked_attributes_0;
2931         TALLOC_CTX *_mem_save_linked_attributes_1;
2932         if (ndr_flags & NDR_SCALARS) {
2933                 NDR_CHECK(ndr_pull_align(ndr, 8));
2934                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2935                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2936                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2937                 if (_ptr_naming_context) {
2938                         NDR_PULL_ALLOC(ndr, r->naming_context);
2939                 } else {
2940                         r->naming_context = NULL;
2941                 }
2942                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2943                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2945                 if (_ptr_uptodateness_vector) {
2946                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2947                 } else {
2948                         r->uptodateness_vector = NULL;
2949                 }
2950                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2951                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2954                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2955                 if (_ptr_first_object) {
2956                         NDR_PULL_ALLOC(ndr, r->first_object);
2957                 } else {
2958                         r->first_object = NULL;
2959                 }
2960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
2962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
2963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
2964                 if (r->linked_attributes_count > 1048576) {
2965                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2966                 }
2967                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
2968                 if (_ptr_linked_attributes) {
2969                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
2970                 } else {
2971                         r->linked_attributes = NULL;
2972                 }
2973                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
2974                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2975         }
2976         if (ndr_flags & NDR_BUFFERS) {
2977                 if (r->naming_context) {
2978                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2979                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2980                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2981                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2982                 }
2983                 if (r->uptodateness_vector) {
2984                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2985                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2986                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2988                 }
2989                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2990                 if (r->first_object) {
2991                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2992                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2993                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2994                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2995                 }
2996                 if (r->linked_attributes) {
2997                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2998                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2999                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3000                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3001                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3002                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3003                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3004                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3005                         }
3006                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3007                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3008                         }
3009                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3011                 }
3012                 if (r->linked_attributes) {
3013                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3014                 }
3015         }
3016         return NDR_ERR_SUCCESS;
3017 }
3018
3019 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3020 {
3021         uint32_t cntr_linked_attributes_1;
3022         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3023         ndr->depth++;
3024         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3025         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3026         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3027         ndr->depth++;
3028         if (r->naming_context) {
3029                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3030         }
3031         ndr->depth--;
3032         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3033         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3034         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3035         ndr->depth++;
3036         if (r->uptodateness_vector) {
3037                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3038         }
3039         ndr->depth--;
3040         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3041         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3042         ndr_print_uint32(ndr, "object_count", r->object_count);
3043         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);
3044         ndr_print_ptr(ndr, "first_object", r->first_object);
3045         ndr->depth++;
3046         if (r->first_object) {
3047                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3048         }
3049         ndr->depth--;
3050         ndr_print_uint32(ndr, "more_data", r->more_data);
3051         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3052         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3053         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3054         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3055         ndr->depth++;
3056         if (r->linked_attributes) {
3057                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3058                 ndr->depth++;
3059                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3060                         char *idx_1=NULL;
3061                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3062                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3063                                 free(idx_1);
3064                         }
3065                 }
3066                 ndr->depth--;
3067         }
3068         ndr->depth--;
3069         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3070         ndr->depth--;
3071 }
3072
3073 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3074 {
3075         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3076 }
3077
3078 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3079 {
3080         if (ndr_flags & NDR_SCALARS) {
3081                 NDR_CHECK(ndr_push_align(ndr, 1));
3082                 {
3083                         struct ndr_push *_ndr_ctr1;
3084                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3085                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3086                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3087                 }
3088                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3089         }
3090         if (ndr_flags & NDR_BUFFERS) {
3091         }
3092         return NDR_ERR_SUCCESS;
3093 }
3094
3095 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3096 {
3097         if (ndr_flags & NDR_SCALARS) {
3098                 NDR_CHECK(ndr_pull_align(ndr, 1));
3099                 {
3100                         struct ndr_pull *_ndr_ctr1;
3101                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3102                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3103                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3104                 }
3105                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3106         }
3107         if (ndr_flags & NDR_BUFFERS) {
3108         }
3109         return NDR_ERR_SUCCESS;
3110 }
3111
3112 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3113 {
3114         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3115         ndr->depth++;
3116         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3117         ndr->depth--;
3118 }
3119
3120 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3121 {
3122         if (ndr_flags & NDR_SCALARS) {
3123                 NDR_CHECK(ndr_push_align(ndr, 1));
3124                 {
3125                         struct ndr_push *_ndr_ctr6;
3126                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3127                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3128                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3129                 }
3130                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3131         }
3132         if (ndr_flags & NDR_BUFFERS) {
3133         }
3134         return NDR_ERR_SUCCESS;
3135 }
3136
3137 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3138 {
3139         if (ndr_flags & NDR_SCALARS) {
3140                 NDR_CHECK(ndr_pull_align(ndr, 1));
3141                 {
3142                         struct ndr_pull *_ndr_ctr6;
3143                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3144                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3145                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3146                 }
3147                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3148         }
3149         if (ndr_flags & NDR_BUFFERS) {
3150         }
3151         return NDR_ERR_SUCCESS;
3152 }
3153
3154 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3155 {
3156         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3157         ndr->depth++;
3158         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3159         ndr->depth--;
3160 }
3161
3162 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3163 {
3164         uint32_t _ptr_ts;
3165         TALLOC_CTX *_mem_save_ts_0;
3166         if (ndr_flags & NDR_SCALARS) {
3167                 NDR_CHECK(ndr_pull_align(ndr, 5));
3168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3171                 if (_ptr_ts) {
3172                         NDR_PULL_ALLOC(ndr, r->ts);
3173                 } else {
3174                         r->ts = NULL;
3175                 }
3176                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3177         }
3178         if (ndr_flags & NDR_BUFFERS) {
3179                 if (r->ts) {
3180                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3181                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3182                         {
3183                                 struct ndr_pull *_ndr_ts;
3184                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3185                                 {
3186                                         struct ndr_pull *_ndr_ts_compressed;
3187                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3188                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3189                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3190                                 }
3191                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3192                         }
3193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3194                 }
3195         }
3196         return NDR_ERR_SUCCESS;
3197 }
3198
3199 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3200 {
3201         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3202         ndr->depth++;
3203         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3204         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3205         ndr_print_ptr(ndr, "ts", r->ts);
3206         ndr->depth++;
3207         if (r->ts) {
3208                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3209         }
3210         ndr->depth--;
3211         ndr->depth--;
3212 }
3213
3214 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3215 {
3216         uint32_t _ptr_ts;
3217         TALLOC_CTX *_mem_save_ts_0;
3218         if (ndr_flags & NDR_SCALARS) {
3219                 NDR_CHECK(ndr_pull_align(ndr, 5));
3220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3222                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3223                 if (_ptr_ts) {
3224                         NDR_PULL_ALLOC(ndr, r->ts);
3225                 } else {
3226                         r->ts = NULL;
3227                 }
3228                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3229         }
3230         if (ndr_flags & NDR_BUFFERS) {
3231                 if (r->ts) {
3232                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3233                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3234                         {
3235                                 struct ndr_pull *_ndr_ts;
3236                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3237                                 {
3238                                         struct ndr_pull *_ndr_ts_compressed;
3239                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3240                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3241                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3242                                 }
3243                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3244                         }
3245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3246                 }
3247         }
3248         return NDR_ERR_SUCCESS;
3249 }
3250
3251 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3252 {
3253         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3254         ndr->depth++;
3255         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3256         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3257         ndr_print_ptr(ndr, "ts", r->ts);
3258         ndr->depth++;
3259         if (r->ts) {
3260                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3261         }
3262         ndr->depth--;
3263         ndr->depth--;
3264 }
3265
3266 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3267 {
3268         uint32_t _ptr_ts;
3269         TALLOC_CTX *_mem_save_ts_0;
3270         if (ndr_flags & NDR_SCALARS) {
3271                 NDR_CHECK(ndr_pull_align(ndr, 5));
3272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3275                 if (_ptr_ts) {
3276                         NDR_PULL_ALLOC(ndr, r->ts);
3277                 } else {
3278                         r->ts = NULL;
3279                 }
3280                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3281         }
3282         if (ndr_flags & NDR_BUFFERS) {
3283                 if (r->ts) {
3284                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3285                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3286                         {
3287                                 struct ndr_pull *_ndr_ts;
3288                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3289                                 {
3290                                         struct ndr_pull *_ndr_ts_compressed;
3291                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3292                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3293                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3294                                 }
3295                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3296                         }
3297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3298                 }
3299         }
3300         return NDR_ERR_SUCCESS;
3301 }
3302
3303 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3304 {
3305         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3306         ndr->depth++;
3307         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3308         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3309         ndr_print_ptr(ndr, "ts", r->ts);
3310         ndr->depth++;
3311         if (r->ts) {
3312                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3313         }
3314         ndr->depth--;
3315         ndr->depth--;
3316 }
3317
3318 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3319 {
3320         uint32_t _ptr_ts;
3321         TALLOC_CTX *_mem_save_ts_0;
3322         if (ndr_flags & NDR_SCALARS) {
3323                 NDR_CHECK(ndr_pull_align(ndr, 5));
3324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3327                 if (_ptr_ts) {
3328                         NDR_PULL_ALLOC(ndr, r->ts);
3329                 } else {
3330                         r->ts = NULL;
3331                 }
3332                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3333         }
3334         if (ndr_flags & NDR_BUFFERS) {
3335                 if (r->ts) {
3336                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3337                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3338                         {
3339                                 struct ndr_pull *_ndr_ts;
3340                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3341                                 {
3342                                         struct ndr_pull *_ndr_ts_compressed;
3343                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3344                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3345                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3346                                 }
3347                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3348                         }
3349                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3350                 }
3351         }
3352         return NDR_ERR_SUCCESS;
3353 }
3354
3355 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3356 {
3357         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3358         ndr->depth++;
3359         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3360         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3361         ndr_print_ptr(ndr, "ts", r->ts);
3362         ndr->depth++;
3363         if (r->ts) {
3364                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3365         }
3366         ndr->depth--;
3367         ndr->depth--;
3368 }
3369
3370 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3371 {
3372         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3373         return NDR_ERR_SUCCESS;
3374 }
3375
3376 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3377 {
3378         uint16_t v;
3379         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3380         *r = v;
3381         return NDR_ERR_SUCCESS;
3382 }
3383
3384 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3385 {
3386         const char *val = NULL;
3387
3388         switch (r) {
3389                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3390                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3391         }
3392         ndr_print_enum(ndr, name, "ENUM", val, r);
3393 }
3394
3395 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3396 {
3397         {
3398                 uint32_t _flags_save_UNION = ndr->flags;
3399                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3400                 if (ndr_flags & NDR_SCALARS) {
3401                         int level = ndr_push_get_switch_value(ndr, r);
3402                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3403                         switch (level) {
3404                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3405                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3406                                 break; }
3407
3408                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3409                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3410                                 break; }
3411
3412                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3413                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3414                                 break; }
3415
3416                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3417                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3418                                 break; }
3419
3420                                 default:
3421                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3422                         }
3423                 }
3424                 if (ndr_flags & NDR_BUFFERS) {
3425                         int level = ndr_push_get_switch_value(ndr, r);
3426                         switch (level) {
3427                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3428                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3429                                 break;
3430
3431                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3432                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3433                                 break;
3434
3435                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3436                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3437                                 break;
3438
3439                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3440                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3441                                 break;
3442
3443                                 default:
3444                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3445                         }
3446                 }
3447                 ndr->flags = _flags_save_UNION;
3448         }
3449         return NDR_ERR_SUCCESS;
3450 }
3451
3452 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3453 {
3454         int level;
3455         {
3456                 uint32_t _flags_save_UNION = ndr->flags;
3457                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3458                 level = ndr_pull_get_switch_value(ndr, r);
3459                 if (ndr_flags & NDR_SCALARS) {
3460                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3461                         switch (level) {
3462                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3463                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3464                                 break; }
3465
3466                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3467                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3468                                 break; }
3469
3470                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3471                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3472                                 break; }
3473
3474                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3475                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3476                                 break; }
3477
3478                                 default:
3479                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3480                         }
3481                 }
3482                 if (ndr_flags & NDR_BUFFERS) {
3483                         switch (level) {
3484                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3485                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3486                                 break;
3487
3488                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3489                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3490                                 break;
3491
3492                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3493                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3494                                 break;
3495
3496                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3497                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3498                                 break;
3499
3500                                 default:
3501                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3502                         }
3503                 }
3504                 ndr->flags = _flags_save_UNION;
3505         }
3506         return NDR_ERR_SUCCESS;
3507 }
3508
3509 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3510 {
3511         int level;
3512         {
3513                 uint32_t _flags_save_UNION = ndr->flags;
3514                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3515                 level = ndr_print_get_switch_value(ndr, r);
3516                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3517                 switch (level) {
3518                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3519                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3520                         break;
3521
3522                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3523                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3524                         break;
3525
3526                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3527                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3528                         break;
3529
3530                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3531                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3532                         break;
3533
3534                         default:
3535                                 ndr_print_bad_level(ndr, name, level);
3536                 }
3537                 ndr->flags = _flags_save_UNION;
3538         }
3539 }
3540
3541 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3542 {
3543         if (ndr_flags & NDR_SCALARS) {
3544                 NDR_CHECK(ndr_push_align(ndr, 5));
3545                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3546                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3547         }
3548         if (ndr_flags & NDR_BUFFERS) {
3549                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3550         }
3551         return NDR_ERR_SUCCESS;
3552 }
3553
3554 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3555 {
3556         if (ndr_flags & NDR_SCALARS) {
3557                 NDR_CHECK(ndr_pull_align(ndr, 5));
3558                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3559                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3560         }
3561         if (ndr_flags & NDR_BUFFERS) {
3562                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3563         }
3564         return NDR_ERR_SUCCESS;
3565 }
3566
3567 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3568 {
3569         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3570         ndr->depth++;
3571         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3572         ndr->depth--;
3573 }
3574
3575 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3576 {
3577         if (ndr_flags & NDR_SCALARS) {
3578                 NDR_CHECK(ndr_push_align(ndr, 5));
3579                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3580                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3581                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3582                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3583                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3584         }
3585         if (ndr_flags & NDR_BUFFERS) {
3586                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3587         }
3588         return NDR_ERR_SUCCESS;
3589 }
3590
3591 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3592 {
3593         if (ndr_flags & NDR_SCALARS) {
3594                 NDR_CHECK(ndr_pull_align(ndr, 5));
3595                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3596                 if (r->level < 0 || r->level > 6) {
3597                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3598                 }
3599                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3600                 if (r->type < 2 || r->type > 3) {
3601                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3602                 }
3603                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3604                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3605                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3606         }
3607         if (ndr_flags & NDR_BUFFERS) {
3608                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3609         }
3610         return NDR_ERR_SUCCESS;
3611 }
3612
3613 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3614 {
3615         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3616         ndr->depth++;
3617         ndr_print_int32(ndr, "level", r->level);
3618         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3619         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3620         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3621         ndr->depth--;
3622 }
3623
3624 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3625 {
3626         if (ndr_flags & NDR_SCALARS) {
3627                 int level = ndr_push_get_switch_value(ndr, r);
3628                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3629                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3630                 switch (level) {
3631                         case 1: {
3632                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3633                         break; }
3634
3635                         case 2: {
3636                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3637                         break; }
3638
3639                         case 6: {
3640                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3641                         break; }
3642
3643                         case 7: {
3644                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3645                         break; }
3646
3647                         default:
3648                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3649                 }
3650         }
3651         if (ndr_flags & NDR_BUFFERS) {
3652                 int level = ndr_push_get_switch_value(ndr, r);
3653                 switch (level) {
3654                         case 1:
3655                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3656                         break;
3657
3658                         case 2:
3659                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3660                         break;
3661
3662                         case 6:
3663                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3664                         break;
3665
3666                         case 7:
3667                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3668                         break;
3669
3670                         default:
3671                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3672                 }
3673         }
3674         return NDR_ERR_SUCCESS;
3675 }
3676
3677 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3678 {
3679         int level;
3680         int32_t _level;
3681         level = ndr_pull_get_switch_value(ndr, r);
3682         if (ndr_flags & NDR_SCALARS) {
3683                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3684                 if (_level != level) {
3685                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3686                 }
3687                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3688                 switch (level) {
3689                         case 1: {
3690                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3691                         break; }
3692
3693                         case 2: {
3694                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3695                         break; }
3696
3697                         case 6: {
3698                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3699                         break; }
3700
3701                         case 7: {
3702                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3703                         break; }
3704
3705                         default:
3706                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3707                 }
3708         }
3709         if (ndr_flags & NDR_BUFFERS) {
3710                 switch (level) {
3711                         case 1:
3712                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3713                         break;
3714
3715                         case 2:
3716                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3717                         break;
3718
3719                         case 6:
3720                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3721                         break;
3722
3723                         case 7:
3724                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3725                         break;
3726
3727                         default:
3728                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3729                 }
3730         }
3731         return NDR_ERR_SUCCESS;
3732 }
3733
3734 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3735 {
3736         int level;
3737         level = ndr_print_get_switch_value(ndr, r);
3738         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3739         switch (level) {
3740                 case 1:
3741                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3742                 break;
3743
3744                 case 2:
3745                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3746                 break;
3747
3748                 case 6:
3749                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3750                 break;
3751
3752                 case 7:
3753                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3754                 break;
3755
3756                 default:
3757                         ndr_print_bad_level(ndr, name, level);
3758         }
3759 }
3760
3761 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3762 {
3763         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3764         return NDR_ERR_SUCCESS;
3765 }
3766
3767 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3768 {
3769         uint32_t v;
3770         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3771         *r = v;
3772         return NDR_ERR_SUCCESS;
3773 }
3774
3775 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3776 {
3777         ndr_print_uint32(ndr, name, r);
3778         ndr->depth++;
3779         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION, r);
3780         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK", DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK, r);
3781         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE, r);
3782         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE, r);
3783         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE", DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE, r);
3784         ndr->depth--;
3785 }
3786
3787 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3788 {
3789         if (ndr_flags & NDR_SCALARS) {
3790                 NDR_CHECK(ndr_push_align(ndr, 5));
3791                 if (r->naming_context == NULL) {
3792                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3793                 }
3794                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3795                 if (r->dest_dsa_dns_name == NULL) {
3796                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3797                 }
3798                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3799                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3800                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
3801                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3802         }
3803         if (ndr_flags & NDR_BUFFERS) {
3804                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3805                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3806                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3807                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3808                 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));
3809         }
3810         return NDR_ERR_SUCCESS;
3811 }
3812
3813 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3814 {
3815         uint32_t _ptr_naming_context;
3816         TALLOC_CTX *_mem_save_naming_context_0;
3817         uint32_t _ptr_dest_dsa_dns_name;
3818         if (ndr_flags & NDR_SCALARS) {
3819                 NDR_CHECK(ndr_pull_align(ndr, 5));
3820                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3821                 if (_ptr_naming_context) {
3822                         NDR_PULL_ALLOC(ndr, r->naming_context);
3823                 } else {
3824                         r->naming_context = NULL;
3825                 }
3826                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3827                 if (_ptr_dest_dsa_dns_name) {
3828                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3829                 } else {
3830                         r->dest_dsa_dns_name = NULL;
3831                 }
3832                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3833                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
3834                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3835         }
3836         if (ndr_flags & NDR_BUFFERS) {
3837                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3838                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3839                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3841                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3842                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3843                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3844                         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));
3845                 }
3846                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3847                 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));
3848         }
3849         return NDR_ERR_SUCCESS;
3850 }
3851
3852 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3853 {
3854         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3855         ndr->depth++;
3856         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3857         ndr->depth++;
3858         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3859         ndr->depth--;
3860         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3861         ndr->depth++;
3862         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3863         ndr->depth--;
3864         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3865         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "options", r->options);
3866         ndr->depth--;
3867 }
3868
3869 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3870 {
3871         if (ndr_flags & NDR_SCALARS) {
3872                 int level = ndr_push_get_switch_value(ndr, r);
3873                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3874                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3875                 switch (level) {
3876                         case 1: {
3877                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3878                         break; }
3879
3880                         default:
3881                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3882                 }
3883         }
3884         if (ndr_flags & NDR_BUFFERS) {
3885                 int level = ndr_push_get_switch_value(ndr, r);
3886                 switch (level) {
3887                         case 1:
3888                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3889                         break;
3890
3891                         default:
3892                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3893                 }
3894         }
3895         return NDR_ERR_SUCCESS;
3896 }
3897
3898 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3899 {
3900         int level;
3901         int32_t _level;
3902         level = ndr_pull_get_switch_value(ndr, r);
3903         if (ndr_flags & NDR_SCALARS) {
3904                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3905                 if (_level != level) {
3906                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3907                 }
3908                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3909                 switch (level) {
3910                         case 1: {
3911                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3912                         break; }
3913
3914                         default:
3915                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3916                 }
3917         }
3918         if (ndr_flags & NDR_BUFFERS) {
3919                 switch (level) {
3920                         case 1:
3921                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3922                         break;
3923
3924                         default:
3925                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3926                 }
3927         }
3928         return NDR_ERR_SUCCESS;
3929 }
3930
3931 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3932 {
3933         int level;
3934         level = ndr_print_get_switch_value(ndr, r);
3935         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3936         switch (level) {
3937                 case 1:
3938                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3939                 break;
3940
3941                 default:
3942                         ndr_print_bad_level(ndr, name, level);
3943         }
3944 }
3945
3946 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3947 {
3948         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3949         return NDR_ERR_SUCCESS;
3950 }
3951
3952 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3953 {
3954         uint32_t v;
3955         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3956         *r = v;
3957         return NDR_ERR_SUCCESS;
3958 }
3959
3960 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3961 {
3962         ndr_print_uint32(ndr, name, r);
3963         ndr->depth++;
3964         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
3965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
3966         ndr->depth--;
3967 }
3968
3969 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
3970 {
3971         if (ndr_flags & NDR_SCALARS) {
3972                 NDR_CHECK(ndr_push_align(ndr, 5));
3973                 if (r->naming_context == NULL) {
3974                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3975                 }
3976                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3977                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3978                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3979                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
3980                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3981         }
3982         if (ndr_flags & NDR_BUFFERS) {
3983                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3984                 if (r->source_dsa_address) {
3985                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3986                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3988                         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));
3989                 }
3990         }
3991         return NDR_ERR_SUCCESS;
3992 }
3993
3994 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
3995 {
3996         uint32_t _ptr_naming_context;
3997         TALLOC_CTX *_mem_save_naming_context_0;
3998         uint32_t _ptr_source_dsa_address;
3999         TALLOC_CTX *_mem_save_source_dsa_address_0;
4000         if (ndr_flags & NDR_SCALARS) {
4001                 NDR_CHECK(ndr_pull_align(ndr, 5));
4002                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4003                 if (_ptr_naming_context) {
4004                         NDR_PULL_ALLOC(ndr, r->naming_context);
4005                 } else {
4006                         r->naming_context = NULL;
4007                 }
4008                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4009                 if (_ptr_source_dsa_address) {
4010                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4011                 } else {
4012                         r->source_dsa_address = NULL;
4013                 }
4014                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4015                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4016                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4017         }
4018         if (ndr_flags & NDR_BUFFERS) {
4019                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4020                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4021                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4022                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4023                 if (r->source_dsa_address) {
4024                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4025                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4026                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4027                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4028                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4029                                 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));
4030                         }
4031                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4032                         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));
4033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4034                 }
4035         }
4036         return NDR_ERR_SUCCESS;
4037 }
4038
4039 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4040 {
4041         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4042         ndr->depth++;
4043         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4044         ndr->depth++;
4045         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4046         ndr->depth--;
4047         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4048         ndr->depth++;
4049         if (r->source_dsa_address) {
4050                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4051         }
4052         ndr->depth--;
4053         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4054         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
4055         ndr->depth--;
4056 }
4057
4058 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4059 {
4060         if (ndr_flags & NDR_SCALARS) {
4061                 NDR_CHECK(ndr_push_align(ndr, 5));
4062                 if (r->naming_context == NULL) {
4063                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4064                 }
4065                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4066                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4069                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4070                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
4071                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4072         }
4073         if (ndr_flags & NDR_BUFFERS) {
4074                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4075                 if (r->source_dsa_dn) {
4076                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4077                 }
4078                 if (r->transport_dn) {
4079                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4080                 }
4081                 if (r->source_dsa_address) {
4082                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4083                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4084                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4085                         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));
4086                 }
4087         }
4088         return NDR_ERR_SUCCESS;
4089 }
4090
4091 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4092 {
4093         uint32_t _ptr_naming_context;
4094         TALLOC_CTX *_mem_save_naming_context_0;
4095         uint32_t _ptr_source_dsa_dn;
4096         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4097         uint32_t _ptr_transport_dn;
4098         TALLOC_CTX *_mem_save_transport_dn_0;
4099         uint32_t _ptr_source_dsa_address;
4100         TALLOC_CTX *_mem_save_source_dsa_address_0;
4101         if (ndr_flags & NDR_SCALARS) {
4102                 NDR_CHECK(ndr_pull_align(ndr, 5));
4103                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4104                 if (_ptr_naming_context) {
4105                         NDR_PULL_ALLOC(ndr, r->naming_context);
4106                 } else {
4107                         r->naming_context = NULL;
4108                 }
4109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4110                 if (_ptr_source_dsa_dn) {
4111                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4112                 } else {
4113                         r->source_dsa_dn = NULL;
4114                 }
4115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4116                 if (_ptr_transport_dn) {
4117                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4118                 } else {
4119                         r->transport_dn = NULL;
4120                 }
4121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4122                 if (_ptr_source_dsa_address) {
4123                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4124                 } else {
4125                         r->source_dsa_address = NULL;
4126                 }
4127                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4128                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4129                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4130         }
4131         if (ndr_flags & NDR_BUFFERS) {
4132                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4133                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4134                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4136                 if (r->source_dsa_dn) {
4137                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4138                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4139                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4141                 }
4142                 if (r->transport_dn) {
4143                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4144                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4145                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4147                 }
4148                 if (r->source_dsa_address) {
4149                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4150                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4151                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4152                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4153                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4154                                 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));
4155                         }
4156                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4157                         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));
4158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4159                 }
4160         }
4161         return NDR_ERR_SUCCESS;
4162 }
4163
4164 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4165 {
4166         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4167         ndr->depth++;
4168         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4169         ndr->depth++;
4170         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4171         ndr->depth--;
4172         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4173         ndr->depth++;
4174         if (r->source_dsa_dn) {
4175                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4176         }
4177         ndr->depth--;
4178         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4179         ndr->depth++;
4180         if (r->transport_dn) {
4181                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4182         }
4183         ndr->depth--;
4184         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4185         ndr->depth++;
4186         if (r->source_dsa_address) {
4187                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4188         }
4189         ndr->depth--;
4190         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4191         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
4192         ndr->depth--;
4193 }
4194
4195 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4196 {
4197         if (ndr_flags & NDR_SCALARS) {
4198                 int level = ndr_push_get_switch_value(ndr, r);
4199                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4200                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4201                 switch (level) {
4202                         case 1: {
4203                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4204                         break; }
4205
4206                         case 2: {
4207                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4208                         break; }
4209
4210                         default:
4211                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4212                 }
4213         }
4214         if (ndr_flags & NDR_BUFFERS) {
4215                 int level = ndr_push_get_switch_value(ndr, r);
4216                 switch (level) {
4217                         case 1:
4218                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4219                         break;
4220
4221                         case 2:
4222                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4223                         break;
4224
4225                         default:
4226                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4227                 }
4228         }
4229         return NDR_ERR_SUCCESS;
4230 }
4231
4232 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4233 {
4234         int level;
4235         int32_t _level;
4236         level = ndr_pull_get_switch_value(ndr, r);
4237         if (ndr_flags & NDR_SCALARS) {
4238                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4239                 if (_level != level) {
4240                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4241                 }
4242                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4243                 switch (level) {
4244                         case 1: {
4245                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4246                         break; }
4247
4248                         case 2: {
4249                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4250                         break; }
4251
4252                         default:
4253                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4254                 }
4255         }
4256         if (ndr_flags & NDR_BUFFERS) {
4257                 switch (level) {
4258                         case 1:
4259                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4260                         break;
4261
4262                         case 2:
4263                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4264                         break;
4265
4266                         default:
4267                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4268                 }
4269         }
4270         return NDR_ERR_SUCCESS;
4271 }
4272
4273 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4274 {
4275         int level;
4276         level = ndr_print_get_switch_value(ndr, r);
4277         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4278         switch (level) {
4279                 case 1:
4280                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4281                 break;
4282
4283                 case 2:
4284                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4285                 break;
4286
4287                 default:
4288                         ndr_print_bad_level(ndr, name, level);
4289         }
4290 }
4291
4292 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4293 {
4294         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4295         return NDR_ERR_SUCCESS;
4296 }
4297
4298 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4299 {
4300         uint32_t v;
4301         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4302         *r = v;
4303         return NDR_ERR_SUCCESS;
4304 }
4305
4306 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4307 {
4308         ndr_print_uint32(ndr, name, r);
4309         ndr->depth++;
4310         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4311         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4312         ndr->depth--;
4313 }
4314
4315 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4316 {
4317         if (ndr_flags & NDR_SCALARS) {
4318                 NDR_CHECK(ndr_push_align(ndr, 5));
4319                 if (r->naming_context == NULL) {
4320                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4321                 }
4322                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4324                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->options));
4325                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4326         }
4327         if (ndr_flags & NDR_BUFFERS) {
4328                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4329                 if (r->source_dsa_address) {
4330                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4331                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4332                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4333                         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));
4334                 }
4335         }
4336         return NDR_ERR_SUCCESS;
4337 }
4338
4339 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4340 {
4341         uint32_t _ptr_naming_context;
4342         TALLOC_CTX *_mem_save_naming_context_0;
4343         uint32_t _ptr_source_dsa_address;
4344         TALLOC_CTX *_mem_save_source_dsa_address_0;
4345         if (ndr_flags & NDR_SCALARS) {
4346                 NDR_CHECK(ndr_pull_align(ndr, 5));
4347                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4348                 if (_ptr_naming_context) {
4349                         NDR_PULL_ALLOC(ndr, r->naming_context);
4350                 } else {
4351                         r->naming_context = NULL;
4352                 }
4353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4354                 if (_ptr_source_dsa_address) {
4355                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4356                 } else {
4357                         r->source_dsa_address = NULL;
4358                 }
4359                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->options));
4360                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4361         }
4362         if (ndr_flags & NDR_BUFFERS) {
4363                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4364                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4365                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4367                 if (r->source_dsa_address) {
4368                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4369                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4370                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4371                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4372                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4373                                 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));
4374                         }
4375                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4376                         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));
4377                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4378                 }
4379         }
4380         return NDR_ERR_SUCCESS;
4381 }
4382
4383 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4384 {
4385         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4386         ndr->depth++;
4387         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4388         ndr->depth++;
4389         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4390         ndr->depth--;
4391         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4392         ndr->depth++;
4393         if (r->source_dsa_address) {
4394                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4395         }
4396         ndr->depth--;
4397         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "options", r->options);
4398         ndr->depth--;
4399 }
4400
4401 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4402 {
4403         if (ndr_flags & NDR_SCALARS) {
4404                 int level = ndr_push_get_switch_value(ndr, r);
4405                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4406                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4407                 switch (level) {
4408                         case 1: {
4409                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4410                         break; }
4411
4412                         default:
4413                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4414                 }
4415         }
4416         if (ndr_flags & NDR_BUFFERS) {
4417                 int level = ndr_push_get_switch_value(ndr, r);
4418                 switch (level) {
4419                         case 1:
4420                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4421                         break;
4422
4423                         default:
4424                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4425                 }
4426         }
4427         return NDR_ERR_SUCCESS;
4428 }
4429
4430 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4431 {
4432         int level;
4433         int32_t _level;
4434         level = ndr_pull_get_switch_value(ndr, r);
4435         if (ndr_flags & NDR_SCALARS) {
4436                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4437                 if (_level != level) {
4438                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4439                 }
4440                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4441                 switch (level) {
4442                         case 1: {
4443                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4444                         break; }
4445
4446                         default:
4447                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4448                 }
4449         }
4450         if (ndr_flags & NDR_BUFFERS) {
4451                 switch (level) {
4452                         case 1:
4453                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4454                         break;
4455
4456                         default:
4457                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4458                 }
4459         }
4460         return NDR_ERR_SUCCESS;
4461 }
4462
4463 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4464 {
4465         int level;
4466         level = ndr_print_get_switch_value(ndr, r);
4467         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4468         switch (level) {
4469                 case 1:
4470                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4471                 break;
4472
4473                 default:
4474                         ndr_print_bad_level(ndr, name, level);
4475         }
4476 }
4477
4478 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4479 {
4480         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4481         return NDR_ERR_SUCCESS;
4482 }
4483
4484 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModifyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4485 {
4486         uint32_t v;
4487         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4488         *r = v;
4489         return NDR_ERR_SUCCESS;
4490 }
4491
4492 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4493 {
4494         ndr_print_uint32(ndr, name, r);
4495         ndr->depth++;
4496         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4497         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4498         ndr->depth--;
4499 }
4500
4501 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4502 {
4503         if (ndr_flags & NDR_SCALARS) {
4504                 NDR_CHECK(ndr_push_align(ndr, 5));
4505                 if (r->naming_context == NULL) {
4506                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4507                 }
4508                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4509                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4510                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4511                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4514                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->options));
4515                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4516         }
4517         if (ndr_flags & NDR_BUFFERS) {
4518                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4519                 if (r->source_dra_address) {
4520                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4523                         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));
4524                 }
4525         }
4526         return NDR_ERR_SUCCESS;
4527 }
4528
4529 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4530 {
4531         uint32_t _ptr_naming_context;
4532         TALLOC_CTX *_mem_save_naming_context_0;
4533         uint32_t _ptr_source_dra_address;
4534         TALLOC_CTX *_mem_save_source_dra_address_0;
4535         if (ndr_flags & NDR_SCALARS) {
4536                 NDR_CHECK(ndr_pull_align(ndr, 5));
4537                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4538                 if (_ptr_naming_context) {
4539                         NDR_PULL_ALLOC(ndr, r->naming_context);
4540                 } else {
4541                         r->naming_context = NULL;
4542                 }
4543                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4544                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4545                 if (_ptr_source_dra_address) {
4546                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4547                 } else {
4548                         r->source_dra_address = NULL;
4549                 }
4550                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4553                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->options));
4554                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4555         }
4556         if (ndr_flags & NDR_BUFFERS) {
4557                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4558                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4559                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4561                 if (r->source_dra_address) {
4562                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4563                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4566                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4567                                 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));
4568                         }
4569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4570                         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));
4571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4572                 }
4573         }
4574         return NDR_ERR_SUCCESS;
4575 }
4576
4577 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4578 {
4579         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4580         ndr->depth++;
4581         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4582         ndr->depth++;
4583         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4584         ndr->depth--;
4585         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4586         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4587         ndr->depth++;
4588         if (r->source_dra_address) {
4589                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4590         }
4591         ndr->depth--;
4592         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4593         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4594         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4595         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "options", r->options);
4596         ndr->depth--;
4597 }
4598
4599 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4600 {
4601         if (ndr_flags & NDR_SCALARS) {
4602                 int level = ndr_push_get_switch_value(ndr, r);
4603                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4604                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4605                 switch (level) {
4606                         case 1: {
4607                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4608                         break; }
4609
4610                         default:
4611                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4612                 }
4613         }
4614         if (ndr_flags & NDR_BUFFERS) {
4615                 int level = ndr_push_get_switch_value(ndr, r);
4616                 switch (level) {
4617                         case 1:
4618                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4619                         break;
4620
4621                         default:
4622                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4623                 }
4624         }
4625         return NDR_ERR_SUCCESS;
4626 }
4627
4628 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4629 {
4630         int level;
4631         int32_t _level;
4632         level = ndr_pull_get_switch_value(ndr, r);
4633         if (ndr_flags & NDR_SCALARS) {
4634                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4635                 if (_level != level) {
4636                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4637                 }
4638                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4639                 switch (level) {
4640                         case 1: {
4641                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4642                         break; }
4643
4644                         default:
4645                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4646                 }
4647         }
4648         if (ndr_flags & NDR_BUFFERS) {
4649                 switch (level) {
4650                         case 1:
4651                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4652                         break;
4653
4654                         default:
4655                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4656                 }
4657         }
4658         return NDR_ERR_SUCCESS;
4659 }
4660
4661 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4662 {
4663         int level;
4664         level = ndr_print_get_switch_value(ndr, r);
4665         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4666         switch (level) {
4667                 case 1:
4668                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4669                 break;
4670
4671                 default:
4672                         ndr_print_bad_level(ndr, name, level);
4673         }
4674 }
4675
4676 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4677 {
4678         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4679         return NDR_ERR_SUCCESS;
4680 }
4681
4682 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4683 {
4684         uint32_t v;
4685         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4686         *r = v;
4687         return NDR_ERR_SUCCESS;
4688 }
4689
4690 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4691 {
4692         const char *val = NULL;
4693
4694         switch (r) {
4695                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4696                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4697                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4698                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4699                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4700                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4701                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4702         }
4703         ndr_print_enum(ndr, name, "ENUM", val, r);
4704 }
4705
4706 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4707 {
4708         uint32_t cntr_info_array_1;
4709         uint32_t cntr_group_attrs_1;
4710         uint32_t cntr_sids_1;
4711         if (ndr_flags & NDR_SCALARS) {
4712                 NDR_CHECK(ndr_push_align(ndr, 5));
4713                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4719                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4720         }
4721         if (ndr_flags & NDR_BUFFERS) {
4722                 if (r->info_array) {
4723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4724                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4725                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4726                         }
4727                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4728                                 if (r->info_array[cntr_info_array_1]) {
4729                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4730                                 }
4731                         }
4732                 }
4733                 if (r->group_attrs) {
4734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4735                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4736                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4737                         }
4738                 }
4739                 if (r->sids) {
4740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4741                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4742                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4743                         }
4744                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4745                                 if (r->sids[cntr_sids_1]) {
4746                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4747                                 }
4748                         }
4749                 }
4750         }
4751         return NDR_ERR_SUCCESS;
4752 }
4753
4754 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4755 {
4756         uint32_t _ptr_info_array;
4757         uint32_t cntr_info_array_1;
4758         TALLOC_CTX *_mem_save_info_array_0;
4759         TALLOC_CTX *_mem_save_info_array_1;
4760         TALLOC_CTX *_mem_save_info_array_2;
4761         uint32_t _ptr_group_attrs;
4762         uint32_t cntr_group_attrs_1;
4763         TALLOC_CTX *_mem_save_group_attrs_0;
4764         TALLOC_CTX *_mem_save_group_attrs_1;
4765         uint32_t _ptr_sids;
4766         uint32_t cntr_sids_1;
4767         TALLOC_CTX *_mem_save_sids_0;
4768         TALLOC_CTX *_mem_save_sids_1;
4769         TALLOC_CTX *_mem_save_sids_2;
4770         if (ndr_flags & NDR_SCALARS) {
4771                 NDR_CHECK(ndr_pull_align(ndr, 5));
4772                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4774                 if (r->num_memberships > 10000) {
4775                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4776                 }
4777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4778                 if (r->num_sids > 10000) {
4779                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4780                 }
4781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4782                 if (_ptr_info_array) {
4783                         NDR_PULL_ALLOC(ndr, r->info_array);
4784                 } else {
4785                         r->info_array = NULL;
4786                 }
4787                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4788                 if (_ptr_group_attrs) {
4789                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4790                 } else {
4791                         r->group_attrs = NULL;
4792                 }
4793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4794                 if (_ptr_sids) {
4795                         NDR_PULL_ALLOC(ndr, r->sids);
4796                 } else {
4797                         r->sids = NULL;
4798                 }
4799                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4800         }
4801         if (ndr_flags & NDR_BUFFERS) {
4802                 if (r->info_array) {
4803                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4804                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4806                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4807                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4808                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4809                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4810                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4811                                 if (_ptr_info_array) {
4812                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4813                                 } else {
4814                                         r->info_array[cntr_info_array_1] = NULL;
4815                                 }
4816                         }
4817                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4818                                 if (r->info_array[cntr_info_array_1]) {
4819                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4820                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4821                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4822                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4823                                 }
4824                         }
4825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4826                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4827                 }
4828                 if (r->group_attrs) {
4829                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4830                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4831                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4832                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4833                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4834                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4835                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4836                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4837                         }
4838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4840                 }
4841                 if (r->sids) {
4842                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4843                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4844                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4845                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4846                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4847                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4848                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4849                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4850                                 if (_ptr_sids) {
4851                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4852                                 } else {
4853                                         r->sids[cntr_sids_1] = NULL;
4854                                 }
4855                         }
4856                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4857                                 if (r->sids[cntr_sids_1]) {
4858                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4859                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4860                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4861                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4862                                 }
4863                         }
4864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4865                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4866                 }
4867                 if (r->info_array) {
4868                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4869                 }
4870                 if (r->group_attrs) {
4871                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4872                 }
4873                 if (r->sids) {
4874                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4875                 }
4876         }
4877         return NDR_ERR_SUCCESS;
4878 }
4879
4880 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4881 {
4882         uint32_t cntr_info_array_1;
4883         uint32_t cntr_group_attrs_1;
4884         uint32_t cntr_sids_1;
4885         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4886         ndr->depth++;
4887         ndr_print_NTSTATUS(ndr, "status", r->status);
4888         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4889         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4890         ndr_print_ptr(ndr, "info_array", r->info_array);
4891         ndr->depth++;
4892         if (r->info_array) {
4893                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4894                 ndr->depth++;
4895                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4896                         char *idx_1=NULL;
4897                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4898                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4899                                 ndr->depth++;
4900                                 if (r->info_array[cntr_info_array_1]) {
4901                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4902                                 }
4903                                 ndr->depth--;
4904                                 free(idx_1);
4905                         }
4906                 }
4907                 ndr->depth--;
4908         }
4909         ndr->depth--;
4910         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4911         ndr->depth++;
4912         if (r->group_attrs) {
4913                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4914                 ndr->depth++;
4915                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4916                         char *idx_1=NULL;
4917                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4918                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4919                                 free(idx_1);
4920                         }
4921                 }
4922                 ndr->depth--;
4923         }
4924         ndr->depth--;
4925         ndr_print_ptr(ndr, "sids", r->sids);
4926         ndr->depth++;
4927         if (r->sids) {
4928                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4929                 ndr->depth++;
4930                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4931                         char *idx_1=NULL;
4932                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4933                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4934                                 ndr->depth++;
4935                                 if (r->sids[cntr_sids_1]) {
4936                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4937                                 }
4938                                 ndr->depth--;
4939                                 free(idx_1);
4940                         }
4941                 }
4942                 ndr->depth--;
4943         }
4944         ndr->depth--;
4945         ndr->depth--;
4946 }
4947
4948 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4949 {
4950         if (ndr_flags & NDR_SCALARS) {
4951                 int level = ndr_push_get_switch_value(ndr, r);
4952                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4953                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4954                 switch (level) {
4955                         case 1: {
4956                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4957                         break; }
4958
4959                         default:
4960                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4961                 }
4962         }
4963         if (ndr_flags & NDR_BUFFERS) {
4964                 int level = ndr_push_get_switch_value(ndr, r);
4965                 switch (level) {
4966                         case 1:
4967                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4968                         break;
4969
4970                         default:
4971                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4972                 }
4973         }
4974         return NDR_ERR_SUCCESS;
4975 }
4976
4977 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4978 {
4979         int level;
4980         int32_t _level;
4981         level = ndr_pull_get_switch_value(ndr, r);
4982         if (ndr_flags & NDR_SCALARS) {
4983                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4984                 if (_level != level) {
4985                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4986                 }
4987                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4988                 switch (level) {
4989                         case 1: {
4990                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4991                         break; }
4992
4993                         default:
4994                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4995                 }
4996         }
4997         if (ndr_flags & NDR_BUFFERS) {
4998                 switch (level) {
4999                         case 1:
5000                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
5001                         break;
5002
5003                         default:
5004                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5005                 }
5006         }
5007         return NDR_ERR_SUCCESS;
5008 }
5009
5010 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
5011 {
5012         int level;
5013         level = ndr_print_get_switch_value(ndr, r);
5014         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
5015         switch (level) {
5016                 case 1:
5017                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
5018                 break;
5019
5020                 default:
5021                         ndr_print_bad_level(ndr, name, level);
5022         }
5023 }
5024
5025 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
5026 {
5027         uint32_t cntr_info_array_1;
5028         if (ndr_flags & NDR_SCALARS) {
5029                 NDR_CHECK(ndr_push_align(ndr, 5));
5030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
5032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
5033                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
5034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
5035                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5036         }
5037         if (ndr_flags & NDR_BUFFERS) {
5038                 if (r->info_array) {
5039                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5040                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5041                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
5042                         }
5043                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5044                                 if (r->info_array[cntr_info_array_1]) {
5045                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5046                                 }
5047                         }
5048                 }
5049                 if (r->domain) {
5050                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5051                 }
5052         }
5053         return NDR_ERR_SUCCESS;
5054 }
5055
5056 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5057 {
5058         uint32_t _ptr_info_array;
5059         uint32_t cntr_info_array_1;
5060         TALLOC_CTX *_mem_save_info_array_0;
5061         TALLOC_CTX *_mem_save_info_array_1;
5062         TALLOC_CTX *_mem_save_info_array_2;
5063         uint32_t _ptr_domain;
5064         TALLOC_CTX *_mem_save_domain_0;
5065         if (ndr_flags & NDR_SCALARS) {
5066                 NDR_CHECK(ndr_pull_align(ndr, 5));
5067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5068                 if (r->count < 1 || r->count > 10000) {
5069                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5070                 }
5071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5072                 if (_ptr_info_array) {
5073                         NDR_PULL_ALLOC(ndr, r->info_array);
5074                 } else {
5075                         r->info_array = NULL;
5076                 }
5077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5078                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
5079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
5080                 if (_ptr_domain) {
5081                         NDR_PULL_ALLOC(ndr, r->domain);
5082                 } else {
5083                         r->domain = NULL;
5084                 }
5085                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5086         }
5087         if (ndr_flags & NDR_BUFFERS) {
5088                 if (r->info_array) {
5089                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5090                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5091                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5092                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5093                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5094                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5095                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5096                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5097                                 if (_ptr_info_array) {
5098                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5099                                 } else {
5100                                         r->info_array[cntr_info_array_1] = NULL;
5101                                 }
5102                         }
5103                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5104                                 if (r->info_array[cntr_info_array_1]) {
5105                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5106                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5107                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5108                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5109                                 }
5110                         }
5111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5113                 }
5114                 if (r->domain) {
5115                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5116                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5117                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5119                 }
5120                 if (r->info_array) {
5121                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5122                 }
5123         }
5124         return NDR_ERR_SUCCESS;
5125 }
5126
5127 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5128 {
5129         uint32_t cntr_info_array_1;
5130         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5131         ndr->depth++;
5132         ndr_print_uint32(ndr, "count", r->count);
5133         ndr_print_ptr(ndr, "info_array", r->info_array);
5134         ndr->depth++;
5135         if (r->info_array) {
5136                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5137                 ndr->depth++;
5138                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5139                         char *idx_1=NULL;
5140                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5141                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5142                                 ndr->depth++;
5143                                 if (r->info_array[cntr_info_array_1]) {
5144                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5145                                 }
5146                                 ndr->depth--;
5147                                 free(idx_1);
5148                         }
5149                 }
5150                 ndr->depth--;
5151         }
5152         ndr->depth--;
5153         ndr_print_uint32(ndr, "flags", r->flags);
5154         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5155         ndr_print_ptr(ndr, "domain", r->domain);
5156         ndr->depth++;
5157         if (r->domain) {
5158                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5159         }
5160         ndr->depth--;
5161         ndr->depth--;
5162 }
5163
5164 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5165 {
5166         if (ndr_flags & NDR_SCALARS) {
5167                 int level = ndr_push_get_switch_value(ndr, r);
5168                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5169                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5170                 switch (level) {
5171                         case 1: {
5172                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5173                         break; }
5174
5175                         default:
5176                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5177                 }
5178         }
5179         if (ndr_flags & NDR_BUFFERS) {
5180                 int level = ndr_push_get_switch_value(ndr, r);
5181                 switch (level) {
5182                         case 1:
5183                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5184                         break;
5185
5186                         default:
5187                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5188                 }
5189         }
5190         return NDR_ERR_SUCCESS;
5191 }
5192
5193 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5194 {
5195         int level;
5196         int32_t _level;
5197         level = ndr_pull_get_switch_value(ndr, r);
5198         if (ndr_flags & NDR_SCALARS) {
5199                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5200                 if (_level != level) {
5201                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5202                 }
5203                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5204                 switch (level) {
5205                         case 1: {
5206                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5207                         break; }
5208
5209                         default:
5210                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5211                 }
5212         }
5213         if (ndr_flags & NDR_BUFFERS) {
5214                 switch (level) {
5215                         case 1:
5216                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5217                         break;
5218
5219                         default:
5220                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5221                 }
5222         }
5223         return NDR_ERR_SUCCESS;
5224 }
5225
5226 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5227 {
5228         int level;
5229         level = ndr_print_get_switch_value(ndr, r);
5230         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5231         switch (level) {
5232                 case 1:
5233                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5234                 break;
5235
5236                 default:
5237                         ndr_print_bad_level(ndr, name, level);
5238         }
5239 }
5240
5241 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5242 {
5243         if (ndr_flags & NDR_SCALARS) {
5244                 NDR_CHECK(ndr_push_align(ndr, 5));
5245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5248                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5249                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5250         }
5251         if (ndr_flags & NDR_BUFFERS) {
5252                 if (r->data) {
5253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5254                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5255                 }
5256         }
5257         return NDR_ERR_SUCCESS;
5258 }
5259
5260 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5261 {
5262         uint32_t _ptr_data;
5263         TALLOC_CTX *_mem_save_data_0;
5264         if (ndr_flags & NDR_SCALARS) {
5265                 NDR_CHECK(ndr_pull_align(ndr, 5));
5266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5269                 if (r->length > 0x00A00000) {
5270                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5271                 }
5272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5273                 if (_ptr_data) {
5274                         NDR_PULL_ALLOC(ndr, r->data);
5275                 } else {
5276                         r->data = NULL;
5277                 }
5278                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5279         }
5280         if (ndr_flags & NDR_BUFFERS) {
5281                 if (r->data) {
5282                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5283                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5284                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5285                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5286                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5288                 }
5289                 if (r->data) {
5290                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5291                 }
5292         }
5293         return NDR_ERR_SUCCESS;
5294 }
5295
5296 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5297 {
5298         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5299         ndr->depth++;
5300         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5301         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5302         ndr_print_uint32(ndr, "length", r->length);
5303         ndr_print_ptr(ndr, "data", r->data);
5304         ndr->depth++;
5305         if (r->data) {
5306                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5307         }
5308         ndr->depth--;
5309         ndr->depth--;
5310 }
5311
5312 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5313 {
5314         if (ndr_flags & NDR_SCALARS) {
5315                 int level = ndr_push_get_switch_value(ndr, r);
5316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5317                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5318                 switch (level) {
5319                         case 1: {
5320                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5321                         break; }
5322
5323                         default:
5324                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5325                 }
5326         }
5327         if (ndr_flags & NDR_BUFFERS) {
5328                 int level = ndr_push_get_switch_value(ndr, r);
5329                 switch (level) {
5330                         case 1:
5331                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5332                         break;
5333
5334                         default:
5335                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5336                 }
5337         }
5338         return NDR_ERR_SUCCESS;
5339 }
5340
5341 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5342 {
5343         int level;
5344         uint32_t _level;
5345         level = ndr_pull_get_switch_value(ndr, r);
5346         if (ndr_flags & NDR_SCALARS) {
5347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5348                 if (_level != level) {
5349                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5350                 }
5351                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5352                 switch (level) {
5353                         case 1: {
5354                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5355                         break; }
5356
5357                         default:
5358                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5359                 }
5360         }
5361         if (ndr_flags & NDR_BUFFERS) {
5362                 switch (level) {
5363                         case 1:
5364                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5365                         break;
5366
5367                         default:
5368                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5369                 }
5370         }
5371         return NDR_ERR_SUCCESS;
5372 }
5373
5374 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5375 {
5376         int level;
5377         level = ndr_print_get_switch_value(ndr, r);
5378         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5379         switch (level) {
5380                 case 1:
5381                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5382                 break;
5383
5384                 default:
5385                         ndr_print_bad_level(ndr, name, level);
5386         }
5387 }
5388
5389 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5390 {
5391         if (ndr_flags & NDR_SCALARS) {
5392                 NDR_CHECK(ndr_push_align(ndr, 8));
5393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5395                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5396                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5397                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5398                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5399                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5400                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5401                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5402                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5404                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5405         }
5406         if (ndr_flags & NDR_BUFFERS) {
5407                 if (r->data1) {
5408                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5409                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5410                 }
5411                 if (r->data2) {
5412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5413                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5414                 }
5415         }
5416         return NDR_ERR_SUCCESS;
5417 }
5418
5419 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5420 {
5421         uint32_t _ptr_data1;
5422         TALLOC_CTX *_mem_save_data1_0;
5423         uint32_t _ptr_data2;
5424         TALLOC_CTX *_mem_save_data2_0;
5425         if (ndr_flags & NDR_SCALARS) {
5426                 NDR_CHECK(ndr_pull_align(ndr, 8));
5427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5428                 if (r->length1 > 0x00A00000) {
5429                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5430                 }
5431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5432                 if (r->length2 > 0x00A00000) {
5433                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5434                 }
5435                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5436                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5437                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5438                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5439                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5440                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5441                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5443                 if (_ptr_data1) {
5444                         NDR_PULL_ALLOC(ndr, r->data1);
5445                 } else {
5446                         r->data1 = NULL;
5447                 }
5448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5449                 if (_ptr_data2) {
5450                         NDR_PULL_ALLOC(ndr, r->data2);
5451                 } else {
5452                         r->data2 = NULL;
5453                 }
5454                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5455         }
5456         if (ndr_flags & NDR_BUFFERS) {
5457                 if (r->data1) {
5458                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5459                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5460                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5461                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5462                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5463                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5464                 }
5465                 if (r->data2) {
5466                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5467                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5469                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5470                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5471                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5472                 }
5473                 if (r->data1) {
5474                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5475                 }
5476                 if (r->data2) {
5477                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5478                 }
5479         }
5480         return NDR_ERR_SUCCESS;
5481 }
5482
5483 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5484 {
5485         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5486         ndr->depth++;
5487         ndr_print_uint32(ndr, "length1", r->length1);
5488         ndr_print_uint32(ndr, "length2", r->length2);
5489         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5490         ndr_print_NTTIME(ndr, "time2", r->time2);
5491         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5492         ndr_print_NTTIME(ndr, "time4", r->time4);
5493         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5494         ndr_print_NTTIME(ndr, "time6", r->time6);
5495         ndr_print_NTSTATUS(ndr, "status", r->status);
5496         ndr_print_ptr(ndr, "data1", r->data1);
5497         ndr->depth++;
5498         if (r->data1) {
5499                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5500         }
5501         ndr->depth--;
5502         ndr_print_ptr(ndr, "data2", r->data2);
5503         ndr->depth++;
5504         if (r->data2) {
5505                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5506         }
5507         ndr->depth--;
5508         ndr->depth--;
5509 }
5510
5511 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5512 {
5513         if (ndr_flags & NDR_SCALARS) {
5514                 int level = ndr_push_get_switch_value(ndr, r);
5515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5516                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5517                 switch (level) {
5518                         case 1: {
5519                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5520                         break; }
5521
5522                         default:
5523                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5524                 }
5525         }
5526         if (ndr_flags & NDR_BUFFERS) {
5527                 int level = ndr_push_get_switch_value(ndr, r);
5528                 switch (level) {
5529                         case 1:
5530                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5531                         break;
5532
5533                         default:
5534                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5535                 }
5536         }
5537         return NDR_ERR_SUCCESS;
5538 }
5539
5540 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5541 {
5542         int level;
5543         uint32_t _level;
5544         level = ndr_pull_get_switch_value(ndr, r);
5545         if (ndr_flags & NDR_SCALARS) {
5546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5547                 if (_level != level) {
5548                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5549                 }
5550                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5551                 switch (level) {
5552                         case 1: {
5553                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5554                         break; }
5555
5556                         default:
5557                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5558                 }
5559         }
5560         if (ndr_flags & NDR_BUFFERS) {
5561                 switch (level) {
5562                         case 1:
5563                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5564                         break;
5565
5566                         default:
5567                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5568                 }
5569         }
5570         return NDR_ERR_SUCCESS;
5571 }
5572
5573 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5574 {
5575         int level;
5576         level = ndr_print_get_switch_value(ndr, r);
5577         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5578         switch (level) {
5579                 case 1:
5580                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5581                 break;
5582
5583                 default:
5584                         ndr_print_bad_level(ndr, name, level);
5585         }
5586 }
5587
5588 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5589 {
5590         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5591         return NDR_ERR_SUCCESS;
5592 }
5593
5594 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5595 {
5596         uint32_t v;
5597         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5598         *r = v;
5599         return NDR_ERR_SUCCESS;
5600 }
5601
5602 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5603 {
5604         const char *val = NULL;
5605
5606         switch (r) {
5607                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5608                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5609                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5610                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5611                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5612                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5613                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5614                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5615         }
5616         ndr_print_enum(ndr, name, "ENUM", val, r);
5617 }
5618
5619 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5620 {
5621         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5622         return NDR_ERR_SUCCESS;
5623 }
5624
5625 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5626 {
5627         uint32_t v;
5628         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5629         *r = v;
5630         return NDR_ERR_SUCCESS;
5631 }
5632
5633 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5634 {
5635         const char *val = NULL;
5636
5637         switch (r) {
5638                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5639                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5640                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5641                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5642                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5643         }
5644         ndr_print_enum(ndr, name, "ENUM", val, r);
5645 }
5646
5647 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5648 {
5649         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5650         return NDR_ERR_SUCCESS;
5651 }
5652
5653 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5654 {
5655         uint32_t v;
5656         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5657         *r = v;
5658         return NDR_ERR_SUCCESS;
5659 }
5660
5661 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5662 {
5663         const char *val = NULL;
5664
5665         switch (r) {
5666                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5667                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5668                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5669                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5670                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5671                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5672                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5673                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5674                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5675                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5676                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5677         }
5678         ndr_print_enum(ndr, name, "ENUM", val, r);
5679 }
5680
5681 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5682 {
5683         if (ndr_flags & NDR_SCALARS) {
5684                 NDR_CHECK(ndr_push_align(ndr, 5));
5685                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5686                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5687         }
5688         if (ndr_flags & NDR_BUFFERS) {
5689                 if (r->str) {
5690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5691                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5693                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5694                 }
5695         }
5696         return NDR_ERR_SUCCESS;
5697 }
5698
5699 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5700 {
5701         uint32_t _ptr_str;
5702         TALLOC_CTX *_mem_save_str_0;
5703         if (ndr_flags & NDR_SCALARS) {
5704                 NDR_CHECK(ndr_pull_align(ndr, 5));
5705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5706                 if (_ptr_str) {
5707                         NDR_PULL_ALLOC(ndr, r->str);
5708                 } else {
5709                         r->str = NULL;
5710                 }
5711                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5712         }
5713         if (ndr_flags & NDR_BUFFERS) {
5714                 if (r->str) {
5715                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5716                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5718                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5719                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5720                                 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));
5721                         }
5722                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5723                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5725                 }
5726         }
5727         return NDR_ERR_SUCCESS;
5728 }
5729
5730 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5731 {
5732         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5733         ndr->depth++;
5734         ndr_print_ptr(ndr, "str", r->str);
5735         ndr->depth++;
5736         if (r->str) {
5737                 ndr_print_string(ndr, "str", r->str);
5738         }
5739         ndr->depth--;
5740         ndr->depth--;
5741 }
5742
5743 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5744 {
5745         uint32_t cntr_names_1;
5746         if (ndr_flags & NDR_SCALARS) {
5747                 NDR_CHECK(ndr_push_align(ndr, 5));
5748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5750                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5751                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5752                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5755                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5756         }
5757         if (ndr_flags & NDR_BUFFERS) {
5758                 if (r->names) {
5759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5760                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5761                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5762                         }
5763                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5764                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5765                         }
5766                 }
5767         }
5768         return NDR_ERR_SUCCESS;
5769 }
5770
5771 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5772 {
5773         uint32_t _ptr_names;
5774         uint32_t cntr_names_1;
5775         TALLOC_CTX *_mem_save_names_0;
5776         TALLOC_CTX *_mem_save_names_1;
5777         if (ndr_flags & NDR_SCALARS) {
5778                 NDR_CHECK(ndr_pull_align(ndr, 5));
5779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5781                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5782                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5783                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5785                 if (r->count < 1 || r->count > 10000) {
5786                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5787                 }
5788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5789                 if (_ptr_names) {
5790                         NDR_PULL_ALLOC(ndr, r->names);
5791                 } else {
5792                         r->names = NULL;
5793                 }
5794                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5795         }
5796         if (ndr_flags & NDR_BUFFERS) {
5797                 if (r->names) {
5798                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5799                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5801                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5802                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5803                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5804                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5805                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5806                         }
5807                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5808                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5809                         }
5810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5812                 }
5813                 if (r->names) {
5814                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5815                 }
5816         }
5817         return NDR_ERR_SUCCESS;
5818 }
5819
5820 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5821 {
5822         uint32_t cntr_names_1;
5823         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5824         ndr->depth++;
5825         ndr_print_uint32(ndr, "codepage", r->codepage);
5826         ndr_print_uint32(ndr, "language", r->language);
5827         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5828         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5829         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5830         ndr_print_uint32(ndr, "count", r->count);
5831         ndr_print_ptr(ndr, "names", r->names);
5832         ndr->depth++;
5833         if (r->names) {
5834                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5835                 ndr->depth++;
5836                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5837                         char *idx_1=NULL;
5838                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5839                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5840                                 free(idx_1);
5841                         }
5842                 }
5843                 ndr->depth--;
5844         }
5845         ndr->depth--;
5846         ndr->depth--;
5847 }
5848
5849 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5850 {
5851         if (ndr_flags & NDR_SCALARS) {
5852                 int level = ndr_push_get_switch_value(ndr, r);
5853                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5854                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5855                 switch (level) {
5856                         case 1: {
5857                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5858                         break; }
5859
5860                         default:
5861                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5862                 }
5863         }
5864         if (ndr_flags & NDR_BUFFERS) {
5865                 int level = ndr_push_get_switch_value(ndr, r);
5866                 switch (level) {
5867                         case 1:
5868                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5869                         break;
5870
5871                         default:
5872                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5873                 }
5874         }
5875         return NDR_ERR_SUCCESS;
5876 }
5877
5878 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5879 {
5880         int level;
5881         int32_t _level;
5882         level = ndr_pull_get_switch_value(ndr, r);
5883         if (ndr_flags & NDR_SCALARS) {
5884                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5885                 if (_level != level) {
5886                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5887                 }
5888                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5889                 switch (level) {
5890                         case 1: {
5891                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5892                         break; }
5893
5894                         default:
5895                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5896                 }
5897         }
5898         if (ndr_flags & NDR_BUFFERS) {
5899                 switch (level) {
5900                         case 1:
5901                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5902                         break;
5903
5904                         default:
5905                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5906                 }
5907         }
5908         return NDR_ERR_SUCCESS;
5909 }
5910
5911 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5912 {
5913         int level;
5914         level = ndr_print_get_switch_value(ndr, r);
5915         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5916         switch (level) {
5917                 case 1:
5918                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5919                 break;
5920
5921                 default:
5922                         ndr_print_bad_level(ndr, name, level);
5923         }
5924 }
5925
5926 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5927 {
5928         if (ndr_flags & NDR_SCALARS) {
5929                 NDR_CHECK(ndr_push_align(ndr, 5));
5930                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5931                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5932                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5933                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5934         }
5935         if (ndr_flags & NDR_BUFFERS) {
5936                 if (r->dns_domain_name) {
5937                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5940                         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));
5941                 }
5942                 if (r->result_name) {
5943                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5944                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5945                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5946                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5947                 }
5948         }
5949         return NDR_ERR_SUCCESS;
5950 }
5951
5952 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5953 {
5954         uint32_t _ptr_dns_domain_name;
5955         TALLOC_CTX *_mem_save_dns_domain_name_0;
5956         uint32_t _ptr_result_name;
5957         TALLOC_CTX *_mem_save_result_name_0;
5958         if (ndr_flags & NDR_SCALARS) {
5959                 NDR_CHECK(ndr_pull_align(ndr, 5));
5960                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5961                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5962                 if (_ptr_dns_domain_name) {
5963                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5964                 } else {
5965                         r->dns_domain_name = NULL;
5966                 }
5967                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5968                 if (_ptr_result_name) {
5969                         NDR_PULL_ALLOC(ndr, r->result_name);
5970                 } else {
5971                         r->result_name = NULL;
5972                 }
5973                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5974         }
5975         if (ndr_flags & NDR_BUFFERS) {
5976                 if (r->dns_domain_name) {
5977                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5978                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5979                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5980                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5981                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5982                                 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));
5983                         }
5984                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5985                         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));
5986                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5987                 }
5988                 if (r->result_name) {
5989                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5990                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5991                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5992                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5993                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5994                                 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));
5995                         }
5996                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5997                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5998                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5999                 }
6000         }
6001         return NDR_ERR_SUCCESS;
6002 }
6003
6004 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
6005 {
6006         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
6007         ndr->depth++;
6008         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
6009         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
6010         ndr->depth++;
6011         if (r->dns_domain_name) {
6012                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
6013         }
6014         ndr->depth--;
6015         ndr_print_ptr(ndr, "result_name", r->result_name);
6016         ndr->depth++;
6017         if (r->result_name) {
6018                 ndr_print_string(ndr, "result_name", r->result_name);
6019         }
6020         ndr->depth--;
6021         ndr->depth--;
6022 }
6023
6024 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
6025 {
6026         uint32_t cntr_array_1;
6027         if (ndr_flags & NDR_SCALARS) {
6028                 NDR_CHECK(ndr_push_align(ndr, 5));
6029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6031                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6032         }
6033         if (ndr_flags & NDR_BUFFERS) {
6034                 if (r->array) {
6035                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6036                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6037                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6038                         }
6039                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6040                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6041                         }
6042                 }
6043         }
6044         return NDR_ERR_SUCCESS;
6045 }
6046
6047 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6048 {
6049         uint32_t _ptr_array;
6050         uint32_t cntr_array_1;
6051         TALLOC_CTX *_mem_save_array_0;
6052         TALLOC_CTX *_mem_save_array_1;
6053         if (ndr_flags & NDR_SCALARS) {
6054                 NDR_CHECK(ndr_pull_align(ndr, 5));
6055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6056                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6057                 if (_ptr_array) {
6058                         NDR_PULL_ALLOC(ndr, r->array);
6059                 } else {
6060                         r->array = NULL;
6061                 }
6062                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6063         }
6064         if (ndr_flags & NDR_BUFFERS) {
6065                 if (r->array) {
6066                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6067                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6069                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6070                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6071                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6072                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6073                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6074                         }
6075                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6076                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6077                         }
6078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6080                 }
6081                 if (r->array) {
6082                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6083                 }
6084         }
6085         return NDR_ERR_SUCCESS;
6086 }
6087
6088 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6089 {
6090         uint32_t cntr_array_1;
6091         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6092         ndr->depth++;
6093         ndr_print_uint32(ndr, "count", r->count);
6094         ndr_print_ptr(ndr, "array", r->array);
6095         ndr->depth++;
6096         if (r->array) {
6097                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6098                 ndr->depth++;
6099                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6100                         char *idx_1=NULL;
6101                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6102                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6103                                 free(idx_1);
6104                         }
6105                 }
6106                 ndr->depth--;
6107         }
6108         ndr->depth--;
6109         ndr->depth--;
6110 }
6111
6112 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6113 {
6114         if (ndr_flags & NDR_SCALARS) {
6115                 int level = ndr_push_get_switch_value(ndr, r);
6116                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6117                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6118                 switch (level) {
6119                         case 1: {
6120                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6121                         break; }
6122
6123                         default:
6124                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6125                 }
6126         }
6127         if (ndr_flags & NDR_BUFFERS) {
6128                 int level = ndr_push_get_switch_value(ndr, r);
6129                 switch (level) {
6130                         case 1:
6131                                 if (r->ctr1) {
6132                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6133                                 }
6134                         break;
6135
6136                         default:
6137                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6138                 }
6139         }
6140         return NDR_ERR_SUCCESS;
6141 }
6142
6143 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6144 {
6145         int level;
6146         int32_t _level;
6147         TALLOC_CTX *_mem_save_ctr1_0;
6148         level = ndr_pull_get_switch_value(ndr, r);
6149         if (ndr_flags & NDR_SCALARS) {
6150                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6151                 if (_level != level) {
6152                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6153                 }
6154                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6155                 switch (level) {
6156                         case 1: {
6157                                 uint32_t _ptr_ctr1;
6158                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6159                                 if (_ptr_ctr1) {
6160                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6161                                 } else {
6162                                         r->ctr1 = NULL;
6163                                 }
6164                         break; }
6165
6166                         default:
6167                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6168                 }
6169         }
6170         if (ndr_flags & NDR_BUFFERS) {
6171                 switch (level) {
6172                         case 1:
6173                                 if (r->ctr1) {
6174                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6175                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6176                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6177                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6178                                 }
6179                         break;
6180
6181                         default:
6182                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6183                 }
6184         }
6185         return NDR_ERR_SUCCESS;
6186 }
6187
6188 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6189 {
6190         int level;
6191         level = ndr_print_get_switch_value(ndr, r);
6192         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6193         switch (level) {
6194                 case 1:
6195                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6196                         ndr->depth++;
6197                         if (r->ctr1) {
6198                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6199                         }
6200                         ndr->depth--;
6201                 break;
6202
6203                 default:
6204                         ndr_print_bad_level(ndr, name, level);
6205         }
6206 }
6207
6208 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6209 {
6210         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6211         return NDR_ERR_SUCCESS;
6212 }
6213
6214 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6215 {
6216         uint32_t v;
6217         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6218         *r = v;
6219         return NDR_ERR_SUCCESS;
6220 }
6221
6222 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6223 {
6224         const char *val = NULL;
6225
6226         switch (r) {
6227                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6228                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6229                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6230         }
6231         ndr_print_enum(ndr, name, "ENUM", val, r);
6232 }
6233
6234 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6235 {
6236         uint32_t cntr_spn_names_1;
6237         if (ndr_flags & NDR_SCALARS) {
6238                 NDR_CHECK(ndr_push_align(ndr, 5));
6239                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6243                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6244                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6245         }
6246         if (ndr_flags & NDR_BUFFERS) {
6247                 if (r->object_dn) {
6248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6252                 }
6253                 if (r->spn_names) {
6254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6255                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6256                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6257                         }
6258                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6259                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6260                         }
6261                 }
6262         }
6263         return NDR_ERR_SUCCESS;
6264 }
6265
6266 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6267 {
6268         uint32_t _ptr_object_dn;
6269         TALLOC_CTX *_mem_save_object_dn_0;
6270         uint32_t _ptr_spn_names;
6271         uint32_t cntr_spn_names_1;
6272         TALLOC_CTX *_mem_save_spn_names_0;
6273         TALLOC_CTX *_mem_save_spn_names_1;
6274         if (ndr_flags & NDR_SCALARS) {
6275                 NDR_CHECK(ndr_pull_align(ndr, 5));
6276                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6279                 if (_ptr_object_dn) {
6280                         NDR_PULL_ALLOC(ndr, r->object_dn);
6281                 } else {
6282                         r->object_dn = NULL;
6283                 }
6284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6285                 if (r->count > 10000) {
6286                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6287                 }
6288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6289                 if (_ptr_spn_names) {
6290                         NDR_PULL_ALLOC(ndr, r->spn_names);
6291                 } else {
6292                         r->spn_names = NULL;
6293                 }
6294                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6295         }
6296         if (ndr_flags & NDR_BUFFERS) {
6297                 if (r->object_dn) {
6298                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6299                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6300                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6301                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6302                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6303                                 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));
6304                         }
6305                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6306                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6308                 }
6309                 if (r->spn_names) {
6310                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6311                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6312                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6313                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6314                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6315                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6316                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6317                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6318                         }
6319                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6320                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6321                         }
6322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6324                 }
6325                 if (r->spn_names) {
6326                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6327                 }
6328         }
6329         return NDR_ERR_SUCCESS;
6330 }
6331
6332 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6333 {
6334         uint32_t cntr_spn_names_1;
6335         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6336         ndr->depth++;
6337         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6338         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6339         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6340         ndr->depth++;
6341         if (r->object_dn) {
6342                 ndr_print_string(ndr, "object_dn", r->object_dn);
6343         }
6344         ndr->depth--;
6345         ndr_print_uint32(ndr, "count", r->count);
6346         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6347         ndr->depth++;
6348         if (r->spn_names) {
6349                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6350                 ndr->depth++;
6351                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6352                         char *idx_1=NULL;
6353                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6354                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6355                                 free(idx_1);
6356                         }
6357                 }
6358                 ndr->depth--;
6359         }
6360         ndr->depth--;
6361         ndr->depth--;
6362 }
6363
6364 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6365 {
6366         if (ndr_flags & NDR_SCALARS) {
6367                 int level = ndr_push_get_switch_value(ndr, r);
6368                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6369                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6370                 switch (level) {
6371                         case 1: {
6372                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6373                         break; }
6374
6375                         default:
6376                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6377                 }
6378         }
6379         if (ndr_flags & NDR_BUFFERS) {
6380                 int level = ndr_push_get_switch_value(ndr, r);
6381                 switch (level) {
6382                         case 1:
6383                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6384                         break;
6385
6386                         default:
6387                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6388                 }
6389         }
6390         return NDR_ERR_SUCCESS;
6391 }
6392
6393 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6394 {
6395         int level;
6396         int32_t _level;
6397         level = ndr_pull_get_switch_value(ndr, r);
6398         if (ndr_flags & NDR_SCALARS) {
6399                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6400                 if (_level != level) {
6401                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6402                 }
6403                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6404                 switch (level) {
6405                         case 1: {
6406                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6407                         break; }
6408
6409                         default:
6410                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6411                 }
6412         }
6413         if (ndr_flags & NDR_BUFFERS) {
6414                 switch (level) {
6415                         case 1:
6416                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6417                         break;
6418
6419                         default:
6420                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6421                 }
6422         }
6423         return NDR_ERR_SUCCESS;
6424 }
6425
6426 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6427 {
6428         int level;
6429         level = ndr_print_get_switch_value(ndr, r);
6430         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6431         switch (level) {
6432                 case 1:
6433                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6434                 break;
6435
6436                 default:
6437                         ndr_print_bad_level(ndr, name, level);
6438         }
6439 }
6440
6441 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6442 {
6443         if (ndr_flags & NDR_SCALARS) {
6444                 NDR_CHECK(ndr_push_align(ndr, 4));
6445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6446                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6447         }
6448         if (ndr_flags & NDR_BUFFERS) {
6449         }
6450         return NDR_ERR_SUCCESS;
6451 }
6452
6453 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6454 {
6455         if (ndr_flags & NDR_SCALARS) {
6456                 NDR_CHECK(ndr_pull_align(ndr, 4));
6457                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6458                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6459         }
6460         if (ndr_flags & NDR_BUFFERS) {
6461         }
6462         return NDR_ERR_SUCCESS;
6463 }
6464
6465 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6466 {
6467         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6468         ndr->depth++;
6469         ndr_print_WERROR(ndr, "status", r->status);
6470         ndr->depth--;
6471 }
6472
6473 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6474 {
6475         if (ndr_flags & NDR_SCALARS) {
6476                 int level = ndr_push_get_switch_value(ndr, r);
6477                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6478                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6479                 switch (level) {
6480                         case 1: {
6481                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6482                         break; }
6483
6484                         default:
6485                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6486                 }
6487         }
6488         if (ndr_flags & NDR_BUFFERS) {
6489                 int level = ndr_push_get_switch_value(ndr, r);
6490                 switch (level) {
6491                         case 1:
6492                         break;
6493
6494                         default:
6495                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6496                 }
6497         }
6498         return NDR_ERR_SUCCESS;
6499 }
6500
6501 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6502 {
6503         int level;
6504         int32_t _level;
6505         level = ndr_pull_get_switch_value(ndr, r);
6506         if (ndr_flags & NDR_SCALARS) {
6507                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6508                 if (_level != level) {
6509                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6510                 }
6511                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6512                 switch (level) {
6513                         case 1: {
6514                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6515                         break; }
6516
6517                         default:
6518                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6519                 }
6520         }
6521         if (ndr_flags & NDR_BUFFERS) {
6522                 switch (level) {
6523                         case 1:
6524                         break;
6525
6526                         default:
6527                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6528                 }
6529         }
6530         return NDR_ERR_SUCCESS;
6531 }
6532
6533 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6534 {
6535         int level;
6536         level = ndr_print_get_switch_value(ndr, r);
6537         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6538         switch (level) {
6539                 case 1:
6540                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6541                 break;
6542
6543                 default:
6544                         ndr_print_bad_level(ndr, name, level);
6545         }
6546 }
6547
6548 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6549 {
6550         if (ndr_flags & NDR_SCALARS) {
6551                 NDR_CHECK(ndr_push_align(ndr, 5));
6552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6555                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6556         }
6557         if (ndr_flags & NDR_BUFFERS) {
6558                 if (r->server_dn) {
6559                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6560                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6561                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6562                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6563                 }
6564                 if (r->domain_dn) {
6565                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6566                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6567                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6568                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6569                 }
6570         }
6571         return NDR_ERR_SUCCESS;
6572 }
6573
6574 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6575 {
6576         uint32_t _ptr_server_dn;
6577         TALLOC_CTX *_mem_save_server_dn_0;
6578         uint32_t _ptr_domain_dn;
6579         TALLOC_CTX *_mem_save_domain_dn_0;
6580         if (ndr_flags & NDR_SCALARS) {
6581                 NDR_CHECK(ndr_pull_align(ndr, 5));
6582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6583                 if (_ptr_server_dn) {
6584                         NDR_PULL_ALLOC(ndr, r->server_dn);
6585                 } else {
6586                         r->server_dn = NULL;
6587                 }
6588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6589                 if (_ptr_domain_dn) {
6590                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6591                 } else {
6592                         r->domain_dn = NULL;
6593                 }
6594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6595                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6596         }
6597         if (ndr_flags & NDR_BUFFERS) {
6598                 if (r->server_dn) {
6599                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6600                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6601                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6602                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6603                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6604                                 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));
6605                         }
6606                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6607                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6608                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6609                 }
6610                 if (r->domain_dn) {
6611                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6612                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6613                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6614                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6615                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6616                                 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));
6617                         }
6618                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6619                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6621                 }
6622         }
6623         return NDR_ERR_SUCCESS;
6624 }
6625
6626 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6627 {
6628         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6629         ndr->depth++;
6630         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6631         ndr->depth++;
6632         if (r->server_dn) {
6633                 ndr_print_string(ndr, "server_dn", r->server_dn);
6634         }
6635         ndr->depth--;
6636         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6637         ndr->depth++;
6638         if (r->domain_dn) {
6639                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6640         }
6641         ndr->depth--;
6642         ndr_print_uint32(ndr, "commit", r->commit);
6643         ndr->depth--;
6644 }
6645
6646 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6647 {
6648         if (ndr_flags & NDR_SCALARS) {
6649                 int level = ndr_push_get_switch_value(ndr, r);
6650                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6651                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6652                 switch (level) {
6653                         case 1: {
6654                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6655                         break; }
6656
6657                         default:
6658                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6659                 }
6660         }
6661         if (ndr_flags & NDR_BUFFERS) {
6662                 int level = ndr_push_get_switch_value(ndr, r);
6663                 switch (level) {
6664                         case 1:
6665                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6666                         break;
6667
6668                         default:
6669                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6670                 }
6671         }
6672         return NDR_ERR_SUCCESS;
6673 }
6674
6675 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6676 {
6677         int level;
6678         int32_t _level;
6679         level = ndr_pull_get_switch_value(ndr, r);
6680         if (ndr_flags & NDR_SCALARS) {
6681                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6682                 if (_level != level) {
6683                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6684                 }
6685                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6686                 switch (level) {
6687                         case 1: {
6688                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6689                         break; }
6690
6691                         default:
6692                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6693                 }
6694         }
6695         if (ndr_flags & NDR_BUFFERS) {
6696                 switch (level) {
6697                         case 1:
6698                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6699                         break;
6700
6701                         default:
6702                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6703                 }
6704         }
6705         return NDR_ERR_SUCCESS;
6706 }
6707
6708 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6709 {
6710         int level;
6711         level = ndr_print_get_switch_value(ndr, r);
6712         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6713         switch (level) {
6714                 case 1:
6715                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6716                 break;
6717
6718                 default:
6719                         ndr_print_bad_level(ndr, name, level);
6720         }
6721 }
6722
6723 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6724 {
6725         if (ndr_flags & NDR_SCALARS) {
6726                 NDR_CHECK(ndr_push_align(ndr, 4));
6727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6728                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6729         }
6730         if (ndr_flags & NDR_BUFFERS) {
6731         }
6732         return NDR_ERR_SUCCESS;
6733 }
6734
6735 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6736 {
6737         if (ndr_flags & NDR_SCALARS) {
6738                 NDR_CHECK(ndr_pull_align(ndr, 4));
6739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6740                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6741         }
6742         if (ndr_flags & NDR_BUFFERS) {
6743         }
6744         return NDR_ERR_SUCCESS;
6745 }
6746
6747 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6748 {
6749         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6750         ndr->depth++;
6751         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6752         ndr->depth--;
6753 }
6754
6755 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6756 {
6757         if (ndr_flags & NDR_SCALARS) {
6758                 int level = ndr_push_get_switch_value(ndr, r);
6759                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6760                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6761                 switch (level) {
6762                         case 1: {
6763                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6764                         break; }
6765
6766                         default:
6767                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6768                 }
6769         }
6770         if (ndr_flags & NDR_BUFFERS) {
6771                 int level = ndr_push_get_switch_value(ndr, r);
6772                 switch (level) {
6773                         case 1:
6774                         break;
6775
6776                         default:
6777                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6778                 }
6779         }
6780         return NDR_ERR_SUCCESS;
6781 }
6782
6783 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6784 {
6785         int level;
6786         int32_t _level;
6787         level = ndr_pull_get_switch_value(ndr, r);
6788         if (ndr_flags & NDR_SCALARS) {
6789                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6790                 if (_level != level) {
6791                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6792                 }
6793                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6794                 switch (level) {
6795                         case 1: {
6796                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6797                         break; }
6798
6799                         default:
6800                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6801                 }
6802         }
6803         if (ndr_flags & NDR_BUFFERS) {
6804                 switch (level) {
6805                         case 1:
6806                         break;
6807
6808                         default:
6809                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6810                 }
6811         }
6812         return NDR_ERR_SUCCESS;
6813 }
6814
6815 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6816 {
6817         int level;
6818         level = ndr_print_get_switch_value(ndr, r);
6819         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6820         switch (level) {
6821                 case 1:
6822                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6823                 break;
6824
6825                 default:
6826                         ndr_print_bad_level(ndr, name, level);
6827         }
6828 }
6829
6830 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6831 {
6832         if (ndr_flags & NDR_SCALARS) {
6833                 NDR_CHECK(ndr_push_align(ndr, 5));
6834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6835                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6836                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6837         }
6838         if (ndr_flags & NDR_BUFFERS) {
6839                 if (r->domain_name) {
6840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6841                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6842                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6843                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6844                 }
6845         }
6846         return NDR_ERR_SUCCESS;
6847 }
6848
6849 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6850 {
6851         uint32_t _ptr_domain_name;
6852         TALLOC_CTX *_mem_save_domain_name_0;
6853         if (ndr_flags & NDR_SCALARS) {
6854                 NDR_CHECK(ndr_pull_align(ndr, 5));
6855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6856                 if (_ptr_domain_name) {
6857                         NDR_PULL_ALLOC(ndr, r->domain_name);
6858                 } else {
6859                         r->domain_name = NULL;
6860                 }
6861                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6862                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6863         }
6864         if (ndr_flags & NDR_BUFFERS) {
6865                 if (r->domain_name) {
6866                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6867                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6868                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6869                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6870                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6871                                 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));
6872                         }
6873                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6874                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6875                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6876                 }
6877         }
6878         return NDR_ERR_SUCCESS;
6879 }
6880
6881 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6882 {
6883         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6884         ndr->depth++;
6885         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6886         ndr->depth++;
6887         if (r->domain_name) {
6888                 ndr_print_string(ndr, "domain_name", r->domain_name);
6889         }
6890         ndr->depth--;
6891         ndr_print_int32(ndr, "level", r->level);
6892         ndr->depth--;
6893 }
6894
6895 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6896 {
6897         if (ndr_flags & NDR_SCALARS) {
6898                 int level = ndr_push_get_switch_value(ndr, r);
6899                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6900                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6901                 switch (level) {
6902                         case 1: {
6903                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6904                         break; }
6905
6906                         default:
6907                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6908                 }
6909         }
6910         if (ndr_flags & NDR_BUFFERS) {
6911                 int level = ndr_push_get_switch_value(ndr, r);
6912                 switch (level) {
6913                         case 1:
6914                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6915                         break;
6916
6917                         default:
6918                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6919                 }
6920         }
6921         return NDR_ERR_SUCCESS;
6922 }
6923
6924 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6925 {
6926         int level;
6927         int32_t _level;
6928         level = ndr_pull_get_switch_value(ndr, r);
6929         if (ndr_flags & NDR_SCALARS) {
6930                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6931                 if (_level != level) {
6932                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6933                 }
6934                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6935                 switch (level) {
6936                         case 1: {
6937                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6938                         break; }
6939
6940                         default:
6941                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6942                 }
6943         }
6944         if (ndr_flags & NDR_BUFFERS) {
6945                 switch (level) {
6946                         case 1:
6947                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6948                         break;
6949
6950                         default:
6951                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6952                 }
6953         }
6954         return NDR_ERR_SUCCESS;
6955 }
6956
6957 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6958 {
6959         int level;
6960         level = ndr_print_get_switch_value(ndr, r);
6961         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6962         switch (level) {
6963                 case 1:
6964                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6965                 break;
6966
6967                 default:
6968                         ndr_print_bad_level(ndr, name, level);
6969         }
6970 }
6971
6972 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6973 {
6974         if (ndr_flags & NDR_SCALARS) {
6975                 NDR_CHECK(ndr_push_align(ndr, 5));
6976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6977                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6978                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6979                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6983                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6984         }
6985         if (ndr_flags & NDR_BUFFERS) {
6986                 if (r->netbios_name) {
6987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6988                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6989                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6990                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6991                 }
6992                 if (r->dns_name) {
6993                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6996                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6997                 }
6998                 if (r->site_name) {
6999                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7000                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7002                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7003                 }
7004                 if (r->computer_dn) {
7005                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7006                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7007                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7008                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7009                 }
7010                 if (r->server_dn) {
7011                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7012                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7013                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7014                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7015                 }
7016         }
7017         return NDR_ERR_SUCCESS;
7018 }
7019
7020 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
7021 {
7022         uint32_t _ptr_netbios_name;
7023         TALLOC_CTX *_mem_save_netbios_name_0;
7024         uint32_t _ptr_dns_name;
7025         TALLOC_CTX *_mem_save_dns_name_0;
7026         uint32_t _ptr_site_name;
7027         TALLOC_CTX *_mem_save_site_name_0;
7028         uint32_t _ptr_computer_dn;
7029         TALLOC_CTX *_mem_save_computer_dn_0;
7030         uint32_t _ptr_server_dn;
7031         TALLOC_CTX *_mem_save_server_dn_0;
7032         if (ndr_flags & NDR_SCALARS) {
7033                 NDR_CHECK(ndr_pull_align(ndr, 5));
7034                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7035                 if (_ptr_netbios_name) {
7036                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7037                 } else {
7038                         r->netbios_name = NULL;
7039                 }
7040                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7041                 if (_ptr_dns_name) {
7042                         NDR_PULL_ALLOC(ndr, r->dns_name);
7043                 } else {
7044                         r->dns_name = NULL;
7045                 }
7046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7047                 if (_ptr_site_name) {
7048                         NDR_PULL_ALLOC(ndr, r->site_name);
7049                 } else {
7050                         r->site_name = NULL;
7051                 }
7052                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7053                 if (_ptr_computer_dn) {
7054                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7055                 } else {
7056                         r->computer_dn = NULL;
7057                 }
7058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7059                 if (_ptr_server_dn) {
7060                         NDR_PULL_ALLOC(ndr, r->server_dn);
7061                 } else {
7062                         r->server_dn = NULL;
7063                 }
7064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7066                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7067         }
7068         if (ndr_flags & NDR_BUFFERS) {
7069                 if (r->netbios_name) {
7070                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7071                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7074                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7075                                 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));
7076                         }
7077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7080                 }
7081                 if (r->dns_name) {
7082                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7083                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7086                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7087                                 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));
7088                         }
7089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7092                 }
7093                 if (r->site_name) {
7094                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7095                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7096                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7097                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7098                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7099                                 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));
7100                         }
7101                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7102                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7104                 }
7105                 if (r->computer_dn) {
7106                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7107                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7108                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7109                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7110                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7111                                 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));
7112                         }
7113                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7114                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7116                 }
7117                 if (r->server_dn) {
7118                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7119                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7120                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7121                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7122                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7123                                 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));
7124                         }
7125                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7126                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7128                 }
7129         }
7130         return NDR_ERR_SUCCESS;
7131 }
7132
7133 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7134 {
7135         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7136         ndr->depth++;
7137         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7138         ndr->depth++;
7139         if (r->netbios_name) {
7140                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7141         }
7142         ndr->depth--;
7143         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7144         ndr->depth++;
7145         if (r->dns_name) {
7146                 ndr_print_string(ndr, "dns_name", r->dns_name);
7147         }
7148         ndr->depth--;
7149         ndr_print_ptr(ndr, "site_name", r->site_name);
7150         ndr->depth++;
7151         if (r->site_name) {
7152                 ndr_print_string(ndr, "site_name", r->site_name);
7153         }
7154         ndr->depth--;
7155         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7156         ndr->depth++;
7157         if (r->computer_dn) {
7158                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7159         }
7160         ndr->depth--;
7161         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7162         ndr->depth++;
7163         if (r->server_dn) {
7164                 ndr_print_string(ndr, "server_dn", r->server_dn);
7165         }
7166         ndr->depth--;
7167         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7168         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7169         ndr->depth--;
7170 }
7171
7172 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7173 {
7174         uint32_t cntr_array_1;
7175         if (ndr_flags & NDR_SCALARS) {
7176                 NDR_CHECK(ndr_push_align(ndr, 5));
7177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7178                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7179                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7180         }
7181         if (ndr_flags & NDR_BUFFERS) {
7182                 if (r->array) {
7183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7184                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7185                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7186                         }
7187                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7188                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7189                         }
7190                 }
7191         }
7192         return NDR_ERR_SUCCESS;
7193 }
7194
7195 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7196 {
7197         uint32_t _ptr_array;
7198         uint32_t cntr_array_1;
7199         TALLOC_CTX *_mem_save_array_0;
7200         TALLOC_CTX *_mem_save_array_1;
7201         if (ndr_flags & NDR_SCALARS) {
7202                 NDR_CHECK(ndr_pull_align(ndr, 5));
7203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7204                 if (r->count > 10000) {
7205                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7206                 }
7207                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7208                 if (_ptr_array) {
7209                         NDR_PULL_ALLOC(ndr, r->array);
7210                 } else {
7211                         r->array = NULL;
7212                 }
7213                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7214         }
7215         if (ndr_flags & NDR_BUFFERS) {
7216                 if (r->array) {
7217                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7218                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7219                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7220                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7221                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7222                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7223                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7224                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7225                         }
7226                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7227                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7228                         }
7229                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7231                 }
7232                 if (r->array) {
7233                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7234                 }
7235         }
7236         return NDR_ERR_SUCCESS;
7237 }
7238
7239 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7240 {
7241         uint32_t cntr_array_1;
7242         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7243         ndr->depth++;
7244         ndr_print_uint32(ndr, "count", r->count);
7245         ndr_print_ptr(ndr, "array", r->array);
7246         ndr->depth++;
7247         if (r->array) {
7248                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7249                 ndr->depth++;
7250                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7251                         char *idx_1=NULL;
7252                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7253                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7254                                 free(idx_1);
7255                         }
7256                 }
7257                 ndr->depth--;
7258         }
7259         ndr->depth--;
7260         ndr->depth--;
7261 }
7262
7263 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7264 {
7265         if (ndr_flags & NDR_SCALARS) {
7266                 NDR_CHECK(ndr_push_align(ndr, 5));
7267                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7268                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7269                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7270                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7271                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7272                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7277                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7278                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7279                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7280                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7281                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7282         }
7283         if (ndr_flags & NDR_BUFFERS) {
7284                 if (r->netbios_name) {
7285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7287                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7288                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7289                 }
7290                 if (r->dns_name) {
7291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7294                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7295                 }
7296                 if (r->site_name) {
7297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7299                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7300                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7301                 }
7302                 if (r->site_dn) {
7303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7306                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7307                 }
7308                 if (r->computer_dn) {
7309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7312                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7313                 }
7314                 if (r->server_dn) {
7315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7318                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7319                 }
7320                 if (r->ntds_dn) {
7321                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7322                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7323                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7324                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7325                 }
7326         }
7327         return NDR_ERR_SUCCESS;
7328 }
7329
7330 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7331 {
7332         uint32_t _ptr_netbios_name;
7333         TALLOC_CTX *_mem_save_netbios_name_0;
7334         uint32_t _ptr_dns_name;
7335         TALLOC_CTX *_mem_save_dns_name_0;
7336         uint32_t _ptr_site_name;
7337         TALLOC_CTX *_mem_save_site_name_0;
7338         uint32_t _ptr_site_dn;
7339         TALLOC_CTX *_mem_save_site_dn_0;
7340         uint32_t _ptr_computer_dn;
7341         TALLOC_CTX *_mem_save_computer_dn_0;
7342         uint32_t _ptr_server_dn;
7343         TALLOC_CTX *_mem_save_server_dn_0;
7344         uint32_t _ptr_ntds_dn;
7345         TALLOC_CTX *_mem_save_ntds_dn_0;
7346         if (ndr_flags & NDR_SCALARS) {
7347                 NDR_CHECK(ndr_pull_align(ndr, 5));
7348                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7349                 if (_ptr_netbios_name) {
7350                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7351                 } else {
7352                         r->netbios_name = NULL;
7353                 }
7354                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7355                 if (_ptr_dns_name) {
7356                         NDR_PULL_ALLOC(ndr, r->dns_name);
7357                 } else {
7358                         r->dns_name = NULL;
7359                 }
7360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7361                 if (_ptr_site_name) {
7362                         NDR_PULL_ALLOC(ndr, r->site_name);
7363                 } else {
7364                         r->site_name = NULL;
7365                 }
7366                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7367                 if (_ptr_site_dn) {
7368                         NDR_PULL_ALLOC(ndr, r->site_dn);
7369                 } else {
7370                         r->site_dn = NULL;
7371                 }
7372                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7373                 if (_ptr_computer_dn) {
7374                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7375                 } else {
7376                         r->computer_dn = NULL;
7377                 }
7378                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7379                 if (_ptr_server_dn) {
7380                         NDR_PULL_ALLOC(ndr, r->server_dn);
7381                 } else {
7382                         r->server_dn = NULL;
7383                 }
7384                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7385                 if (_ptr_ntds_dn) {
7386                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7387                 } else {
7388                         r->ntds_dn = NULL;
7389                 }
7390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7393                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7394                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7395                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7396                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7397                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7398         }
7399         if (ndr_flags & NDR_BUFFERS) {
7400                 if (r->netbios_name) {
7401                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7402                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7403                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7404                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7405                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7406                                 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));
7407                         }
7408                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7409                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7411                 }
7412                 if (r->dns_name) {
7413                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7414                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7415                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7416                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7417                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7418                                 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));
7419                         }
7420                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7421                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7422                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7423                 }
7424                 if (r->site_name) {
7425                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7426                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7428                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7429                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7430                                 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));
7431                         }
7432                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7433                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7435                 }
7436                 if (r->site_dn) {
7437                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7438                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7439                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7440                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7441                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7442                                 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));
7443                         }
7444                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7445                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7446                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7447                 }
7448                 if (r->computer_dn) {
7449                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7450                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7451                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7452                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7453                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7454                                 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));
7455                         }
7456                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7457                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7458                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7459                 }
7460                 if (r->server_dn) {
7461                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7462                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7463                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7464                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7465                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7466                                 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));
7467                         }
7468                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7469                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7470                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7471                 }
7472                 if (r->ntds_dn) {
7473                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7474                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7475                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7476                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7477                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7478                                 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));
7479                         }
7480                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7481                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7482                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7483                 }
7484         }
7485         return NDR_ERR_SUCCESS;
7486 }
7487
7488 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7489 {
7490         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7491         ndr->depth++;
7492         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7493         ndr->depth++;
7494         if (r->netbios_name) {
7495                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7496         }
7497         ndr->depth--;
7498         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7499         ndr->depth++;
7500         if (r->dns_name) {
7501                 ndr_print_string(ndr, "dns_name", r->dns_name);
7502         }
7503         ndr->depth--;
7504         ndr_print_ptr(ndr, "site_name", r->site_name);
7505         ndr->depth++;
7506         if (r->site_name) {
7507                 ndr_print_string(ndr, "site_name", r->site_name);
7508         }
7509         ndr->depth--;
7510         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7511         ndr->depth++;
7512         if (r->site_dn) {
7513                 ndr_print_string(ndr, "site_dn", r->site_dn);
7514         }
7515         ndr->depth--;
7516         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7517         ndr->depth++;
7518         if (r->computer_dn) {
7519                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7520         }
7521         ndr->depth--;
7522         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7523         ndr->depth++;
7524         if (r->server_dn) {
7525                 ndr_print_string(ndr, "server_dn", r->server_dn);
7526         }
7527         ndr->depth--;
7528         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7529         ndr->depth++;
7530         if (r->ntds_dn) {
7531                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7532         }
7533         ndr->depth--;
7534         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7535         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7536         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7537         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7538         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7539         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7540         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7541         ndr->depth--;
7542 }
7543
7544 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7545 {
7546         uint32_t cntr_array_1;
7547         if (ndr_flags & NDR_SCALARS) {
7548                 NDR_CHECK(ndr_push_align(ndr, 5));
7549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7550                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7551                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7552         }
7553         if (ndr_flags & NDR_BUFFERS) {
7554                 if (r->array) {
7555                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7556                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7557                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7558                         }
7559                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7560                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7561                         }
7562                 }
7563         }
7564         return NDR_ERR_SUCCESS;
7565 }
7566
7567 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7568 {
7569         uint32_t _ptr_array;
7570         uint32_t cntr_array_1;
7571         TALLOC_CTX *_mem_save_array_0;
7572         TALLOC_CTX *_mem_save_array_1;
7573         if (ndr_flags & NDR_SCALARS) {
7574                 NDR_CHECK(ndr_pull_align(ndr, 5));
7575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7576                 if (r->count > 10000) {
7577                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7578                 }
7579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7580                 if (_ptr_array) {
7581                         NDR_PULL_ALLOC(ndr, r->array);
7582                 } else {
7583                         r->array = NULL;
7584                 }
7585                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7586         }
7587         if (ndr_flags & NDR_BUFFERS) {
7588                 if (r->array) {
7589                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7590                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7592                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7593                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7594                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7595                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7596                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7597                         }
7598                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7599                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7600                         }
7601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7603                 }
7604                 if (r->array) {
7605                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7606                 }
7607         }
7608         return NDR_ERR_SUCCESS;
7609 }
7610
7611 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7612 {
7613         uint32_t cntr_array_1;
7614         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7615         ndr->depth++;
7616         ndr_print_uint32(ndr, "count", r->count);
7617         ndr_print_ptr(ndr, "array", r->array);
7618         ndr->depth++;
7619         if (r->array) {
7620                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7621                 ndr->depth++;
7622                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7623                         char *idx_1=NULL;
7624                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7625                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7626                                 free(idx_1);
7627                         }
7628                 }
7629                 ndr->depth--;
7630         }
7631         ndr->depth--;
7632         ndr->depth--;
7633 }
7634
7635 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7636 {
7637         if (ndr_flags & NDR_SCALARS) {
7638                 NDR_CHECK(ndr_push_align(ndr, 5));
7639                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7642                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7643                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7644                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7650                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7651                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7652                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7653                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7654                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7655         }
7656         if (ndr_flags & NDR_BUFFERS) {
7657                 if (r->netbios_name) {
7658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7661                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7662                 }
7663                 if (r->dns_name) {
7664                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7667                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7668                 }
7669                 if (r->site_name) {
7670                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7671                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7672                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7673                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7674                 }
7675                 if (r->site_dn) {
7676                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7677                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7678                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7679                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7680                 }
7681                 if (r->computer_dn) {
7682                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7683                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7684                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7685                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7686                 }
7687                 if (r->server_dn) {
7688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7691                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7692                 }
7693                 if (r->ntds_dn) {
7694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7697                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7698                 }
7699         }
7700         return NDR_ERR_SUCCESS;
7701 }
7702
7703 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7704 {
7705         uint32_t _ptr_netbios_name;
7706         TALLOC_CTX *_mem_save_netbios_name_0;
7707         uint32_t _ptr_dns_name;
7708         TALLOC_CTX *_mem_save_dns_name_0;
7709         uint32_t _ptr_site_name;
7710         TALLOC_CTX *_mem_save_site_name_0;
7711         uint32_t _ptr_site_dn;
7712         TALLOC_CTX *_mem_save_site_dn_0;
7713         uint32_t _ptr_computer_dn;
7714         TALLOC_CTX *_mem_save_computer_dn_0;
7715         uint32_t _ptr_server_dn;
7716         TALLOC_CTX *_mem_save_server_dn_0;
7717         uint32_t _ptr_ntds_dn;
7718         TALLOC_CTX *_mem_save_ntds_dn_0;
7719         if (ndr_flags & NDR_SCALARS) {
7720                 NDR_CHECK(ndr_pull_align(ndr, 5));
7721                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7722                 if (_ptr_netbios_name) {
7723                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7724                 } else {
7725                         r->netbios_name = NULL;
7726                 }
7727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7728                 if (_ptr_dns_name) {
7729                         NDR_PULL_ALLOC(ndr, r->dns_name);
7730                 } else {
7731                         r->dns_name = NULL;
7732                 }
7733                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7734                 if (_ptr_site_name) {
7735                         NDR_PULL_ALLOC(ndr, r->site_name);
7736                 } else {
7737                         r->site_name = NULL;
7738                 }
7739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7740                 if (_ptr_site_dn) {
7741                         NDR_PULL_ALLOC(ndr, r->site_dn);
7742                 } else {
7743                         r->site_dn = NULL;
7744                 }
7745                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7746                 if (_ptr_computer_dn) {
7747                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7748                 } else {
7749                         r->computer_dn = NULL;
7750                 }
7751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7752                 if (_ptr_server_dn) {
7753                         NDR_PULL_ALLOC(ndr, r->server_dn);
7754                 } else {
7755                         r->server_dn = NULL;
7756                 }
7757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7758                 if (_ptr_ntds_dn) {
7759                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7760                 } else {
7761                         r->ntds_dn = NULL;
7762                 }
7763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7767                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7768                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7769                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7770                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7771                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7772         }
7773         if (ndr_flags & NDR_BUFFERS) {
7774                 if (r->netbios_name) {
7775                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7776                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7777                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7778                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7779                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7780                                 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));
7781                         }
7782                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7783                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7785                 }
7786                 if (r->dns_name) {
7787                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7788                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7789                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7790                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7791                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7792                                 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));
7793                         }
7794                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7795                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7796                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7797                 }
7798                 if (r->site_name) {
7799                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7800                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7801                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7802                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7803                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7804                                 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));
7805                         }
7806                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7807                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7809                 }
7810                 if (r->site_dn) {
7811                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7812                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7813                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7814                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7815                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7816                                 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));
7817                         }
7818                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7821                 }
7822                 if (r->computer_dn) {
7823                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7824                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7825                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7826                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7827                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7828                                 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));
7829                         }
7830                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7831                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7832                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7833                 }
7834                 if (r->server_dn) {
7835                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7836                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7837                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7838                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7839                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7840                                 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));
7841                         }
7842                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7843                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7845                 }
7846                 if (r->ntds_dn) {
7847                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7848                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7851                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7852                                 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));
7853                         }
7854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7857                 }
7858         }
7859         return NDR_ERR_SUCCESS;
7860 }
7861
7862 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7863 {
7864         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7865         ndr->depth++;
7866         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7867         ndr->depth++;
7868         if (r->netbios_name) {
7869                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7870         }
7871         ndr->depth--;
7872         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7873         ndr->depth++;
7874         if (r->dns_name) {
7875                 ndr_print_string(ndr, "dns_name", r->dns_name);
7876         }
7877         ndr->depth--;
7878         ndr_print_ptr(ndr, "site_name", r->site_name);
7879         ndr->depth++;
7880         if (r->site_name) {
7881                 ndr_print_string(ndr, "site_name", r->site_name);
7882         }
7883         ndr->depth--;
7884         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7885         ndr->depth++;
7886         if (r->site_dn) {
7887                 ndr_print_string(ndr, "site_dn", r->site_dn);
7888         }
7889         ndr->depth--;
7890         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7891         ndr->depth++;
7892         if (r->computer_dn) {
7893                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7894         }
7895         ndr->depth--;
7896         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7897         ndr->depth++;
7898         if (r->server_dn) {
7899                 ndr_print_string(ndr, "server_dn", r->server_dn);
7900         }
7901         ndr->depth--;
7902         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7903         ndr->depth++;
7904         if (r->ntds_dn) {
7905                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7906         }
7907         ndr->depth--;
7908         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7909         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7910         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7911         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7912         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7913         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7914         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7915         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7916         ndr->depth--;
7917 }
7918
7919 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7920 {
7921         uint32_t cntr_array_1;
7922         if (ndr_flags & NDR_SCALARS) {
7923                 NDR_CHECK(ndr_push_align(ndr, 5));
7924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7925                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7926                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7927         }
7928         if (ndr_flags & NDR_BUFFERS) {
7929                 if (r->array) {
7930                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7931                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7932                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7933                         }
7934                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7935                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7936                         }
7937                 }
7938         }
7939         return NDR_ERR_SUCCESS;
7940 }
7941
7942 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7943 {
7944         uint32_t _ptr_array;
7945         uint32_t cntr_array_1;
7946         TALLOC_CTX *_mem_save_array_0;
7947         TALLOC_CTX *_mem_save_array_1;
7948         if (ndr_flags & NDR_SCALARS) {
7949                 NDR_CHECK(ndr_pull_align(ndr, 5));
7950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7951                 if (r->count > 10000) {
7952                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7953                 }
7954                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7955                 if (_ptr_array) {
7956                         NDR_PULL_ALLOC(ndr, r->array);
7957                 } else {
7958                         r->array = NULL;
7959                 }
7960                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7961         }
7962         if (ndr_flags & NDR_BUFFERS) {
7963                 if (r->array) {
7964                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7965                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7966                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7967                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7968                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7969                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7970                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7971                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7972                         }
7973                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7974                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7975                         }
7976                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7978                 }
7979                 if (r->array) {
7980                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7981                 }
7982         }
7983         return NDR_ERR_SUCCESS;
7984 }
7985
7986 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7987 {
7988         uint32_t cntr_array_1;
7989         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7990         ndr->depth++;
7991         ndr_print_uint32(ndr, "count", r->count);
7992         ndr_print_ptr(ndr, "array", r->array);
7993         ndr->depth++;
7994         if (r->array) {
7995                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7996                 ndr->depth++;
7997                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7998                         char *idx_1=NULL;
7999                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8000                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
8001                                 free(idx_1);
8002                         }
8003                 }
8004                 ndr->depth--;
8005         }
8006         ndr->depth--;
8007         ndr->depth--;
8008 }
8009
8010 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
8011 {
8012         if (ndr_flags & NDR_SCALARS) {
8013                 NDR_CHECK(ndr_push_align(ndr, 5));
8014                 {
8015                         uint32_t _flags_save_ipv4address = ndr->flags;
8016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8017                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
8018                         ndr->flags = _flags_save_ipv4address;
8019                 }
8020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
8022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
8023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
8024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
8025                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
8026                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8027         }
8028         if (ndr_flags & NDR_BUFFERS) {
8029                 if (r->client_account) {
8030                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8031                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8033                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8034                 }
8035         }
8036         return NDR_ERR_SUCCESS;
8037 }
8038
8039 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8040 {
8041         uint32_t _ptr_client_account;
8042         TALLOC_CTX *_mem_save_client_account_0;
8043         if (ndr_flags & NDR_SCALARS) {
8044                 NDR_CHECK(ndr_pull_align(ndr, 5));
8045                 {
8046                         uint32_t _flags_save_ipv4address = ndr->flags;
8047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8048                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
8049                         ndr->flags = _flags_save_ipv4address;
8050                 }
8051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
8053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
8054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
8055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
8056                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
8057                 if (_ptr_client_account) {
8058                         NDR_PULL_ALLOC(ndr, r->client_account);
8059                 } else {
8060                         r->client_account = NULL;
8061                 }
8062                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8063         }
8064         if (ndr_flags & NDR_BUFFERS) {
8065                 if (r->client_account) {
8066                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8067                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8070                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8071                                 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));
8072                         }
8073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8074                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8076                 }
8077         }
8078         return NDR_ERR_SUCCESS;
8079 }
8080
8081 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8082 {
8083         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8084         ndr->depth++;
8085         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8086         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8087         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8088         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8089         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8090         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8091         ndr_print_ptr(ndr, "client_account", r->client_account);
8092         ndr->depth++;
8093         if (r->client_account) {
8094                 ndr_print_string(ndr, "client_account", r->client_account);
8095         }
8096         ndr->depth--;
8097         ndr->depth--;
8098 }
8099
8100 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8101 {
8102         uint32_t cntr_array_1;
8103         if (ndr_flags & NDR_SCALARS) {
8104                 NDR_CHECK(ndr_push_align(ndr, 5));
8105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8106                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8107                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8108         }
8109         if (ndr_flags & NDR_BUFFERS) {
8110                 if (r->array) {
8111                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8112                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8113                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8114                         }
8115                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8116                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8117                         }
8118                 }
8119         }
8120         return NDR_ERR_SUCCESS;
8121 }
8122
8123 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8124 {
8125         uint32_t _ptr_array;
8126         uint32_t cntr_array_1;
8127         TALLOC_CTX *_mem_save_array_0;
8128         TALLOC_CTX *_mem_save_array_1;
8129         if (ndr_flags & NDR_SCALARS) {
8130                 NDR_CHECK(ndr_pull_align(ndr, 5));
8131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8132                 if (r->count > 10000) {
8133                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8134                 }
8135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8136                 if (_ptr_array) {
8137                         NDR_PULL_ALLOC(ndr, r->array);
8138                 } else {
8139                         r->array = NULL;
8140                 }
8141                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8142         }
8143         if (ndr_flags & NDR_BUFFERS) {
8144                 if (r->array) {
8145                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8146                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8147                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8148                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8149                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8150                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8151                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8152                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8153                         }
8154                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8155                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8156                         }
8157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8159                 }
8160                 if (r->array) {
8161                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8162                 }
8163         }
8164         return NDR_ERR_SUCCESS;
8165 }
8166
8167 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8168 {
8169         uint32_t cntr_array_1;
8170         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8171         ndr->depth++;
8172         ndr_print_uint32(ndr, "count", r->count);
8173         ndr_print_ptr(ndr, "array", r->array);
8174         ndr->depth++;
8175         if (r->array) {
8176                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8177                 ndr->depth++;
8178                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8179                         char *idx_1=NULL;
8180                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8181                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8182                                 free(idx_1);
8183                         }
8184                 }
8185                 ndr->depth--;
8186         }
8187         ndr->depth--;
8188         ndr->depth--;
8189 }
8190
8191 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8192 {
8193         if (ndr_flags & NDR_SCALARS) {
8194                 int level = ndr_push_get_switch_value(ndr, r);
8195                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8196                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8197                 switch (level) {
8198                         case DRSUAPI_DC_INFO_CTR_1: {
8199                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8200                         break; }
8201
8202                         case DRSUAPI_DC_INFO_CTR_2: {
8203                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8204                         break; }
8205
8206                         case DRSUAPI_DC_INFO_CTR_3: {
8207                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8208                         break; }
8209
8210                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8211                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8212                         break; }
8213
8214                         default:
8215                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8216                 }
8217         }
8218         if (ndr_flags & NDR_BUFFERS) {
8219                 int level = ndr_push_get_switch_value(ndr, r);
8220                 switch (level) {
8221                         case DRSUAPI_DC_INFO_CTR_1:
8222                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8223                         break;
8224
8225                         case DRSUAPI_DC_INFO_CTR_2:
8226                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8227                         break;
8228
8229                         case DRSUAPI_DC_INFO_CTR_3:
8230                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8231                         break;
8232
8233                         case DRSUAPI_DC_CONNECTION_CTR_01:
8234                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8235                         break;
8236
8237                         default:
8238                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8239                 }
8240         }
8241         return NDR_ERR_SUCCESS;
8242 }
8243
8244 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8245 {
8246         int level;
8247         int32_t _level;
8248         level = ndr_pull_get_switch_value(ndr, r);
8249         if (ndr_flags & NDR_SCALARS) {
8250                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8251                 if (_level != level) {
8252                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8253                 }
8254                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8255                 switch (level) {
8256                         case DRSUAPI_DC_INFO_CTR_1: {
8257                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8258                         break; }
8259
8260                         case DRSUAPI_DC_INFO_CTR_2: {
8261                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8262                         break; }
8263
8264                         case DRSUAPI_DC_INFO_CTR_3: {
8265                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8266                         break; }
8267
8268                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8269                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8270                         break; }
8271
8272                         default:
8273                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8274                 }
8275         }
8276         if (ndr_flags & NDR_BUFFERS) {
8277                 switch (level) {
8278                         case DRSUAPI_DC_INFO_CTR_1:
8279                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8280                         break;
8281
8282                         case DRSUAPI_DC_INFO_CTR_2:
8283                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8284                         break;
8285
8286                         case DRSUAPI_DC_INFO_CTR_3:
8287                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8288                         break;
8289
8290                         case DRSUAPI_DC_CONNECTION_CTR_01:
8291                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8292                         break;
8293
8294                         default:
8295                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8296                 }
8297         }
8298         return NDR_ERR_SUCCESS;
8299 }
8300
8301 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8302 {
8303         int level;
8304         level = ndr_print_get_switch_value(ndr, r);
8305         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8306         switch (level) {
8307                 case DRSUAPI_DC_INFO_CTR_1:
8308                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8309                 break;
8310
8311                 case DRSUAPI_DC_INFO_CTR_2:
8312                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8313                 break;
8314
8315                 case DRSUAPI_DC_INFO_CTR_3:
8316                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8317                 break;
8318
8319                 case DRSUAPI_DC_CONNECTION_CTR_01:
8320                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8321                 break;
8322
8323                 default:
8324                         ndr_print_bad_level(ndr, name, level);
8325         }
8326 }
8327
8328 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8329 {
8330         if (ndr_flags & NDR_SCALARS) {
8331                 NDR_CHECK(ndr_push_align(ndr, 5));
8332                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8333                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8334                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8335         }
8336         if (ndr_flags & NDR_BUFFERS) {
8337                 if (r->next_object) {
8338                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8339                 }
8340                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8341         }
8342         return NDR_ERR_SUCCESS;
8343 }
8344
8345 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8346 {
8347         uint32_t _ptr_next_object;
8348         TALLOC_CTX *_mem_save_next_object_0;
8349         if (ndr_flags & NDR_SCALARS) {
8350                 NDR_CHECK(ndr_pull_align(ndr, 5));
8351                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8352                 if (_ptr_next_object) {
8353                         NDR_PULL_ALLOC(ndr, r->next_object);
8354                 } else {
8355                         r->next_object = NULL;
8356                 }
8357                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8358                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8359         }
8360         if (ndr_flags & NDR_BUFFERS) {
8361                 if (r->next_object) {
8362                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8363                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8364                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8365                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8366                 }
8367                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8368         }
8369         return NDR_ERR_SUCCESS;
8370 }
8371
8372 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8373 {
8374         if (ndr_flags & NDR_SCALARS) {
8375                 NDR_CHECK(ndr_push_align(ndr, 5));
8376                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8377                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8378         }
8379         if (ndr_flags & NDR_BUFFERS) {
8380                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8381         }
8382         return NDR_ERR_SUCCESS;
8383 }
8384
8385 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8386 {
8387         if (ndr_flags & NDR_SCALARS) {
8388                 NDR_CHECK(ndr_pull_align(ndr, 5));
8389                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8390                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8391         }
8392         if (ndr_flags & NDR_BUFFERS) {
8393                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8394         }
8395         return NDR_ERR_SUCCESS;
8396 }
8397
8398 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8399 {
8400         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8401         ndr->depth++;
8402         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8403         ndr->depth--;
8404 }
8405
8406 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8407 {
8408         if (ndr_flags & NDR_SCALARS) {
8409                 int level = ndr_push_get_switch_value(ndr, r);
8410                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8411                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8412                 switch (level) {
8413                         case 2: {
8414                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8415                         break; }
8416
8417                         default:
8418                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8419                 }
8420         }
8421         if (ndr_flags & NDR_BUFFERS) {
8422                 int level = ndr_push_get_switch_value(ndr, r);
8423                 switch (level) {
8424                         case 2:
8425                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8426                         break;
8427
8428                         default:
8429                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8430                 }
8431         }
8432         return NDR_ERR_SUCCESS;
8433 }
8434
8435 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8436 {
8437         int level;
8438         int32_t _level;
8439         level = ndr_pull_get_switch_value(ndr, r);
8440         if (ndr_flags & NDR_SCALARS) {
8441                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8442                 if (_level != level) {
8443                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8444                 }
8445                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8446                 switch (level) {
8447                         case 2: {
8448                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8449                         break; }
8450
8451                         default:
8452                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8453                 }
8454         }
8455         if (ndr_flags & NDR_BUFFERS) {
8456                 switch (level) {
8457                         case 2:
8458                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8459                         break;
8460
8461                         default:
8462                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8463                 }
8464         }
8465         return NDR_ERR_SUCCESS;
8466 }
8467
8468 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8469 {
8470         int level;
8471         level = ndr_print_get_switch_value(ndr, r);
8472         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8473         switch (level) {
8474                 case 2:
8475                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8476                 break;
8477
8478                 default:
8479                         ndr_print_bad_level(ndr, name, level);
8480         }
8481 }
8482
8483 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8484 {
8485         if (ndr_flags & NDR_SCALARS) {
8486                 NDR_CHECK(ndr_push_align(ndr, 4));
8487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8488                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8490                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8491                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8492         }
8493         if (ndr_flags & NDR_BUFFERS) {
8494         }
8495         return NDR_ERR_SUCCESS;
8496 }
8497
8498 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8499 {
8500         if (ndr_flags & NDR_SCALARS) {
8501                 NDR_CHECK(ndr_pull_align(ndr, 4));
8502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8503                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8505                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8506                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8507         }
8508         if (ndr_flags & NDR_BUFFERS) {
8509         }
8510         return NDR_ERR_SUCCESS;
8511 }
8512
8513 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8514 {
8515         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8516         ndr->depth++;
8517         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8518         ndr_print_WERROR(ndr, "status", r->status);
8519         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8520         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8521         ndr->depth--;
8522 }
8523
8524 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8525 {
8526         if (ndr_flags & NDR_SCALARS) {
8527                 NDR_CHECK(ndr_push_align(ndr, 5));
8528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8530                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8531         }
8532         if (ndr_flags & NDR_BUFFERS) {
8533                 if (r->data) {
8534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8535                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8536                 }
8537         }
8538         return NDR_ERR_SUCCESS;
8539 }
8540
8541 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8542 {
8543         uint32_t _ptr_data;
8544         TALLOC_CTX *_mem_save_data_0;
8545         if (ndr_flags & NDR_SCALARS) {
8546                 NDR_CHECK(ndr_pull_align(ndr, 5));
8547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8548                 if (r->size > 10485760) {
8549                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8550                 }
8551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8552                 if (_ptr_data) {
8553                         NDR_PULL_ALLOC(ndr, r->data);
8554                 } else {
8555                         r->data = NULL;
8556                 }
8557                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8558         }
8559         if (ndr_flags & NDR_BUFFERS) {
8560                 if (r->data) {
8561                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8562                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8563                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8564                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8565                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8567                 }
8568                 if (r->data) {
8569                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8570                 }
8571         }
8572         return NDR_ERR_SUCCESS;
8573 }
8574
8575 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8576 {
8577         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8578         ndr->depth++;
8579         ndr_print_uint32(ndr, "size", r->size);
8580         ndr_print_ptr(ndr, "data", r->data);
8581         ndr->depth++;
8582         if (r->data) {
8583                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8584         }
8585         ndr->depth--;
8586         ndr->depth--;
8587 }
8588
8589 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8590 {
8591         if (ndr_flags & NDR_SCALARS) {
8592                 NDR_CHECK(ndr_push_align(ndr, 5));
8593                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8594                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8596                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8597                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8598         }
8599         if (ndr_flags & NDR_BUFFERS) {
8600                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8601         }
8602         return NDR_ERR_SUCCESS;
8603 }
8604
8605 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8606 {
8607         if (ndr_flags & NDR_SCALARS) {
8608                 NDR_CHECK(ndr_pull_align(ndr, 5));
8609                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8610                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8612                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8613                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8614         }
8615         if (ndr_flags & NDR_BUFFERS) {
8616                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8617         }
8618         return NDR_ERR_SUCCESS;
8619 }
8620
8621 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8622 {
8623         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8624         ndr->depth++;
8625         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8626         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8627         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8628         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8629         ndr->depth--;
8630 }
8631
8632 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8633 {
8634         if (ndr_flags & NDR_SCALARS) {
8635                 NDR_CHECK(ndr_push_align(ndr, 5));
8636                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8637                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8638                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8639         }
8640         if (ndr_flags & NDR_BUFFERS) {
8641                 if (r->next) {
8642                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8643                 }
8644                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8645         }
8646         return NDR_ERR_SUCCESS;
8647 }
8648
8649 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8650 {
8651         uint32_t _ptr_next;
8652         TALLOC_CTX *_mem_save_next_0;
8653         if (ndr_flags & NDR_SCALARS) {
8654                 NDR_CHECK(ndr_pull_align(ndr, 5));
8655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8656                 if (_ptr_next) {
8657                         NDR_PULL_ALLOC(ndr, r->next);
8658                 } else {
8659                         r->next = NULL;
8660                 }
8661                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8662                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8663         }
8664         if (ndr_flags & NDR_BUFFERS) {
8665                 if (r->next) {
8666                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8667                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8668                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8669                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8670                 }
8671                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8672         }
8673         return NDR_ERR_SUCCESS;
8674 }
8675
8676 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8677 {
8678         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8679         ndr->depth++;
8680         ndr_print_ptr(ndr, "next", r->next);
8681         ndr->depth++;
8682         if (r->next) {
8683                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8684         }
8685         ndr->depth--;
8686         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8687         ndr->depth--;
8688 }
8689
8690 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8691 {
8692         if (ndr_flags & NDR_SCALARS) {
8693                 NDR_CHECK(ndr_push_align(ndr, 5));
8694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8695                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8696                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8697                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8698         }
8699         if (ndr_flags & NDR_BUFFERS) {
8700                 if (r->id) {
8701                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8702                 }
8703                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8704         }
8705         return NDR_ERR_SUCCESS;
8706 }
8707
8708 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8709 {
8710         uint32_t _ptr_id;
8711         TALLOC_CTX *_mem_save_id_0;
8712         if (ndr_flags & NDR_SCALARS) {
8713                 NDR_CHECK(ndr_pull_align(ndr, 5));
8714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8715                 if (_ptr_id) {
8716                         NDR_PULL_ALLOC(ndr, r->id);
8717                 } else {
8718                         r->id = NULL;
8719                 }
8720                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8721                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8722                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8723         }
8724         if (ndr_flags & NDR_BUFFERS) {
8725                 if (r->id) {
8726                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8727                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8728                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8730                 }
8731                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8732         }
8733         return NDR_ERR_SUCCESS;
8734 }
8735
8736 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8737 {
8738         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8739         ndr->depth++;
8740         ndr_print_ptr(ndr, "id", r->id);
8741         ndr->depth++;
8742         if (r->id) {
8743                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8744         }
8745         ndr->depth--;
8746         ndr_print_WERROR(ndr, "status", r->status);
8747         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8748         ndr->depth--;
8749 }
8750
8751 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8752 {
8753         if (ndr_flags & NDR_SCALARS) {
8754                 int level = ndr_push_get_switch_value(ndr, r);
8755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8756                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8757                 switch (level) {
8758                         case 1: {
8759                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8760                         break; }
8761
8762                         case 4: {
8763                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8764                         break; }
8765
8766                         case 5: {
8767                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8768                         break; }
8769
8770                         case 6: {
8771                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8772                         break; }
8773
8774                         case 7: {
8775                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8776                         break; }
8777
8778                         default:
8779                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8780                 }
8781         }
8782         if (ndr_flags & NDR_BUFFERS) {
8783                 int level = ndr_push_get_switch_value(ndr, r);
8784                 switch (level) {
8785                         case 1:
8786                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8787                         break;
8788
8789                         case 4:
8790                         break;
8791
8792                         case 5:
8793                         break;
8794
8795                         case 6:
8796                         break;
8797
8798                         case 7:
8799                         break;
8800
8801                         default:
8802                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8803                 }
8804         }
8805         return NDR_ERR_SUCCESS;
8806 }
8807
8808 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8809 {
8810         int level;
8811         uint32_t _level;
8812         level = ndr_pull_get_switch_value(ndr, r);
8813         if (ndr_flags & NDR_SCALARS) {
8814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8815                 if (_level != level) {
8816                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8817                 }
8818                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8819                 switch (level) {
8820                         case 1: {
8821                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8822                         break; }
8823
8824                         case 4: {
8825                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8826                         break; }
8827
8828                         case 5: {
8829                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8830                         break; }
8831
8832                         case 6: {
8833                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8834                         break; }
8835
8836                         case 7: {
8837                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8838                         break; }
8839
8840                         default:
8841                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8842                 }
8843         }
8844         if (ndr_flags & NDR_BUFFERS) {
8845                 switch (level) {
8846                         case 1:
8847                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8848                         break;
8849
8850                         case 4:
8851                         break;
8852
8853                         case 5:
8854                         break;
8855
8856                         case 6:
8857                         break;
8858
8859                         case 7:
8860                         break;
8861
8862                         default:
8863                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8864                 }
8865         }
8866         return NDR_ERR_SUCCESS;
8867 }
8868
8869 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8870 {
8871         int level;
8872         level = ndr_print_get_switch_value(ndr, r);
8873         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8874         switch (level) {
8875                 case 1:
8876                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8877                 break;
8878
8879                 case 4:
8880                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8881                 break;
8882
8883                 case 5:
8884                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8885                 break;
8886
8887                 case 6:
8888                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8889                 break;
8890
8891                 case 7:
8892                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8893                 break;
8894
8895                 default:
8896                         ndr_print_bad_level(ndr, name, level);
8897         }
8898 }
8899
8900 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8901 {
8902         if (ndr_flags & NDR_SCALARS) {
8903                 NDR_CHECK(ndr_push_align(ndr, 5));
8904                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8907                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8908         }
8909         if (ndr_flags & NDR_BUFFERS) {
8910                 if (r->info) {
8911                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8912                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8913                 }
8914         }
8915         return NDR_ERR_SUCCESS;
8916 }
8917
8918 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8919 {
8920         uint32_t _ptr_info;
8921         TALLOC_CTX *_mem_save_info_0;
8922         if (ndr_flags & NDR_SCALARS) {
8923                 NDR_CHECK(ndr_pull_align(ndr, 5));
8924                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8927                 if (_ptr_info) {
8928                         NDR_PULL_ALLOC(ndr, r->info);
8929                 } else {
8930                         r->info = NULL;
8931                 }
8932                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8933         }
8934         if (ndr_flags & NDR_BUFFERS) {
8935                 if (r->info) {
8936                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8937                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8938                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8939                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8941                 }
8942         }
8943         return NDR_ERR_SUCCESS;
8944 }
8945
8946 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8947 {
8948         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8949         ndr->depth++;
8950         ndr_print_WERROR(ndr, "status", r->status);
8951         ndr_print_uint32(ndr, "level", r->level);
8952         ndr_print_ptr(ndr, "info", r->info);
8953         ndr->depth++;
8954         if (r->info) {
8955                 ndr_print_set_switch_value(ndr, r->info, r->level);
8956                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8957         }
8958         ndr->depth--;
8959         ndr->depth--;
8960 }
8961
8962 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8963 {
8964         if (ndr_flags & NDR_SCALARS) {
8965                 int level = ndr_push_get_switch_value(ndr, r);
8966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8967                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8968                 switch (level) {
8969                         case 1: {
8970                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8971                         break; }
8972
8973                         default:
8974                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8975                 }
8976         }
8977         if (ndr_flags & NDR_BUFFERS) {
8978                 int level = ndr_push_get_switch_value(ndr, r);
8979                 switch (level) {
8980                         case 1:
8981                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8982                         break;
8983
8984                         default:
8985                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8986                 }
8987         }
8988         return NDR_ERR_SUCCESS;
8989 }
8990
8991 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8992 {
8993         int level;
8994         uint32_t _level;
8995         level = ndr_pull_get_switch_value(ndr, r);
8996         if (ndr_flags & NDR_SCALARS) {
8997                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8998                 if (_level != level) {
8999                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9000                 }
9001                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9002                 switch (level) {
9003                         case 1: {
9004                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
9005                         break; }
9006
9007                         default:
9008                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9009                 }
9010         }
9011         if (ndr_flags & NDR_BUFFERS) {
9012                 switch (level) {
9013                         case 1:
9014                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
9015                         break;
9016
9017                         default:
9018                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9019                 }
9020         }
9021         return NDR_ERR_SUCCESS;
9022 }
9023
9024 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
9025 {
9026         int level;
9027         level = ndr_print_get_switch_value(ndr, r);
9028         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
9029         switch (level) {
9030                 case 1:
9031                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
9032                 break;
9033
9034                 default:
9035                         ndr_print_bad_level(ndr, name, level);
9036         }
9037 }
9038
9039 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9040 {
9041         if (ndr_flags & NDR_SCALARS) {
9042                 NDR_CHECK(ndr_push_align(ndr, 4));
9043                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
9044                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9045                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9046         }
9047         if (ndr_flags & NDR_BUFFERS) {
9048                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9049         }
9050         return NDR_ERR_SUCCESS;
9051 }
9052
9053 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
9054 {
9055         if (ndr_flags & NDR_SCALARS) {
9056                 NDR_CHECK(ndr_pull_align(ndr, 4));
9057                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
9058                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9059                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9060         }
9061         if (ndr_flags & NDR_BUFFERS) {
9062                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9063         }
9064         return NDR_ERR_SUCCESS;
9065 }
9066
9067 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9068 {
9069         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9070         ndr->depth++;
9071         ndr_print_GUID(ndr, "guid", &r->guid);
9072         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9073         ndr->depth--;
9074 }
9075
9076 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9077 {
9078         uint32_t cntr_objects_1;
9079         if (ndr_flags & NDR_SCALARS) {
9080                 NDR_CHECK(ndr_push_align(ndr, 5));
9081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9083                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9086                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9087         }
9088         if (ndr_flags & NDR_BUFFERS) {
9089                 if (r->id) {
9090                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9091                 }
9092                 if (r->objects) {
9093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9094                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9095                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9096                         }
9097                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9098                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9099                         }
9100                 }
9101         }
9102         return NDR_ERR_SUCCESS;
9103 }
9104
9105 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9106 {
9107         uint32_t _ptr_id;
9108         TALLOC_CTX *_mem_save_id_0;
9109         uint32_t _ptr_objects;
9110         uint32_t cntr_objects_1;
9111         TALLOC_CTX *_mem_save_objects_0;
9112         TALLOC_CTX *_mem_save_objects_1;
9113         if (ndr_flags & NDR_SCALARS) {
9114                 NDR_CHECK(ndr_pull_align(ndr, 5));
9115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9116                 if (_ptr_id) {
9117                         NDR_PULL_ALLOC(ndr, r->id);
9118                 } else {
9119                         r->id = NULL;
9120                 }
9121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9122                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9123                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9124                 if (r->count > 10000) {
9125                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9126                 }
9127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9128                 if (_ptr_objects) {
9129                         NDR_PULL_ALLOC(ndr, r->objects);
9130                 } else {
9131                         r->objects = NULL;
9132                 }
9133                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9134         }
9135         if (ndr_flags & NDR_BUFFERS) {
9136                 if (r->id) {
9137                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9138                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9139                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9141                 }
9142                 if (r->objects) {
9143                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9144                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9145                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9146                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9147                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9148                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9149                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9150                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9151                         }
9152                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9153                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9154                         }
9155                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9157                 }
9158                 if (r->objects) {
9159                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9160                 }
9161         }
9162         return NDR_ERR_SUCCESS;
9163 }
9164
9165 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9166 {
9167         uint32_t cntr_objects_1;
9168         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9169         ndr->depth++;
9170         ndr_print_ptr(ndr, "id", r->id);
9171         ndr->depth++;
9172         if (r->id) {
9173                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9174         }
9175         ndr->depth--;
9176         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9177         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9178         ndr_print_uint32(ndr, "count", r->count);
9179         ndr_print_ptr(ndr, "objects", r->objects);
9180         ndr->depth++;
9181         if (r->objects) {
9182                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9183                 ndr->depth++;
9184                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9185                         char *idx_1=NULL;
9186                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9187                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9188                                 free(idx_1);
9189                         }
9190                 }
9191                 ndr->depth--;
9192         }
9193         ndr->depth--;
9194         ndr->depth--;
9195 }
9196
9197 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9198 {
9199         uint32_t cntr_objects_1;
9200         if (ndr_flags & NDR_SCALARS) {
9201                 NDR_CHECK(ndr_push_align(ndr, 5));
9202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9207                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9208         }
9209         if (ndr_flags & NDR_BUFFERS) {
9210                 if (r->id) {
9211                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9212                 }
9213                 if (r->error) {
9214                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9215                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9216                 }
9217                 if (r->objects) {
9218                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9219                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9220                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9221                         }
9222                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9223                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9224                         }
9225                 }
9226         }
9227         return NDR_ERR_SUCCESS;
9228 }
9229
9230 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9231 {
9232         uint32_t _ptr_id;
9233         TALLOC_CTX *_mem_save_id_0;
9234         uint32_t _ptr_error;
9235         TALLOC_CTX *_mem_save_error_0;
9236         uint32_t _ptr_objects;
9237         uint32_t cntr_objects_1;
9238         TALLOC_CTX *_mem_save_objects_0;
9239         TALLOC_CTX *_mem_save_objects_1;
9240         if (ndr_flags & NDR_SCALARS) {
9241                 NDR_CHECK(ndr_pull_align(ndr, 5));
9242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9243                 if (_ptr_id) {
9244                         NDR_PULL_ALLOC(ndr, r->id);
9245                 } else {
9246                         r->id = NULL;
9247                 }
9248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9249                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9250                 if (_ptr_error) {
9251                         NDR_PULL_ALLOC(ndr, r->error);
9252                 } else {
9253                         r->error = NULL;
9254                 }
9255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9256                 if (r->count > 10000) {
9257                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9258                 }
9259                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9260                 if (_ptr_objects) {
9261                         NDR_PULL_ALLOC(ndr, r->objects);
9262                 } else {
9263                         r->objects = NULL;
9264                 }
9265                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9266         }
9267         if (ndr_flags & NDR_BUFFERS) {
9268                 if (r->id) {
9269                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9270                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9271                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9273                 }
9274                 if (r->error) {
9275                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9276                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9277                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9278                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9280                 }
9281                 if (r->objects) {
9282                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9283                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9284                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9285                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9286                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9287                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9288                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9289                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9290                         }
9291                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9292                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9293                         }
9294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9295                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9296                 }
9297                 if (r->objects) {
9298                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9299                 }
9300         }
9301         return NDR_ERR_SUCCESS;
9302 }
9303
9304 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9305 {
9306         uint32_t cntr_objects_1;
9307         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9308         ndr->depth++;
9309         ndr_print_ptr(ndr, "id", r->id);
9310         ndr->depth++;
9311         if (r->id) {
9312                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9313         }
9314         ndr->depth--;
9315         ndr_print_uint32(ndr, "level", r->level);
9316         ndr_print_ptr(ndr, "error", r->error);
9317         ndr->depth++;
9318         if (r->error) {
9319                 ndr_print_set_switch_value(ndr, r->error, r->level);
9320                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9321         }
9322         ndr->depth--;
9323         ndr_print_uint32(ndr, "count", r->count);
9324         ndr_print_ptr(ndr, "objects", r->objects);
9325         ndr->depth++;
9326         if (r->objects) {
9327                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9328                 ndr->depth++;
9329                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9330                         char *idx_1=NULL;
9331                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9332                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9333                                 free(idx_1);
9334                         }
9335                 }
9336                 ndr->depth--;
9337         }
9338         ndr->depth--;
9339         ndr->depth--;
9340 }
9341
9342 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9343 {
9344         if (ndr_flags & NDR_SCALARS) {
9345                 int level = ndr_push_get_switch_value(ndr, r);
9346                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9347                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9348                 switch (level) {
9349                         case 2: {
9350                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9351                         break; }
9352
9353                         case 3: {
9354                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9355                         break; }
9356
9357                         default:
9358                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9359                 }
9360         }
9361         if (ndr_flags & NDR_BUFFERS) {
9362                 int level = ndr_push_get_switch_value(ndr, r);
9363                 switch (level) {
9364                         case 2:
9365                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9366                         break;
9367
9368                         case 3:
9369                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9370                         break;
9371
9372                         default:
9373                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9374                 }
9375         }
9376         return NDR_ERR_SUCCESS;
9377 }
9378
9379 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9380 {
9381         int level;
9382         int32_t _level;
9383         level = ndr_pull_get_switch_value(ndr, r);
9384         if (ndr_flags & NDR_SCALARS) {
9385                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9386                 if (_level != level) {
9387                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9388                 }
9389                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9390                 switch (level) {
9391                         case 2: {
9392                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9393                         break; }
9394
9395                         case 3: {
9396                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9397                         break; }
9398
9399                         default:
9400                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9401                 }
9402         }
9403         if (ndr_flags & NDR_BUFFERS) {
9404                 switch (level) {
9405                         case 2:
9406                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9407                         break;
9408
9409                         case 3:
9410                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9411                         break;
9412
9413                         default:
9414                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9415                 }
9416         }
9417         return NDR_ERR_SUCCESS;
9418 }
9419
9420 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9421 {
9422         int level;
9423         level = ndr_print_get_switch_value(ndr, r);
9424         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9425         switch (level) {
9426                 case 2:
9427                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9428                 break;
9429
9430                 case 3:
9431                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9432                 break;
9433
9434                 default:
9435                         ndr_print_bad_level(ndr, name, level);
9436         }
9437 }
9438
9439 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9440 {
9441         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9442         return NDR_ERR_SUCCESS;
9443 }
9444
9445 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9446 {
9447         uint32_t v;
9448         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9449         *r = v;
9450         return NDR_ERR_SUCCESS;
9451 }
9452
9453 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9454 {
9455         ndr_print_uint32(ndr, name, r);
9456         ndr->depth++;
9457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9459         ndr->depth--;
9460 }
9461
9462 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9463 {
9464         if (ndr_flags & NDR_SCALARS) {
9465                 NDR_CHECK(ndr_push_align(ndr, 4));
9466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9467                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9468                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9469         }
9470         if (ndr_flags & NDR_BUFFERS) {
9471         }
9472         return NDR_ERR_SUCCESS;
9473 }
9474
9475 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9476 {
9477         if (ndr_flags & NDR_SCALARS) {
9478                 NDR_CHECK(ndr_pull_align(ndr, 4));
9479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9480                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9481                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9482         }
9483         if (ndr_flags & NDR_BUFFERS) {
9484         }
9485         return NDR_ERR_SUCCESS;
9486 }
9487
9488 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9489 {
9490         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9491         ndr->depth++;
9492         ndr_print_uint32(ndr, "taskID", r->taskID);
9493         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9494         ndr->depth--;
9495 }
9496
9497 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9498 {
9499         if (ndr_flags & NDR_SCALARS) {
9500                 int level = ndr_push_get_switch_value(ndr, r);
9501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9502                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9503                 switch (level) {
9504                         case 1: {
9505                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9506                         break; }
9507
9508                         default:
9509                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9510                 }
9511         }
9512         if (ndr_flags & NDR_BUFFERS) {
9513                 int level = ndr_push_get_switch_value(ndr, r);
9514                 switch (level) {
9515                         case 1:
9516                         break;
9517
9518                         default:
9519                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9520                 }
9521         }
9522         return NDR_ERR_SUCCESS;
9523 }
9524
9525 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9526 {
9527         int level;
9528         uint32_t _level;
9529         level = ndr_pull_get_switch_value(ndr, r);
9530         if (ndr_flags & NDR_SCALARS) {
9531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9532                 if (_level != level) {
9533                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9534                 }
9535                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9536                 switch (level) {
9537                         case 1: {
9538                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9539                         break; }
9540
9541                         default:
9542                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9543                 }
9544         }
9545         if (ndr_flags & NDR_BUFFERS) {
9546                 switch (level) {
9547                         case 1:
9548                         break;
9549
9550                         default:
9551                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9552                 }
9553         }
9554         return NDR_ERR_SUCCESS;
9555 }
9556
9557 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9558 {
9559         int level;
9560         level = ndr_print_get_switch_value(ndr, r);
9561         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9562         switch (level) {
9563                 case 1:
9564                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9565                 break;
9566
9567                 default:
9568                         ndr_print_bad_level(ndr, name, level);
9569         }
9570 }
9571
9572 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9573 {
9574         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9575         return NDR_ERR_SUCCESS;
9576 }
9577
9578 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9579 {
9580         uint32_t v;
9581         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9582         *r = v;
9583         return NDR_ERR_SUCCESS;
9584 }
9585
9586 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9587 {
9588         const char *val = NULL;
9589
9590         switch (r) {
9591                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9592                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9593         }
9594         ndr_print_enum(ndr, name, "ENUM", val, r);
9595 }
9596
9597 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9598 {
9599         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9600         return NDR_ERR_SUCCESS;
9601 }
9602
9603 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9604 {
9605         uint32_t v;
9606         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9607         *r = v;
9608         return NDR_ERR_SUCCESS;
9609 }
9610
9611 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9612 {
9613         const char *val = NULL;
9614
9615         switch (r) {
9616                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9617                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9618                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9619                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9620                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9621                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9622                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9623                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9624                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9625                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9626                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9627                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9628                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9629                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9630                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9631         }
9632         ndr_print_enum(ndr, name, "ENUM", val, r);
9633 }
9634
9635 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9636 {
9637         if (ndr_flags & NDR_SCALARS) {
9638                 NDR_CHECK(ndr_push_align(ndr, 5));
9639                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9641                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9642                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9643         }
9644         if (ndr_flags & NDR_BUFFERS) {
9645                 if (r->object_dn) {
9646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9649                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9650                 }
9651         }
9652         return NDR_ERR_SUCCESS;
9653 }
9654
9655 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9656 {
9657         uint32_t _ptr_object_dn;
9658         TALLOC_CTX *_mem_save_object_dn_0;
9659         if (ndr_flags & NDR_SCALARS) {
9660                 NDR_CHECK(ndr_pull_align(ndr, 5));
9661                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9662                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9663                 if (_ptr_object_dn) {
9664                         NDR_PULL_ALLOC(ndr, r->object_dn);
9665                 } else {
9666                         r->object_dn = NULL;
9667                 }
9668                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9669                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9670         }
9671         if (ndr_flags & NDR_BUFFERS) {
9672                 if (r->object_dn) {
9673                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9674                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9675                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9676                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9677                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9678                                 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));
9679                         }
9680                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9681                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9682                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9683                 }
9684         }
9685         return NDR_ERR_SUCCESS;
9686 }
9687
9688 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9689 {
9690         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9691         ndr->depth++;
9692         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9693         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9694         ndr->depth++;
9695         if (r->object_dn) {
9696                 ndr_print_string(ndr, "object_dn", r->object_dn);
9697         }
9698         ndr->depth--;
9699         ndr_print_GUID(ndr, "guid1", &r->guid1);
9700         ndr->depth--;
9701 }
9702
9703 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9704 {
9705         if (ndr_flags & NDR_SCALARS) {
9706                 NDR_CHECK(ndr_push_align(ndr, 5));
9707                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9709                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
9714                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9715         }
9716         if (ndr_flags & NDR_BUFFERS) {
9717                 if (r->object_dn) {
9718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9719                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9721                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9722                 }
9723                 if (r->string1) {
9724                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9725                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9726                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9727                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9728                 }
9729                 if (r->string2) {
9730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9731                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9732                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9734                 }
9735         }
9736         return NDR_ERR_SUCCESS;
9737 }
9738
9739 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9740 {
9741         uint32_t _ptr_object_dn;
9742         TALLOC_CTX *_mem_save_object_dn_0;
9743         uint32_t _ptr_string1;
9744         TALLOC_CTX *_mem_save_string1_0;
9745         uint32_t _ptr_string2;
9746         TALLOC_CTX *_mem_save_string2_0;
9747         if (ndr_flags & NDR_SCALARS) {
9748                 NDR_CHECK(ndr_pull_align(ndr, 5));
9749                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9751                 if (_ptr_object_dn) {
9752                         NDR_PULL_ALLOC(ndr, r->object_dn);
9753                 } else {
9754                         r->object_dn = NULL;
9755                 }
9756                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9759                 if (_ptr_string1) {
9760                         NDR_PULL_ALLOC(ndr, r->string1);
9761                 } else {
9762                         r->string1 = NULL;
9763                 }
9764                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9765                 if (_ptr_string2) {
9766                         NDR_PULL_ALLOC(ndr, r->string2);
9767                 } else {
9768                         r->string2 = NULL;
9769                 }
9770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
9771                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9772         }
9773         if (ndr_flags & NDR_BUFFERS) {
9774                 if (r->object_dn) {
9775                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9776                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9777                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9778                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9779                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9780                                 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));
9781                         }
9782                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9783                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9785                 }
9786                 if (r->string1) {
9787                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9788                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9789                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9790                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9791                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9792                                 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));
9793                         }
9794                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9795                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9796                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9797                 }
9798                 if (r->string2) {
9799                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9800                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9801                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9802                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9803                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9804                                 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));
9805                         }
9806                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9807                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9809                 }
9810         }
9811         return NDR_ERR_SUCCESS;
9812 }
9813
9814 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9815 {
9816         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9817         ndr->depth++;
9818         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9819         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9820         ndr->depth++;
9821         if (r->object_dn) {
9822                 ndr_print_string(ndr, "object_dn", r->object_dn);
9823         }
9824         ndr->depth--;
9825         ndr_print_GUID(ndr, "guid1", &r->guid1);
9826         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9827         ndr_print_ptr(ndr, "string1", r->string1);
9828         ndr->depth++;
9829         if (r->string1) {
9830                 ndr_print_string(ndr, "string1", r->string1);
9831         }
9832         ndr->depth--;
9833         ndr_print_ptr(ndr, "string2", r->string2);
9834         ndr->depth++;
9835         if (r->string2) {
9836                 ndr_print_string(ndr, "string2", r->string2);
9837         }
9838         ndr->depth--;
9839         ndr_print_uint32(ndr, "unknown2", r->unknown2);
9840         ndr->depth--;
9841 }
9842
9843 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9844 {
9845         if (ndr_flags & NDR_SCALARS) {
9846                 int level = ndr_push_get_switch_value(ndr, r);
9847                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9848                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9849                 switch (level) {
9850                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9851                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9852                         break; }
9853
9854                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9855                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9856                         break; }
9857
9858                         default:
9859                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9860                 }
9861         }
9862         if (ndr_flags & NDR_BUFFERS) {
9863                 int level = ndr_push_get_switch_value(ndr, r);
9864                 switch (level) {
9865                         case DRSUAPI_DS_REPLICA_GET_INFO:
9866                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9867                         break;
9868
9869                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9870                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9871                         break;
9872
9873                         default:
9874                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9875                 }
9876         }
9877         return NDR_ERR_SUCCESS;
9878 }
9879
9880 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9881 {
9882         int level;
9883         uint32_t _level;
9884         level = ndr_pull_get_switch_value(ndr, r);
9885         if (ndr_flags & NDR_SCALARS) {
9886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9887                 if (_level != level) {
9888                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9889                 }
9890                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9891                 switch (level) {
9892                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9893                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9894                         break; }
9895
9896                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9897                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9898                         break; }
9899
9900                         default:
9901                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9902                 }
9903         }
9904         if (ndr_flags & NDR_BUFFERS) {
9905                 switch (level) {
9906                         case DRSUAPI_DS_REPLICA_GET_INFO:
9907                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9908                         break;
9909
9910                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9911                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9912                         break;
9913
9914                         default:
9915                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9916                 }
9917         }
9918         return NDR_ERR_SUCCESS;
9919 }
9920
9921 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9922 {
9923         int level;
9924         level = ndr_print_get_switch_value(ndr, r);
9925         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9926         switch (level) {
9927                 case DRSUAPI_DS_REPLICA_GET_INFO:
9928                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9929                 break;
9930
9931                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9932                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9933                 break;
9934
9935                 default:
9936                         ndr_print_bad_level(ndr, name, level);
9937         }
9938 }
9939
9940 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9941 {
9942         if (ndr_flags & NDR_SCALARS) {
9943                 NDR_CHECK(ndr_push_align(ndr, 8));
9944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9945                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9946                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9947                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9948                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
9949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9950                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9951                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9952                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9953                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9954                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9955                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9956                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9957                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9958                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9960                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9961         }
9962         if (ndr_flags & NDR_BUFFERS) {
9963                 if (r->naming_context_dn) {
9964                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9965                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9967                         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));
9968                 }
9969                 if (r->source_dsa_obj_dn) {
9970                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9971                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9973                         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));
9974                 }
9975                 if (r->source_dsa_address) {
9976                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9977                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9979                         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));
9980                 }
9981                 if (r->transport_obj_dn) {
9982                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9983                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9984                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9985                         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));
9986                 }
9987         }
9988         return NDR_ERR_SUCCESS;
9989 }
9990
9991 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9992 {
9993         uint32_t _ptr_naming_context_dn;
9994         TALLOC_CTX *_mem_save_naming_context_dn_0;
9995         uint32_t _ptr_source_dsa_obj_dn;
9996         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9997         uint32_t _ptr_source_dsa_address;
9998         TALLOC_CTX *_mem_save_source_dsa_address_0;
9999         uint32_t _ptr_transport_obj_dn;
10000         TALLOC_CTX *_mem_save_transport_obj_dn_0;
10001         if (ndr_flags & NDR_SCALARS) {
10002                 NDR_CHECK(ndr_pull_align(ndr, 8));
10003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
10004                 if (_ptr_naming_context_dn) {
10005                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
10006                 } else {
10007                         r->naming_context_dn = NULL;
10008                 }
10009                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
10010                 if (_ptr_source_dsa_obj_dn) {
10011                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
10012                 } else {
10013                         r->source_dsa_obj_dn = NULL;
10014                 }
10015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
10016                 if (_ptr_source_dsa_address) {
10017                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
10018                 } else {
10019                         r->source_dsa_address = NULL;
10020                 }
10021                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
10022                 if (_ptr_transport_obj_dn) {
10023                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
10024                 } else {
10025                         r->transport_obj_dn = NULL;
10026                 }
10027                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
10028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10029                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
10030                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
10031                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10032                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
10033                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
10034                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
10035                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
10036                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
10037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
10038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
10039                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10040         }
10041         if (ndr_flags & NDR_BUFFERS) {
10042                 if (r->naming_context_dn) {
10043                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10044                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10045                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10046                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10047                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10048                                 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));
10049                         }
10050                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10051                         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));
10052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10053                 }
10054                 if (r->source_dsa_obj_dn) {
10055                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10056                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10057                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10058                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10059                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10060                                 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));
10061                         }
10062                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10063                         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));
10064                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10065                 }
10066                 if (r->source_dsa_address) {
10067                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10068                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10069                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10070                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10071                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10072                                 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));
10073                         }
10074                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10075                         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));
10076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10077                 }
10078                 if (r->transport_obj_dn) {
10079                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10080                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10081                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10082                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10083                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10084                                 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));
10085                         }
10086                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10087                         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));
10088                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10089                 }
10090         }
10091         return NDR_ERR_SUCCESS;
10092 }
10093
10094 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10095 {
10096         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10097         ndr->depth++;
10098         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10099         ndr->depth++;
10100         if (r->naming_context_dn) {
10101                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10102         }
10103         ndr->depth--;
10104         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10105         ndr->depth++;
10106         if (r->source_dsa_obj_dn) {
10107                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10108         }
10109         ndr->depth--;
10110         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10111         ndr->depth++;
10112         if (r->source_dsa_address) {
10113                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10114         }
10115         ndr->depth--;
10116         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10117         ndr->depth++;
10118         if (r->transport_obj_dn) {
10119                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10120         }
10121         ndr->depth--;
10122         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
10123         ndr_print_uint32(ndr, "reserved", r->reserved);
10124         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10125         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10126         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10127         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10128         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10129         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10130         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10131         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10132         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10133         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10134         ndr->depth--;
10135 }
10136
10137 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10138 {
10139         uint32_t cntr_array_0;
10140         if (ndr_flags & NDR_SCALARS) {
10141                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10142                 NDR_CHECK(ndr_push_align(ndr, 8));
10143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10145                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10146                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10147                 }
10148                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10149         }
10150         if (ndr_flags & NDR_BUFFERS) {
10151                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10152                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10153                 }
10154         }
10155         return NDR_ERR_SUCCESS;
10156 }
10157
10158 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10159 {
10160         uint32_t cntr_array_0;
10161         TALLOC_CTX *_mem_save_array_0;
10162         if (ndr_flags & NDR_SCALARS) {
10163                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10164                 NDR_CHECK(ndr_pull_align(ndr, 8));
10165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10167                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10168                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10169                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10170                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10171                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10172                 }
10173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10174                 if (r->array) {
10175                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10176                 }
10177                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10178         }
10179         if (ndr_flags & NDR_BUFFERS) {
10180                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10181                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10182                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10183                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10184                 }
10185                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10186         }
10187         return NDR_ERR_SUCCESS;
10188 }
10189
10190 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10191 {
10192         uint32_t cntr_array_0;
10193         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10194         ndr->depth++;
10195         ndr_print_uint32(ndr, "count", r->count);
10196         ndr_print_uint32(ndr, "reserved", r->reserved);
10197         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10198         ndr->depth++;
10199         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10200                 char *idx_0=NULL;
10201                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10202                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10203                         free(idx_0);
10204                 }
10205         }
10206         ndr->depth--;
10207         ndr->depth--;
10208 }
10209
10210 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10211 {
10212         uint32_t cntr_array_0;
10213         if (ndr_flags & NDR_SCALARS) {
10214                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10215                 NDR_CHECK(ndr_push_align(ndr, 8));
10216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10218                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10219                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10220                 }
10221                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10222         }
10223         if (ndr_flags & NDR_BUFFERS) {
10224         }
10225         return NDR_ERR_SUCCESS;
10226 }
10227
10228 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10229 {
10230         uint32_t cntr_array_0;
10231         TALLOC_CTX *_mem_save_array_0;
10232         if (ndr_flags & NDR_SCALARS) {
10233                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10234                 NDR_CHECK(ndr_pull_align(ndr, 8));
10235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10237                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10238                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10239                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10240                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10241                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10242                 }
10243                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10244                 if (r->array) {
10245                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10246                 }
10247                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10248         }
10249         if (ndr_flags & NDR_BUFFERS) {
10250         }
10251         return NDR_ERR_SUCCESS;
10252 }
10253
10254 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10255 {
10256         uint32_t cntr_array_0;
10257         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10258         ndr->depth++;
10259         ndr_print_uint32(ndr, "count", r->count);
10260         ndr_print_uint32(ndr, "reserved", r->reserved);
10261         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10262         ndr->depth++;
10263         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10264                 char *idx_0=NULL;
10265                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10266                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10267                         free(idx_0);
10268                 }
10269         }
10270         ndr->depth--;
10271         ndr->depth--;
10272 }
10273
10274 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10275 {
10276         if (ndr_flags & NDR_SCALARS) {
10277                 NDR_CHECK(ndr_push_align(ndr, 8));
10278                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10280                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10281                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10282                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10283                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10284                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10285         }
10286         if (ndr_flags & NDR_BUFFERS) {
10287                 if (r->attribute_name) {
10288                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10289                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10291                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10292                 }
10293         }
10294         return NDR_ERR_SUCCESS;
10295 }
10296
10297 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10298 {
10299         uint32_t _ptr_attribute_name;
10300         TALLOC_CTX *_mem_save_attribute_name_0;
10301         if (ndr_flags & NDR_SCALARS) {
10302                 NDR_CHECK(ndr_pull_align(ndr, 8));
10303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10304                 if (_ptr_attribute_name) {
10305                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10306                 } else {
10307                         r->attribute_name = NULL;
10308                 }
10309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10310                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10311                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10312                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10313                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10314                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10315         }
10316         if (ndr_flags & NDR_BUFFERS) {
10317                 if (r->attribute_name) {
10318                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10319                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10320                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10321                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10322                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10323                                 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));
10324                         }
10325                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10326                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10328                 }
10329         }
10330         return NDR_ERR_SUCCESS;
10331 }
10332
10333 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10334 {
10335         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10336         ndr->depth++;
10337         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10338         ndr->depth++;
10339         if (r->attribute_name) {
10340                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10341         }
10342         ndr->depth--;
10343         ndr_print_uint32(ndr, "version", r->version);
10344         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10345         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10346         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10347         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10348         ndr->depth--;
10349 }
10350
10351 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10352 {
10353         uint32_t cntr_array_0;
10354         if (ndr_flags & NDR_SCALARS) {
10355                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10356                 NDR_CHECK(ndr_push_align(ndr, 8));
10357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10359                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10360                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10361                 }
10362                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10363         }
10364         if (ndr_flags & NDR_BUFFERS) {
10365                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10366                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10367                 }
10368         }
10369         return NDR_ERR_SUCCESS;
10370 }
10371
10372 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10373 {
10374         uint32_t cntr_array_0;
10375         TALLOC_CTX *_mem_save_array_0;
10376         if (ndr_flags & NDR_SCALARS) {
10377                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10378                 NDR_CHECK(ndr_pull_align(ndr, 8));
10379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10381                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10382                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10383                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10384                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10385                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10386                 }
10387                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10388                 if (r->array) {
10389                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10390                 }
10391                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10392         }
10393         if (ndr_flags & NDR_BUFFERS) {
10394                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10395                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10396                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10397                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10398                 }
10399                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10400         }
10401         return NDR_ERR_SUCCESS;
10402 }
10403
10404 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10405 {
10406         uint32_t cntr_array_0;
10407         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10408         ndr->depth++;
10409         ndr_print_uint32(ndr, "count", r->count);
10410         ndr_print_uint32(ndr, "reserved", r->reserved);
10411         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10412         ndr->depth++;
10413         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10414                 char *idx_0=NULL;
10415                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10416                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10417                         free(idx_0);
10418                 }
10419         }
10420         ndr->depth--;
10421         ndr->depth--;
10422 }
10423
10424 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10425 {
10426         if (ndr_flags & NDR_SCALARS) {
10427                 NDR_CHECK(ndr_push_align(ndr, 5));
10428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10429                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10430                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10432                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10433                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10434         }
10435         if (ndr_flags & NDR_BUFFERS) {
10436                 if (r->dsa_obj_dn) {
10437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10438                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10440                         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));
10441                 }
10442         }
10443         return NDR_ERR_SUCCESS;
10444 }
10445
10446 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10447 {
10448         uint32_t _ptr_dsa_obj_dn;
10449         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10450         if (ndr_flags & NDR_SCALARS) {
10451                 NDR_CHECK(ndr_pull_align(ndr, 5));
10452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10453                 if (_ptr_dsa_obj_dn) {
10454                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10455                 } else {
10456                         r->dsa_obj_dn = NULL;
10457                 }
10458                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10459                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10461                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10462                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10463         }
10464         if (ndr_flags & NDR_BUFFERS) {
10465                 if (r->dsa_obj_dn) {
10466                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10467                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10469                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10470                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10471                                 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));
10472                         }
10473                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10474                         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));
10475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10476                 }
10477         }
10478         return NDR_ERR_SUCCESS;
10479 }
10480
10481 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10482 {
10483         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10484         ndr->depth++;
10485         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10486         ndr->depth++;
10487         if (r->dsa_obj_dn) {
10488                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10489         }
10490         ndr->depth--;
10491         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10492         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10493         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10494         ndr_print_WERROR(ndr, "last_result", r->last_result);
10495         ndr->depth--;
10496 }
10497
10498 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10499 {
10500         uint32_t cntr_array_0;
10501         if (ndr_flags & NDR_SCALARS) {
10502                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10503                 NDR_CHECK(ndr_push_align(ndr, 5));
10504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10506                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10507                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10508                 }
10509                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10510         }
10511         if (ndr_flags & NDR_BUFFERS) {
10512                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10513                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10514                 }
10515         }
10516         return NDR_ERR_SUCCESS;
10517 }
10518
10519 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10520 {
10521         uint32_t cntr_array_0;
10522         TALLOC_CTX *_mem_save_array_0;
10523         if (ndr_flags & NDR_SCALARS) {
10524                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10525                 NDR_CHECK(ndr_pull_align(ndr, 5));
10526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10528                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10529                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10530                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10531                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10532                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10533                 }
10534                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10535                 if (r->array) {
10536                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10537                 }
10538                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10539         }
10540         if (ndr_flags & NDR_BUFFERS) {
10541                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10542                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10543                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10544                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10545                 }
10546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10547         }
10548         return NDR_ERR_SUCCESS;
10549 }
10550
10551 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10552 {
10553         uint32_t cntr_array_0;
10554         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10555         ndr->depth++;
10556         ndr_print_uint32(ndr, "count", r->count);
10557         ndr_print_uint32(ndr, "reserved", r->reserved);
10558         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10559         ndr->depth++;
10560         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10561                 char *idx_0=NULL;
10562                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10563                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10564                         free(idx_0);
10565                 }
10566         }
10567         ndr->depth--;
10568         ndr->depth--;
10569 }
10570
10571 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10572 {
10573         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
10574         return NDR_ERR_SUCCESS;
10575 }
10576
10577 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10578 {
10579         uint16_t v;
10580         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
10581         *r = v;
10582         return NDR_ERR_SUCCESS;
10583 }
10584
10585 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10586 {
10587         const char *val = NULL;
10588
10589         switch (r) {
10590                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10591                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10592                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10593                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10594                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10595         }
10596         ndr_print_enum(ndr, name, "ENUM", val, r);
10597 }
10598
10599 static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
10600 {
10601         if (ndr_flags & NDR_SCALARS) {
10602                 int level = ndr_push_get_switch_value(ndr, r);
10603                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
10604                 NDR_CHECK(ndr_push_union_align(ndr, 4));
10605                 switch (level) {
10606                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10607                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
10608                         break; }
10609
10610                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10611                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
10612                         break; }
10613
10614                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10615                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
10616                         break; }
10617
10618                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10619                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
10620                         break; }
10621
10622                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10623                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
10624                         break; }
10625
10626                         default: {
10627                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
10628                         break; }
10629
10630                 }
10631         }
10632         if (ndr_flags & NDR_BUFFERS) {
10633                 int level = ndr_push_get_switch_value(ndr, r);
10634                 switch (level) {
10635                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10636                         break;
10637
10638                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10639                         break;
10640
10641                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10642                         break;
10643
10644                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10645                         break;
10646
10647                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10648                         break;
10649
10650                         default:
10651                         break;
10652
10653                 }
10654         }
10655         return NDR_ERR_SUCCESS;
10656 }
10657
10658 static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
10659 {
10660         int level;
10661         uint16_t _level;
10662         level = ndr_pull_get_switch_value(ndr, r);
10663         if (ndr_flags & NDR_SCALARS) {
10664                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
10665                 if (_level != level) {
10666                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10667                 }
10668                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
10669                 switch (level) {
10670                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10671                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
10672                         break; }
10673
10674                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10675                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
10676                         break; }
10677
10678                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10679                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
10680                         break; }
10681
10682                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10683                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
10684                         break; }
10685
10686                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10687                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
10688                         break; }
10689
10690                         default: {
10691                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
10692                         break; }
10693
10694                 }
10695         }
10696         if (ndr_flags & NDR_BUFFERS) {
10697                 switch (level) {
10698                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10699                         break;
10700
10701                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10702                         break;
10703
10704                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10705                         break;
10706
10707                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10708                         break;
10709
10710                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10711                         break;
10712
10713                         default:
10714                         break;
10715
10716                 }
10717         }
10718         return NDR_ERR_SUCCESS;
10719 }
10720
10721 _PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
10722 {
10723         int level;
10724         level = ndr_print_get_switch_value(ndr, r);
10725         ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
10726         switch (level) {
10727                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10728                         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
10729                 break;
10730
10731                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10732                         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
10733                 break;
10734
10735                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10736                         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
10737                 break;
10738
10739                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10740                         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
10741                 break;
10742
10743                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10744                         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
10745                 break;
10746
10747                 default:
10748                         ndr_print_uint32(ndr, "unknown", r->unknown);
10749                 break;
10750
10751         }
10752 }
10753
10754 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10755 {
10756         if (ndr_flags & NDR_SCALARS) {
10757                 NDR_CHECK(ndr_push_align(ndr, 5));
10758                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10761                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10762                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
10763                 NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10764                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10765                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10766                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10767                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10768                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10769                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10770         }
10771         if (ndr_flags & NDR_BUFFERS) {
10772                 if (r->nc_dn) {
10773                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10774                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10775                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10776                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10777                 }
10778                 if (r->remote_dsa_obj_dn) {
10779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10782                         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));
10783                 }
10784                 if (r->remote_dsa_address) {
10785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10787                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10788                         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));
10789                 }
10790         }
10791         return NDR_ERR_SUCCESS;
10792 }
10793
10794 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10795 {
10796         uint32_t _ptr_nc_dn;
10797         TALLOC_CTX *_mem_save_nc_dn_0;
10798         uint32_t _ptr_remote_dsa_obj_dn;
10799         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10800         uint32_t _ptr_remote_dsa_address;
10801         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10802         if (ndr_flags & NDR_SCALARS) {
10803                 NDR_CHECK(ndr_pull_align(ndr, 5));
10804                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10807                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10808                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
10809                 NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10810                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10811                 if (_ptr_nc_dn) {
10812                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10813                 } else {
10814                         r->nc_dn = NULL;
10815                 }
10816                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10817                 if (_ptr_remote_dsa_obj_dn) {
10818                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10819                 } else {
10820                         r->remote_dsa_obj_dn = NULL;
10821                 }
10822                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10823                 if (_ptr_remote_dsa_address) {
10824                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10825                 } else {
10826                         r->remote_dsa_address = NULL;
10827                 }
10828                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10829                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10830                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10831         }
10832         if (ndr_flags & NDR_BUFFERS) {
10833                 if (r->nc_dn) {
10834                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10835                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10836                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10837                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10838                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10839                                 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));
10840                         }
10841                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10842                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10844                 }
10845                 if (r->remote_dsa_obj_dn) {
10846                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10847                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10848                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10849                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10850                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10851                                 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));
10852                         }
10853                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10854                         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));
10855                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10856                 }
10857                 if (r->remote_dsa_address) {
10858                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10859                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10860                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10861                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10862                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10863                                 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));
10864                         }
10865                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10866                         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));
10867                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10868                 }
10869         }
10870         return NDR_ERR_SUCCESS;
10871 }
10872
10873 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10874 {
10875         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10876         ndr->depth++;
10877         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10878         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10879         ndr_print_uint32(ndr, "priority", r->priority);
10880         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10881         ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
10882         ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
10883         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10884         ndr->depth++;
10885         if (r->nc_dn) {
10886                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10887         }
10888         ndr->depth--;
10889         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10890         ndr->depth++;
10891         if (r->remote_dsa_obj_dn) {
10892                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10893         }
10894         ndr->depth--;
10895         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10896         ndr->depth++;
10897         if (r->remote_dsa_address) {
10898                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10899         }
10900         ndr->depth--;
10901         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10902         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10903         ndr->depth--;
10904 }
10905
10906 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10907 {
10908         uint32_t cntr_array_0;
10909         if (ndr_flags & NDR_SCALARS) {
10910                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10911                 NDR_CHECK(ndr_push_align(ndr, 5));
10912                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10914                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10915                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10916                 }
10917                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10918         }
10919         if (ndr_flags & NDR_BUFFERS) {
10920                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10921                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10922                 }
10923         }
10924         return NDR_ERR_SUCCESS;
10925 }
10926
10927 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10928 {
10929         uint32_t cntr_array_0;
10930         TALLOC_CTX *_mem_save_array_0;
10931         if (ndr_flags & NDR_SCALARS) {
10932                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10933                 NDR_CHECK(ndr_pull_align(ndr, 5));
10934                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10936                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10937                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10938                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10939                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10940                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10941                 }
10942                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10943                 if (r->array) {
10944                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10945                 }
10946                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10947         }
10948         if (ndr_flags & NDR_BUFFERS) {
10949                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10950                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10951                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10952                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10953                 }
10954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10955         }
10956         return NDR_ERR_SUCCESS;
10957 }
10958
10959 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10960 {
10961         uint32_t cntr_array_0;
10962         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10963         ndr->depth++;
10964         ndr_print_NTTIME(ndr, "time", r->time);
10965         ndr_print_uint32(ndr, "count", r->count);
10966         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10967         ndr->depth++;
10968         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10969                 char *idx_0=NULL;
10970                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10971                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10972                         free(idx_0);
10973                 }
10974         }
10975         ndr->depth--;
10976         ndr->depth--;
10977 }
10978
10979 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10980 {
10981         if (ndr_flags & NDR_SCALARS) {
10982                 NDR_CHECK(ndr_push_align(ndr, 8));
10983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10984                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10987                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10988                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10990                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10991                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10992                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10993                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10994                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10995         }
10996         if (ndr_flags & NDR_BUFFERS) {
10997                 if (r->attribute_name) {
10998                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10999                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11000                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11001                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11002                 }
11003                 if (r->object_dn) {
11004                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11005                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11006                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11007                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11008                 }
11009                 if (r->binary) {
11010                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11011                 }
11012         }
11013         return NDR_ERR_SUCCESS;
11014 }
11015
11016 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
11017 {
11018         uint32_t _ptr_attribute_name;
11019         TALLOC_CTX *_mem_save_attribute_name_0;
11020         uint32_t _ptr_object_dn;
11021         TALLOC_CTX *_mem_save_object_dn_0;
11022         uint32_t _ptr_binary;
11023         TALLOC_CTX *_mem_save_binary_0;
11024         if (ndr_flags & NDR_SCALARS) {
11025                 NDR_CHECK(ndr_pull_align(ndr, 8));
11026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11027                 if (_ptr_attribute_name) {
11028                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11029                 } else {
11030                         r->attribute_name = NULL;
11031                 }
11032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11033                 if (_ptr_object_dn) {
11034                         NDR_PULL_ALLOC(ndr, r->object_dn);
11035                 } else {
11036                         r->object_dn = NULL;
11037                 }
11038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11040                 if (_ptr_binary) {
11041                         NDR_PULL_ALLOC(ndr, r->binary);
11042                 } else {
11043                         r->binary = NULL;
11044                 }
11045                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11046                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11048                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11049                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11050                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11051                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11052                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11053         }
11054         if (ndr_flags & NDR_BUFFERS) {
11055                 if (r->attribute_name) {
11056                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11057                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11058                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11059                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11060                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11061                                 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));
11062                         }
11063                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11064                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11066                 }
11067                 if (r->object_dn) {
11068                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11069                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11070                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11071                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11072                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11073                                 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));
11074                         }
11075                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11076                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11078                 }
11079                 if (r->binary) {
11080                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11081                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11082                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11084                 }
11085         }
11086         return NDR_ERR_SUCCESS;
11087 }
11088
11089 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
11090 {
11091         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
11092         ndr->depth++;
11093         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11094         ndr->depth++;
11095         if (r->attribute_name) {
11096                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11097         }
11098         ndr->depth--;
11099         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11100         ndr->depth++;
11101         if (r->object_dn) {
11102                 ndr_print_string(ndr, "object_dn", r->object_dn);
11103         }
11104         ndr->depth--;
11105         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);
11106         ndr_print_ptr(ndr, "binary", r->binary);
11107         ndr->depth++;
11108         if (r->binary) {
11109                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11110         }
11111         ndr->depth--;
11112         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11113         ndr_print_NTTIME(ndr, "created", r->created);
11114         ndr_print_uint32(ndr, "version", r->version);
11115         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11116         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11117         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11118         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11119         ndr->depth--;
11120 }
11121
11122 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11123 {
11124         uint32_t cntr_array_0;
11125         if (ndr_flags & NDR_SCALARS) {
11126                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11127                 NDR_CHECK(ndr_push_align(ndr, 8));
11128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11129                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11130                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11131                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11132                 }
11133                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11134         }
11135         if (ndr_flags & NDR_BUFFERS) {
11136                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11137                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11138                 }
11139         }
11140         return NDR_ERR_SUCCESS;
11141 }
11142
11143 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11144 {
11145         uint32_t cntr_array_0;
11146         TALLOC_CTX *_mem_save_array_0;
11147         if (ndr_flags & NDR_SCALARS) {
11148                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11149                 NDR_CHECK(ndr_pull_align(ndr, 8));
11150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11151                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11152                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11153                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11154                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11155                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11156                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11157                 }
11158                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11159                 if (r->array) {
11160                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11161                 }
11162                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11163         }
11164         if (ndr_flags & NDR_BUFFERS) {
11165                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11166                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11167                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11168                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11169                 }
11170                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11171         }
11172         return NDR_ERR_SUCCESS;
11173 }
11174
11175 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11176 {
11177         uint32_t cntr_array_0;
11178         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
11179         ndr->depth++;
11180         ndr_print_uint32(ndr, "count", r->count);
11181         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11182         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11183         ndr->depth++;
11184         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11185                 char *idx_0=NULL;
11186                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11187                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
11188                         free(idx_0);
11189                 }
11190         }
11191         ndr->depth--;
11192         ndr->depth--;
11193 }
11194
11195 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
11196 {
11197         uint32_t cntr_array_0;
11198         if (ndr_flags & NDR_SCALARS) {
11199                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11200                 NDR_CHECK(ndr_push_align(ndr, 8));
11201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11202                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11203                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11204                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11205                 }
11206                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11207         }
11208         if (ndr_flags & NDR_BUFFERS) {
11209         }
11210         return NDR_ERR_SUCCESS;
11211 }
11212
11213 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11214 {
11215         uint32_t cntr_array_0;
11216         TALLOC_CTX *_mem_save_array_0;
11217         if (ndr_flags & NDR_SCALARS) {
11218                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11219                 NDR_CHECK(ndr_pull_align(ndr, 8));
11220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11221                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11222                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11223                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11224                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11225                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11226                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11227                 }
11228                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11229                 if (r->array) {
11230                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11231                 }
11232                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11233         }
11234         if (ndr_flags & NDR_BUFFERS) {
11235         }
11236         return NDR_ERR_SUCCESS;
11237 }
11238
11239 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11240 {
11241         uint32_t cntr_array_0;
11242         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11243         ndr->depth++;
11244         ndr_print_uint32(ndr, "count", r->count);
11245         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11246         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11247         ndr->depth++;
11248         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11249                 char *idx_0=NULL;
11250                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11251                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11252                         free(idx_0);
11253                 }
11254         }
11255         ndr->depth--;
11256         ndr->depth--;
11257 }
11258
11259 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11260 {
11261         if (ndr_flags & NDR_SCALARS) {
11262                 NDR_CHECK(ndr_push_align(ndr, 8));
11263                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11264                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11265                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11266                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11267                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11268         }
11269         if (ndr_flags & NDR_BUFFERS) {
11270                 if (r->source_dsa_obj_dn) {
11271                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11272                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11273                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11274                         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));
11275                 }
11276         }
11277         return NDR_ERR_SUCCESS;
11278 }
11279
11280 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11281 {
11282         uint32_t _ptr_source_dsa_obj_dn;
11283         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11284         if (ndr_flags & NDR_SCALARS) {
11285                 NDR_CHECK(ndr_pull_align(ndr, 8));
11286                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11287                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11288                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11289                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11290                 if (_ptr_source_dsa_obj_dn) {
11291                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11292                 } else {
11293                         r->source_dsa_obj_dn = NULL;
11294                 }
11295                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11296         }
11297         if (ndr_flags & NDR_BUFFERS) {
11298                 if (r->source_dsa_obj_dn) {
11299                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11300                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11301                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11302                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11303                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11304                                 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));
11305                         }
11306                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11307                         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));
11308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11309                 }
11310         }
11311         return NDR_ERR_SUCCESS;
11312 }
11313
11314 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11315 {
11316         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11317         ndr->depth++;
11318         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11319         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11320         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11321         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11322         ndr->depth++;
11323         if (r->source_dsa_obj_dn) {
11324                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11325         }
11326         ndr->depth--;
11327         ndr->depth--;
11328 }
11329
11330 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11331 {
11332         uint32_t cntr_array_0;
11333         if (ndr_flags & NDR_SCALARS) {
11334                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11335                 NDR_CHECK(ndr_push_align(ndr, 8));
11336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11337                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11338                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11339                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11340                 }
11341                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11342         }
11343         if (ndr_flags & NDR_BUFFERS) {
11344                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11345                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11346                 }
11347         }
11348         return NDR_ERR_SUCCESS;
11349 }
11350
11351 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11352 {
11353         uint32_t cntr_array_0;
11354         TALLOC_CTX *_mem_save_array_0;
11355         if (ndr_flags & NDR_SCALARS) {
11356                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11357                 NDR_CHECK(ndr_pull_align(ndr, 8));
11358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11359                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11360                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11361                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11362                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11363                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11364                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11365                 }
11366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11367                 if (r->array) {
11368                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11369                 }
11370                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11371         }
11372         if (ndr_flags & NDR_BUFFERS) {
11373                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11374                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11375                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11376                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11377                 }
11378                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11379         }
11380         return NDR_ERR_SUCCESS;
11381 }
11382
11383 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11384 {
11385         uint32_t cntr_array_0;
11386         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11387         ndr->depth++;
11388         ndr_print_uint32(ndr, "count", r->count);
11389         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11390         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11391         ndr->depth++;
11392         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11393                 char *idx_0=NULL;
11394                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11395                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11396                         free(idx_0);
11397                 }
11398         }
11399         ndr->depth--;
11400         ndr->depth--;
11401 }
11402
11403 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11404 {
11405         if (ndr_flags & NDR_SCALARS) {
11406                 NDR_CHECK(ndr_push_align(ndr, 8));
11407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11409                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11410                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11411                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11412                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11414                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11415         }
11416         if (ndr_flags & NDR_BUFFERS) {
11417                 if (r->attribute_name) {
11418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11419                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11420                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11422                 }
11423                 if (r->originating_dsa_dn) {
11424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->originating_dsa_dn, ndr_charset_length(r->originating_dsa_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11428                 }
11429         }
11430         return NDR_ERR_SUCCESS;
11431 }
11432
11433 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11434 {
11435         uint32_t _ptr_attribute_name;
11436         TALLOC_CTX *_mem_save_attribute_name_0;
11437         uint32_t _ptr_originating_dsa_dn;
11438         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11439         if (ndr_flags & NDR_SCALARS) {
11440                 NDR_CHECK(ndr_pull_align(ndr, 8));
11441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11442                 if (_ptr_attribute_name) {
11443                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11444                 } else {
11445                         r->attribute_name = NULL;
11446                 }
11447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11448                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11449                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11450                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11451                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11453                 if (_ptr_originating_dsa_dn) {
11454                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11455                 } else {
11456                         r->originating_dsa_dn = NULL;
11457                 }
11458                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11459         }
11460         if (ndr_flags & NDR_BUFFERS) {
11461                 if (r->attribute_name) {
11462                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11463                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11464                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11465                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11466                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11467                                 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));
11468                         }
11469                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11470                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11471                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11472                 }
11473                 if (r->originating_dsa_dn) {
11474                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11475                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11476                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11477                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11478                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11479                                 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));
11480                         }
11481                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11482                         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));
11483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11484                 }
11485         }
11486         return NDR_ERR_SUCCESS;
11487 }
11488
11489 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11490 {
11491         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11492         ndr->depth++;
11493         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11494         ndr->depth++;
11495         if (r->attribute_name) {
11496                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11497         }
11498         ndr->depth--;
11499         ndr_print_uint32(ndr, "version", r->version);
11500         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11501         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11502         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11503         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11504         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11505         ndr->depth++;
11506         if (r->originating_dsa_dn) {
11507                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11508         }
11509         ndr->depth--;
11510         ndr->depth--;
11511 }
11512
11513 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11514 {
11515         uint32_t cntr_array_0;
11516         if (ndr_flags & NDR_SCALARS) {
11517                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11518                 NDR_CHECK(ndr_push_align(ndr, 8));
11519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11520                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11521                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11522                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11523                 }
11524                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11525         }
11526         if (ndr_flags & NDR_BUFFERS) {
11527                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11528                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11529                 }
11530         }
11531         return NDR_ERR_SUCCESS;
11532 }
11533
11534 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11535 {
11536         uint32_t cntr_array_0;
11537         TALLOC_CTX *_mem_save_array_0;
11538         if (ndr_flags & NDR_SCALARS) {
11539                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11540                 NDR_CHECK(ndr_pull_align(ndr, 8));
11541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11542                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11543                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11544                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11545                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11546                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11547                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11548                 }
11549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11550                 if (r->array) {
11551                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11552                 }
11553                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11554         }
11555         if (ndr_flags & NDR_BUFFERS) {
11556                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11557                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11558                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11559                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11560                 }
11561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11562         }
11563         return NDR_ERR_SUCCESS;
11564 }
11565
11566 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11567 {
11568         uint32_t cntr_array_0;
11569         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11570         ndr->depth++;
11571         ndr_print_uint32(ndr, "count", r->count);
11572         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11573         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11574         ndr->depth++;
11575         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11576                 char *idx_0=NULL;
11577                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11578                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11579                         free(idx_0);
11580                 }
11581         }
11582         ndr->depth--;
11583         ndr->depth--;
11584 }
11585
11586 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11587 {
11588         if (ndr_flags & NDR_SCALARS) {
11589                 NDR_CHECK(ndr_push_align(ndr, 8));
11590                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11591                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11594                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11595                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11597                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11598                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11599                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11600                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11602                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11603         }
11604         if (ndr_flags & NDR_BUFFERS) {
11605                 if (r->attribute_name) {
11606                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11607                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11609                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11610                 }
11611                 if (r->object_dn) {
11612                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11613                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11614                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11615                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11616                 }
11617                 if (r->binary) {
11618                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11619                 }
11620                 if (r->originating_dsa_dn) {
11621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11622                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11623                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11624                         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));
11625                 }
11626         }
11627         return NDR_ERR_SUCCESS;
11628 }
11629
11630 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11631 {
11632         uint32_t _ptr_attribute_name;
11633         TALLOC_CTX *_mem_save_attribute_name_0;
11634         uint32_t _ptr_object_dn;
11635         TALLOC_CTX *_mem_save_object_dn_0;
11636         uint32_t _ptr_binary;
11637         TALLOC_CTX *_mem_save_binary_0;
11638         uint32_t _ptr_originating_dsa_dn;
11639         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11640         if (ndr_flags & NDR_SCALARS) {
11641                 NDR_CHECK(ndr_pull_align(ndr, 8));
11642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11643                 if (_ptr_attribute_name) {
11644                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11645                 } else {
11646                         r->attribute_name = NULL;
11647                 }
11648                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11649                 if (_ptr_object_dn) {
11650                         NDR_PULL_ALLOC(ndr, r->object_dn);
11651                 } else {
11652                         r->object_dn = NULL;
11653                 }
11654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11656                 if (_ptr_binary) {
11657                         NDR_PULL_ALLOC(ndr, r->binary);
11658                 } else {
11659                         r->binary = NULL;
11660                 }
11661                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11662                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11664                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11665                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11666                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11667                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11668                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11669                 if (_ptr_originating_dsa_dn) {
11670                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11671                 } else {
11672                         r->originating_dsa_dn = NULL;
11673                 }
11674                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11675         }
11676         if (ndr_flags & NDR_BUFFERS) {
11677                 if (r->attribute_name) {
11678                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11679                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11680                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11681                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11682                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11683                                 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));
11684                         }
11685                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11686                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11688                 }
11689                 if (r->object_dn) {
11690                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11691                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11692                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11693                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11694                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11695                                 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));
11696                         }
11697                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11698                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11700                 }
11701                 if (r->binary) {
11702                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11703                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11704                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11705                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11706                 }
11707                 if (r->originating_dsa_dn) {
11708                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11709                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11711                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11712                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11713                                 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));
11714                         }
11715                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11716                         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));
11717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11718                 }
11719         }
11720         return NDR_ERR_SUCCESS;
11721 }
11722
11723 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11724 {
11725         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11726         ndr->depth++;
11727         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11728         ndr->depth++;
11729         if (r->attribute_name) {
11730                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11731         }
11732         ndr->depth--;
11733         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11734         ndr->depth++;
11735         if (r->object_dn) {
11736                 ndr_print_string(ndr, "object_dn", r->object_dn);
11737         }
11738         ndr->depth--;
11739         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);
11740         ndr_print_ptr(ndr, "binary", r->binary);
11741         ndr->depth++;
11742         if (r->binary) {
11743                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11744         }
11745         ndr->depth--;
11746         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11747         ndr_print_NTTIME(ndr, "created", r->created);
11748         ndr_print_uint32(ndr, "version", r->version);
11749         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11750         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11751         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11752         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11753         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11754         ndr->depth++;
11755         if (r->originating_dsa_dn) {
11756                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11757         }
11758         ndr->depth--;
11759         ndr->depth--;
11760 }
11761
11762 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11763 {
11764         uint32_t cntr_array_0;
11765         if (ndr_flags & NDR_SCALARS) {
11766                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11767                 NDR_CHECK(ndr_push_align(ndr, 8));
11768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11769                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11770                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11771                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11772                 }
11773                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11774         }
11775         if (ndr_flags & NDR_BUFFERS) {
11776                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11777                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11778                 }
11779         }
11780         return NDR_ERR_SUCCESS;
11781 }
11782
11783 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11784 {
11785         uint32_t cntr_array_0;
11786         TALLOC_CTX *_mem_save_array_0;
11787         if (ndr_flags & NDR_SCALARS) {
11788                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11789                 NDR_CHECK(ndr_pull_align(ndr, 8));
11790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11791                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11792                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11793                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11794                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11795                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11796                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11797                 }
11798                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11799                 if (r->array) {
11800                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11801                 }
11802                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11803         }
11804         if (ndr_flags & NDR_BUFFERS) {
11805                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11806                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11807                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11808                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11809                 }
11810                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11811         }
11812         return NDR_ERR_SUCCESS;
11813 }
11814
11815 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11816 {
11817         uint32_t cntr_array_0;
11818         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11819         ndr->depth++;
11820         ndr_print_uint32(ndr, "count", r->count);
11821         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11822         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11823         ndr->depth++;
11824         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11825                 char *idx_0=NULL;
11826                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11827                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11828                         free(idx_0);
11829                 }
11830         }
11831         ndr->depth--;
11832         ndr->depth--;
11833 }
11834
11835 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11836 {
11837         if (ndr_flags & NDR_SCALARS) {
11838                 NDR_CHECK(ndr_push_align(ndr, 8));
11839                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11842                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11843                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11844                 {
11845                         uint32_t _flags_save_ipv4address = ndr->flags;
11846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11847                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11848                         ndr->flags = _flags_save_ipv4address;
11849                 }
11850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11851                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11852         }
11853         if (ndr_flags & NDR_BUFFERS) {
11854         }
11855         return NDR_ERR_SUCCESS;
11856 }
11857
11858 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11859 {
11860         if (ndr_flags & NDR_SCALARS) {
11861                 NDR_CHECK(ndr_pull_align(ndr, 8));
11862                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11865                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11866                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11867                 {
11868                         uint32_t _flags_save_ipv4address = ndr->flags;
11869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11870                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11871                         ndr->flags = _flags_save_ipv4address;
11872                 }
11873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11874                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11875         }
11876         if (ndr_flags & NDR_BUFFERS) {
11877         }
11878         return NDR_ERR_SUCCESS;
11879 }
11880
11881 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11882 {
11883         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11884         ndr->depth++;
11885         ndr_print_hyper(ndr, "u1", r->u1);
11886         ndr_print_uint32(ndr, "u2", r->u2);
11887         ndr_print_uint32(ndr, "u3", r->u3);
11888         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11889         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11890         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11891         ndr_print_uint32(ndr, "u5", r->u5);
11892         ndr->depth--;
11893 }
11894
11895 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11896 {
11897         uint32_t cntr_array_0;
11898         if (ndr_flags & NDR_SCALARS) {
11899                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11900                 NDR_CHECK(ndr_push_align(ndr, 8));
11901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11903                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11904                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11905                 }
11906                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11907         }
11908         if (ndr_flags & NDR_BUFFERS) {
11909         }
11910         return NDR_ERR_SUCCESS;
11911 }
11912
11913 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11914 {
11915         uint32_t cntr_array_0;
11916         TALLOC_CTX *_mem_save_array_0;
11917         if (ndr_flags & NDR_SCALARS) {
11918                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11919                 NDR_CHECK(ndr_pull_align(ndr, 8));
11920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11921                 if (r->count > 10000) {
11922                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11923                 }
11924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11925                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11926                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11927                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11928                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11929                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11930                 }
11931                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11932                 if (r->array) {
11933                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11934                 }
11935                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11936         }
11937         if (ndr_flags & NDR_BUFFERS) {
11938         }
11939         return NDR_ERR_SUCCESS;
11940 }
11941
11942 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11943 {
11944         uint32_t cntr_array_0;
11945         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11946         ndr->depth++;
11947         ndr_print_uint32(ndr, "count", r->count);
11948         ndr_print_uint32(ndr, "reserved", r->reserved);
11949         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11950         ndr->depth++;
11951         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11952                 char *idx_0=NULL;
11953                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11954                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11955                         free(idx_0);
11956                 }
11957         }
11958         ndr->depth--;
11959         ndr->depth--;
11960 }
11961
11962 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11963 {
11964         if (ndr_flags & NDR_SCALARS) {
11965                 NDR_CHECK(ndr_push_align(ndr, 8));
11966                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11972                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11974                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11975         }
11976         if (ndr_flags & NDR_BUFFERS) {
11977                 if (r->str1) {
11978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11980                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11981                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11982                 }
11983         }
11984         return NDR_ERR_SUCCESS;
11985 }
11986
11987 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11988 {
11989         uint32_t _ptr_str1;
11990         TALLOC_CTX *_mem_save_str1_0;
11991         if (ndr_flags & NDR_SCALARS) {
11992                 NDR_CHECK(ndr_pull_align(ndr, 8));
11993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11994                 if (_ptr_str1) {
11995                         NDR_PULL_ALLOC(ndr, r->str1);
11996                 } else {
11997                         r->str1 = NULL;
11998                 }
11999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
12000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
12001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
12002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
12003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
12004                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
12005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
12006                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12007         }
12008         if (ndr_flags & NDR_BUFFERS) {
12009                 if (r->str1) {
12010                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12011                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
12012                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
12013                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
12014                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
12015                                 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));
12016                         }
12017                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
12018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
12019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
12020                 }
12021         }
12022         return NDR_ERR_SUCCESS;
12023 }
12024
12025 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
12026 {
12027         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
12028         ndr->depth++;
12029         ndr_print_ptr(ndr, "str1", r->str1);
12030         ndr->depth++;
12031         if (r->str1) {
12032                 ndr_print_string(ndr, "str1", r->str1);
12033         }
12034         ndr->depth--;
12035         ndr_print_uint32(ndr, "u1", r->u1);
12036         ndr_print_uint32(ndr, "u2", r->u2);
12037         ndr_print_uint32(ndr, "u3", r->u3);
12038         ndr_print_uint32(ndr, "u4", r->u4);
12039         ndr_print_uint32(ndr, "u5", r->u5);
12040         ndr_print_hyper(ndr, "u6", r->u6);
12041         ndr_print_uint32(ndr, "u7", r->u7);
12042         ndr->depth--;
12043 }
12044
12045 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
12046 {
12047         uint32_t cntr_array_0;
12048         if (ndr_flags & NDR_SCALARS) {
12049                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
12050                 NDR_CHECK(ndr_push_align(ndr, 8));
12051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12053                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12054                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12055                 }
12056                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12057         }
12058         if (ndr_flags & NDR_BUFFERS) {
12059                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12060                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
12061                 }
12062         }
12063         return NDR_ERR_SUCCESS;
12064 }
12065
12066 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
12067 {
12068         uint32_t cntr_array_0;
12069         TALLOC_CTX *_mem_save_array_0;
12070         if (ndr_flags & NDR_SCALARS) {
12071                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12072                 NDR_CHECK(ndr_pull_align(ndr, 8));
12073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12074                 if (r->count > 256) {
12075                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12076                 }
12077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12078                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12079                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12080                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12081                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12082                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12083                 }
12084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12085                 if (r->array) {
12086                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12087                 }
12088                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12089         }
12090         if (ndr_flags & NDR_BUFFERS) {
12091                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12092                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12093                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12094                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
12095                 }
12096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12097         }
12098         return NDR_ERR_SUCCESS;
12099 }
12100
12101 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
12102 {
12103         uint32_t cntr_array_0;
12104         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
12105         ndr->depth++;
12106         ndr_print_uint32(ndr, "count", r->count);
12107         ndr_print_uint32(ndr, "reserved", r->reserved);
12108         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12109         ndr->depth++;
12110         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
12111                 char *idx_0=NULL;
12112                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
12113                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
12114                         free(idx_0);
12115                 }
12116         }
12117         ndr->depth--;
12118         ndr->depth--;
12119 }
12120
12121 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
12122 {
12123         if (ndr_flags & NDR_SCALARS) {
12124                 int level = ndr_push_get_switch_value(ndr, r);
12125                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
12126                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12127                 switch (level) {
12128                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12129                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
12130                         break; }
12131
12132                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12133                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
12134                         break; }
12135
12136                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12137                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
12138                         break; }
12139
12140                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12141                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
12142                         break; }
12143
12144                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12145                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
12146                         break; }
12147
12148                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12149                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
12150                         break; }
12151
12152                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12153                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
12154                         break; }
12155
12156                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12157                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
12158                         break; }
12159
12160                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12161                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
12162                         break; }
12163
12164                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12165                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
12166                         break; }
12167
12168                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12169                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
12170                         break; }
12171
12172                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12173                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
12174                         break; }
12175
12176                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12177                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
12178                         break; }
12179
12180                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12181                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
12182                         break; }
12183
12184                         case DRSUAPI_DS_REPLICA_INFO_06: {
12185                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
12186                         break; }
12187
12188                         default:
12189                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12190                 }
12191         }
12192         if (ndr_flags & NDR_BUFFERS) {
12193                 int level = ndr_push_get_switch_value(ndr, r);
12194                 switch (level) {
12195                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12196                                 if (r->neighbours) {
12197                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12198                                 }
12199                         break;
12200
12201                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12202                                 if (r->cursors) {
12203                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12204                                 }
12205                         break;
12206
12207                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12208                                 if (r->objmetadata) {
12209                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12210                                 }
12211                         break;
12212
12213                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12214                                 if (r->connectfailures) {
12215                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12216                                 }
12217                         break;
12218
12219                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12220                                 if (r->linkfailures) {
12221                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12222                                 }
12223                         break;
12224
12225                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12226                                 if (r->pendingops) {
12227                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12228                                 }
12229                         break;
12230
12231                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12232                                 if (r->attrvalmetadata) {
12233                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12234                                 }
12235                         break;
12236
12237                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12238                                 if (r->cursors2) {
12239                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12240                                 }
12241                         break;
12242
12243                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12244                                 if (r->cursors3) {
12245                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12246                                 }
12247                         break;
12248
12249                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12250                                 if (r->objmetadata2) {
12251                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12252                                 }
12253                         break;
12254
12255                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12256                                 if (r->attrvalmetadata2) {
12257                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12258                                 }
12259                         break;
12260
12261                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12262                                 if (r->neighbours02) {
12263                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12264                                 }
12265                         break;
12266
12267                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12268                                 if (r->connections04) {
12269                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12270                                 }
12271                         break;
12272
12273                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12274                                 if (r->cursors05) {
12275                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12276                                 }
12277                         break;
12278
12279                         case DRSUAPI_DS_REPLICA_INFO_06:
12280                                 if (r->i06) {
12281                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12282                                 }
12283                         break;
12284
12285                         default:
12286                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12287                 }
12288         }
12289         return NDR_ERR_SUCCESS;
12290 }
12291
12292 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12293 {
12294         int level;
12295         uint32_t _level;
12296         TALLOC_CTX *_mem_save_neighbours_0;
12297         TALLOC_CTX *_mem_save_cursors_0;
12298         TALLOC_CTX *_mem_save_objmetadata_0;
12299         TALLOC_CTX *_mem_save_connectfailures_0;
12300         TALLOC_CTX *_mem_save_linkfailures_0;
12301         TALLOC_CTX *_mem_save_pendingops_0;
12302         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12303         TALLOC_CTX *_mem_save_cursors2_0;
12304         TALLOC_CTX *_mem_save_cursors3_0;
12305         TALLOC_CTX *_mem_save_objmetadata2_0;
12306         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12307         TALLOC_CTX *_mem_save_neighbours02_0;
12308         TALLOC_CTX *_mem_save_connections04_0;
12309         TALLOC_CTX *_mem_save_cursors05_0;
12310         TALLOC_CTX *_mem_save_i06_0;
12311         level = ndr_pull_get_switch_value(ndr, r);
12312         if (ndr_flags & NDR_SCALARS) {
12313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12314                 if (_level != level) {
12315                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12316                 }
12317                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12318                 switch (level) {
12319                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12320                                 uint32_t _ptr_neighbours;
12321                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12322                                 if (_ptr_neighbours) {
12323                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12324                                 } else {
12325                                         r->neighbours = NULL;
12326                                 }
12327                         break; }
12328
12329                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12330                                 uint32_t _ptr_cursors;
12331                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12332                                 if (_ptr_cursors) {
12333                                         NDR_PULL_ALLOC(ndr, r->cursors);
12334                                 } else {
12335                                         r->cursors = NULL;
12336                                 }
12337                         break; }
12338
12339                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12340                                 uint32_t _ptr_objmetadata;
12341                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12342                                 if (_ptr_objmetadata) {
12343                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12344                                 } else {
12345                                         r->objmetadata = NULL;
12346                                 }
12347                         break; }
12348
12349                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12350                                 uint32_t _ptr_connectfailures;
12351                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12352                                 if (_ptr_connectfailures) {
12353                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12354                                 } else {
12355                                         r->connectfailures = NULL;
12356                                 }
12357                         break; }
12358
12359                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12360                                 uint32_t _ptr_linkfailures;
12361                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12362                                 if (_ptr_linkfailures) {
12363                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12364                                 } else {
12365                                         r->linkfailures = NULL;
12366                                 }
12367                         break; }
12368
12369                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12370                                 uint32_t _ptr_pendingops;
12371                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12372                                 if (_ptr_pendingops) {
12373                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12374                                 } else {
12375                                         r->pendingops = NULL;
12376                                 }
12377                         break; }
12378
12379                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12380                                 uint32_t _ptr_attrvalmetadata;
12381                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12382                                 if (_ptr_attrvalmetadata) {
12383                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12384                                 } else {
12385                                         r->attrvalmetadata = NULL;
12386                                 }
12387                         break; }
12388
12389                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12390                                 uint32_t _ptr_cursors2;
12391                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12392                                 if (_ptr_cursors2) {
12393                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12394                                 } else {
12395                                         r->cursors2 = NULL;
12396                                 }
12397                         break; }
12398
12399                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12400                                 uint32_t _ptr_cursors3;
12401                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12402                                 if (_ptr_cursors3) {
12403                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12404                                 } else {
12405                                         r->cursors3 = NULL;
12406                                 }
12407                         break; }
12408
12409                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12410                                 uint32_t _ptr_objmetadata2;
12411                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12412                                 if (_ptr_objmetadata2) {
12413                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12414                                 } else {
12415                                         r->objmetadata2 = NULL;
12416                                 }
12417                         break; }
12418
12419                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12420                                 uint32_t _ptr_attrvalmetadata2;
12421                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12422                                 if (_ptr_attrvalmetadata2) {
12423                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12424                                 } else {
12425                                         r->attrvalmetadata2 = NULL;
12426                                 }
12427                         break; }
12428
12429                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12430                                 uint32_t _ptr_neighbours02;
12431                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12432                                 if (_ptr_neighbours02) {
12433                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
12434                                 } else {
12435                                         r->neighbours02 = NULL;
12436                                 }
12437                         break; }
12438
12439                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12440                                 uint32_t _ptr_connections04;
12441                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12442                                 if (_ptr_connections04) {
12443                                         NDR_PULL_ALLOC(ndr, r->connections04);
12444                                 } else {
12445                                         r->connections04 = NULL;
12446                                 }
12447                         break; }
12448
12449                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12450                                 uint32_t _ptr_cursors05;
12451                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12452                                 if (_ptr_cursors05) {
12453                                         NDR_PULL_ALLOC(ndr, r->cursors05);
12454                                 } else {
12455                                         r->cursors05 = NULL;
12456                                 }
12457                         break; }
12458
12459                         case DRSUAPI_DS_REPLICA_INFO_06: {
12460                                 uint32_t _ptr_i06;
12461                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12462                                 if (_ptr_i06) {
12463                                         NDR_PULL_ALLOC(ndr, r->i06);
12464                                 } else {
12465                                         r->i06 = NULL;
12466                                 }
12467                         break; }
12468
12469                         default:
12470                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12471                 }
12472         }
12473         if (ndr_flags & NDR_BUFFERS) {
12474                 switch (level) {
12475                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12476                                 if (r->neighbours) {
12477                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12478                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12479                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12480                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12481                                 }
12482                         break;
12483
12484                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12485                                 if (r->cursors) {
12486                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12487                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12488                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12489                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12490                                 }
12491                         break;
12492
12493                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12494                                 if (r->objmetadata) {
12495                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12496                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12497                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12498                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12499                                 }
12500                         break;
12501
12502                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12503                                 if (r->connectfailures) {
12504                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12505                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12506                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12507                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12508                                 }
12509                         break;
12510
12511                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12512                                 if (r->linkfailures) {
12513                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12514                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12515                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12516                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12517                                 }
12518                         break;
12519
12520                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12521                                 if (r->pendingops) {
12522                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12523                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12524                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12525                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12526                                 }
12527                         break;
12528
12529                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12530                                 if (r->attrvalmetadata) {
12531                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12532                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12533                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12534                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12535                                 }
12536                         break;
12537
12538                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12539                                 if (r->cursors2) {
12540                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12541                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12542                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12543                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12544                                 }
12545                         break;
12546
12547                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12548                                 if (r->cursors3) {
12549                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12550                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12551                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12552                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12553                                 }
12554                         break;
12555
12556                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12557                                 if (r->objmetadata2) {
12558                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12559                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12560                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12561                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12562                                 }
12563                         break;
12564
12565                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12566                                 if (r->attrvalmetadata2) {
12567                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12568                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12569                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12570                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12571                                 }
12572                         break;
12573
12574                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12575                                 if (r->neighbours02) {
12576                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12577                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12578                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12579                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12580                                 }
12581                         break;
12582
12583                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12584                                 if (r->connections04) {
12585                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12586                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12587                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12588                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12589                                 }
12590                         break;
12591
12592                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12593                                 if (r->cursors05) {
12594                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12595                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12596                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12597                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12598                                 }
12599                         break;
12600
12601                         case DRSUAPI_DS_REPLICA_INFO_06:
12602                                 if (r->i06) {
12603                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12604                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12605                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12606                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12607                                 }
12608                         break;
12609
12610                         default:
12611                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12612                 }
12613         }
12614         return NDR_ERR_SUCCESS;
12615 }
12616
12617 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12618 {
12619         int level;
12620         level = ndr_print_get_switch_value(ndr, r);
12621         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12622         switch (level) {
12623                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12624                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12625                         ndr->depth++;
12626                         if (r->neighbours) {
12627                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12628                         }
12629                         ndr->depth--;
12630                 break;
12631
12632                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12633                         ndr_print_ptr(ndr, "cursors", r->cursors);
12634                         ndr->depth++;
12635                         if (r->cursors) {
12636                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12637                         }
12638                         ndr->depth--;
12639                 break;
12640
12641                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12642                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12643                         ndr->depth++;
12644                         if (r->objmetadata) {
12645                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12646                         }
12647                         ndr->depth--;
12648                 break;
12649
12650                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12651                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12652                         ndr->depth++;
12653                         if (r->connectfailures) {
12654                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12655                         }
12656                         ndr->depth--;
12657                 break;
12658
12659                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12660                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12661                         ndr->depth++;
12662                         if (r->linkfailures) {
12663                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12664                         }
12665                         ndr->depth--;
12666                 break;
12667
12668                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12669                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12670                         ndr->depth++;
12671                         if (r->pendingops) {
12672                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12673                         }
12674                         ndr->depth--;
12675                 break;
12676
12677                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12678                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12679                         ndr->depth++;
12680                         if (r->attrvalmetadata) {
12681                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12682                         }
12683                         ndr->depth--;
12684                 break;
12685
12686                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12687                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12688                         ndr->depth++;
12689                         if (r->cursors2) {
12690                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12691                         }
12692                         ndr->depth--;
12693                 break;
12694
12695                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12696                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12697                         ndr->depth++;
12698                         if (r->cursors3) {
12699                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12700                         }
12701                         ndr->depth--;
12702                 break;
12703
12704                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12705                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12706                         ndr->depth++;
12707                         if (r->objmetadata2) {
12708                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12709                         }
12710                         ndr->depth--;
12711                 break;
12712
12713                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12714                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12715                         ndr->depth++;
12716                         if (r->attrvalmetadata2) {
12717                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12718                         }
12719                         ndr->depth--;
12720                 break;
12721
12722                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12723                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12724                         ndr->depth++;
12725                         if (r->neighbours02) {
12726                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12727                         }
12728                         ndr->depth--;
12729                 break;
12730
12731                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12732                         ndr_print_ptr(ndr, "connections04", r->connections04);
12733                         ndr->depth++;
12734                         if (r->connections04) {
12735                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12736                         }
12737                         ndr->depth--;
12738                 break;
12739
12740                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12741                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12742                         ndr->depth++;
12743                         if (r->cursors05) {
12744                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12745                         }
12746                         ndr->depth--;
12747                 break;
12748
12749                 case DRSUAPI_DS_REPLICA_INFO_06:
12750                         ndr_print_ptr(ndr, "i06", r->i06);
12751                         ndr->depth++;
12752                         if (r->i06) {
12753                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12754                         }
12755                         ndr->depth--;
12756                 break;
12757
12758                 default:
12759                         ndr_print_bad_level(ndr, name, level);
12760         }
12761 }
12762
12763 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12764 {
12765         if (ndr_flags & NDR_SCALARS) {
12766                 int level = ndr_push_get_switch_value(ndr, r);
12767                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12768                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12769                 switch (level) {
12770                         case 1: {
12771                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12772                         break; }
12773
12774                         default:
12775                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12776                 }
12777         }
12778         if (ndr_flags & NDR_BUFFERS) {
12779                 int level = ndr_push_get_switch_value(ndr, r);
12780                 switch (level) {
12781                         case 1:
12782                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12783                         break;
12784
12785                         default:
12786                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12787                 }
12788         }
12789         return NDR_ERR_SUCCESS;
12790 }
12791
12792 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12793 {
12794         int level;
12795         int32_t _level;
12796         level = ndr_pull_get_switch_value(ndr, r);
12797         if (ndr_flags & NDR_SCALARS) {
12798                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12799                 if (_level != level) {
12800                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12801                 }
12802                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12803                 switch (level) {
12804                         case 1: {
12805                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12806                         break; }
12807
12808                         default:
12809                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12810                 }
12811         }
12812         if (ndr_flags & NDR_BUFFERS) {
12813                 switch (level) {
12814                         case 1:
12815                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12816                         break;
12817
12818                         default:
12819                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12820                 }
12821         }
12822         return NDR_ERR_SUCCESS;
12823 }
12824
12825 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12826 {
12827         int level;
12828         level = ndr_print_get_switch_value(ndr, r);
12829         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12830         switch (level) {
12831                 case 1:
12832                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12833                 break;
12834
12835                 default:
12836                         ndr_print_bad_level(ndr, name, level);
12837         }
12838 }
12839
12840 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12841 {
12842         uint32_t cntr_req_array_1;
12843         if (ndr_flags & NDR_SCALARS) {
12844                 NDR_CHECK(ndr_push_align(ndr, 5));
12845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12847                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12848         }
12849         if (ndr_flags & NDR_BUFFERS) {
12850                 if (r->req_array) {
12851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12852                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12853                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12854                         }
12855                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12856                                 if (r->req_array[cntr_req_array_1]) {
12857                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12858                                 }
12859                         }
12860                 }
12861         }
12862         return NDR_ERR_SUCCESS;
12863 }
12864
12865 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12866 {
12867         uint32_t _ptr_req_array;
12868         uint32_t cntr_req_array_1;
12869         TALLOC_CTX *_mem_save_req_array_0;
12870         TALLOC_CTX *_mem_save_req_array_1;
12871         TALLOC_CTX *_mem_save_req_array_2;
12872         if (ndr_flags & NDR_SCALARS) {
12873                 NDR_CHECK(ndr_pull_align(ndr, 5));
12874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12875                 if (r->num_req < 1 || r->num_req > 10000) {
12876                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12877                 }
12878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12879                 if (_ptr_req_array) {
12880                         NDR_PULL_ALLOC(ndr, r->req_array);
12881                 } else {
12882                         r->req_array = NULL;
12883                 }
12884                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12885         }
12886         if (ndr_flags & NDR_BUFFERS) {
12887                 if (r->req_array) {
12888                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12889                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12890                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12891                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12892                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12893                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12894                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12895                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12896                                 if (_ptr_req_array) {
12897                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12898                                 } else {
12899                                         r->req_array[cntr_req_array_1] = NULL;
12900                                 }
12901                         }
12902                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12903                                 if (r->req_array[cntr_req_array_1]) {
12904                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12905                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12906                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12907                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12908                                 }
12909                         }
12910                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12912                 }
12913                 if (r->req_array) {
12914                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12915                 }
12916         }
12917         return NDR_ERR_SUCCESS;
12918 }
12919
12920 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12921 {
12922         uint32_t cntr_req_array_1;
12923         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12924         ndr->depth++;
12925         ndr_print_uint32(ndr, "num_req", r->num_req);
12926         ndr_print_ptr(ndr, "req_array", r->req_array);
12927         ndr->depth++;
12928         if (r->req_array) {
12929                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12930                 ndr->depth++;
12931                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12932                         char *idx_1=NULL;
12933                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12934                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12935                                 ndr->depth++;
12936                                 if (r->req_array[cntr_req_array_1]) {
12937                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12938                                 }
12939                                 ndr->depth--;
12940                                 free(idx_1);
12941                         }
12942                 }
12943                 ndr->depth--;
12944         }
12945         ndr->depth--;
12946         ndr->depth--;
12947 }
12948
12949 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12950 {
12951         if (ndr_flags & NDR_SCALARS) {
12952                 int level = ndr_push_get_switch_value(ndr, r);
12953                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12954                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12955                 switch (level) {
12956                         case 1: {
12957                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12958                         break; }
12959
12960                         default:
12961                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12962                 }
12963         }
12964         if (ndr_flags & NDR_BUFFERS) {
12965                 int level = ndr_push_get_switch_value(ndr, r);
12966                 switch (level) {
12967                         case 1:
12968                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12969                         break;
12970
12971                         default:
12972                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12973                 }
12974         }
12975         return NDR_ERR_SUCCESS;
12976 }
12977
12978 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12979 {
12980         int level;
12981         int32_t _level;
12982         level = ndr_pull_get_switch_value(ndr, r);
12983         if (ndr_flags & NDR_SCALARS) {
12984                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12985                 if (_level != level) {
12986                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12987                 }
12988                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12989                 switch (level) {
12990                         case 1: {
12991                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12992                         break; }
12993
12994                         default:
12995                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12996                 }
12997         }
12998         if (ndr_flags & NDR_BUFFERS) {
12999                 switch (level) {
13000                         case 1:
13001                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
13002                         break;
13003
13004                         default:
13005                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13006                 }
13007         }
13008         return NDR_ERR_SUCCESS;
13009 }
13010
13011 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
13012 {
13013         int level;
13014         level = ndr_print_get_switch_value(ndr, r);
13015         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
13016         switch (level) {
13017                 case 1:
13018                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
13019                 break;
13020
13021                 default:
13022                         ndr_print_bad_level(ndr, name, level);
13023         }
13024 }
13025
13026 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
13027 {
13028         if (ndr_flags & NDR_SCALARS) {
13029                 NDR_CHECK(ndr_push_align(ndr, 4));
13030                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
13031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
13032                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
13033         }
13034         if (ndr_flags & NDR_BUFFERS) {
13035         }
13036         return NDR_ERR_SUCCESS;
13037 }
13038
13039 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
13040 {
13041         if (ndr_flags & NDR_SCALARS) {
13042                 NDR_CHECK(ndr_pull_align(ndr, 4));
13043                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
13044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
13045                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
13046         }
13047         if (ndr_flags & NDR_BUFFERS) {
13048         }
13049         return NDR_ERR_SUCCESS;
13050 }
13051
13052 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
13053 {
13054         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
13055         ndr->depth++;
13056         ndr_print_WERROR(ndr, "error_code", r->error_code);
13057         ndr_print_uint32(ndr, "site_cost", r->site_cost);
13058         ndr->depth--;
13059 }
13060
13061 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
13062 {
13063         uint32_t cntr_info_1;
13064         if (ndr_flags & NDR_SCALARS) {
13065                 NDR_CHECK(ndr_push_align(ndr, 5));
13066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
13067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
13068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
13069                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13070         }
13071         if (ndr_flags & NDR_BUFFERS) {
13072                 if (r->info) {
13073                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
13074                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
13075                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
13076                         }
13077                 }
13078         }
13079         return NDR_ERR_SUCCESS;
13080 }
13081
13082 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
13083 {
13084         uint32_t _ptr_info;
13085         uint32_t cntr_info_1;
13086         TALLOC_CTX *_mem_save_info_0;
13087         TALLOC_CTX *_mem_save_info_1;
13088         if (ndr_flags & NDR_SCALARS) {
13089                 NDR_CHECK(ndr_pull_align(ndr, 5));
13090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
13091                 if (r->num_info > 10000) {
13092                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13093                 }
13094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13095                 if (_ptr_info) {
13096                         NDR_PULL_ALLOC(ndr, r->info);
13097                 } else {
13098                         r->info = NULL;
13099                 }
13100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
13101                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13102         }
13103         if (ndr_flags & NDR_BUFFERS) {
13104                 if (r->info) {
13105                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13106                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
13108                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
13109                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
13110                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13111                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
13112                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
13113                         }
13114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
13115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13116                 }
13117                 if (r->info) {
13118                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
13119                 }
13120         }
13121         return NDR_ERR_SUCCESS;
13122 }
13123
13124 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
13125 {
13126         uint32_t cntr_info_1;
13127         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
13128         ndr->depth++;
13129         ndr_print_uint32(ndr, "num_info", r->num_info);
13130         ndr_print_ptr(ndr, "info", r->info);
13131         ndr->depth++;
13132         if (r->info) {
13133                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
13134                 ndr->depth++;
13135                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
13136                         char *idx_1=NULL;
13137                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
13138                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
13139                                 free(idx_1);
13140                         }
13141                 }
13142                 ndr->depth--;
13143         }
13144         ndr->depth--;
13145         ndr_print_uint32(ndr, "unknown", r->unknown);
13146         ndr->depth--;
13147 }
13148
13149 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
13150 {
13151         if (ndr_flags & NDR_SCALARS) {
13152                 int level = ndr_push_get_switch_value(ndr, r);
13153                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13154                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13155                 switch (level) {
13156                         case 1: {
13157                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13158                         break; }
13159
13160                         default:
13161                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13162                 }
13163         }
13164         if (ndr_flags & NDR_BUFFERS) {
13165                 int level = ndr_push_get_switch_value(ndr, r);
13166                 switch (level) {
13167                         case 1:
13168                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13169                         break;
13170
13171                         default:
13172                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13173                 }
13174         }
13175         return NDR_ERR_SUCCESS;
13176 }
13177
13178 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
13179 {
13180         int level;
13181         int32_t _level;
13182         level = ndr_pull_get_switch_value(ndr, r);
13183         if (ndr_flags & NDR_SCALARS) {
13184                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13185                 if (_level != level) {
13186                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13187                 }
13188                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13189                 switch (level) {
13190                         case 1: {
13191                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13192                         break; }
13193
13194                         default:
13195                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13196                 }
13197         }
13198         if (ndr_flags & NDR_BUFFERS) {
13199                 switch (level) {
13200                         case 1:
13201                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13202                         break;
13203
13204                         default:
13205                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13206                 }
13207         }
13208         return NDR_ERR_SUCCESS;
13209 }
13210
13211 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
13212 {
13213         int level;
13214         level = ndr_print_get_switch_value(ndr, r);
13215         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
13216         switch (level) {
13217                 case 1:
13218                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13219                 break;
13220
13221                 default:
13222                         ndr_print_bad_level(ndr, name, level);
13223         }
13224 }
13225
13226 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13227 {
13228         uint32_t cntr_site_to_1;
13229         if (ndr_flags & NDR_SCALARS) {
13230                 NDR_CHECK(ndr_push_align(ndr, 5));
13231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13233                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13235                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13236         }
13237         if (ndr_flags & NDR_BUFFERS) {
13238                 if (r->site_from) {
13239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13240                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13241                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13242                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13243                 }
13244                 if (r->site_to) {
13245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13246                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13247                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13248                         }
13249                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13250                                 if (r->site_to[cntr_site_to_1]) {
13251                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13252                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13253                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13254                                         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));
13255                                 }
13256                         }
13257                 }
13258         }
13259         return NDR_ERR_SUCCESS;
13260 }
13261
13262 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13263 {
13264         uint32_t _ptr_site_from;
13265         TALLOC_CTX *_mem_save_site_from_0;
13266         uint32_t _ptr_site_to;
13267         uint32_t cntr_site_to_1;
13268         TALLOC_CTX *_mem_save_site_to_0;
13269         TALLOC_CTX *_mem_save_site_to_1;
13270         TALLOC_CTX *_mem_save_site_to_2;
13271         if (ndr_flags & NDR_SCALARS) {
13272                 NDR_CHECK(ndr_pull_align(ndr, 5));
13273                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13274                 if (_ptr_site_from) {
13275                         NDR_PULL_ALLOC(ndr, r->site_from);
13276                 } else {
13277                         r->site_from = NULL;
13278                 }
13279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13280                 if (r->num_req < 1 || r->num_req > 10000) {
13281                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13282                 }
13283                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13284                 if (_ptr_site_to) {
13285                         NDR_PULL_ALLOC(ndr, r->site_to);
13286                 } else {
13287                         r->site_to = NULL;
13288                 }
13289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13290                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13291         }
13292         if (ndr_flags & NDR_BUFFERS) {
13293                 if (r->site_from) {
13294                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13295                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13296                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13297                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13298                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13299                                 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));
13300                         }
13301                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13302                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13303                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13304                 }
13305                 if (r->site_to) {
13306                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13307                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13308                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13309                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13310                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13311                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13312                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13313                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13314                                 if (_ptr_site_to) {
13315                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13316                                 } else {
13317                                         r->site_to[cntr_site_to_1] = NULL;
13318                                 }
13319                         }
13320                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13321                                 if (r->site_to[cntr_site_to_1]) {
13322                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13323                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13324                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13325                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13326                                         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])) {
13327                                                 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]));
13328                                         }
13329                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13330                                         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));
13331                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13332                                 }
13333                         }
13334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13336                 }
13337                 if (r->site_to) {
13338                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13339                 }
13340         }
13341         return NDR_ERR_SUCCESS;
13342 }
13343
13344 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13345 {
13346         uint32_t cntr_site_to_1;
13347         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13348         ndr->depth++;
13349         ndr_print_ptr(ndr, "site_from", r->site_from);
13350         ndr->depth++;
13351         if (r->site_from) {
13352                 ndr_print_string(ndr, "site_from", r->site_from);
13353         }
13354         ndr->depth--;
13355         ndr_print_uint32(ndr, "num_req", r->num_req);
13356         ndr_print_ptr(ndr, "site_to", r->site_to);
13357         ndr->depth++;
13358         if (r->site_to) {
13359                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13360                 ndr->depth++;
13361                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13362                         char *idx_1=NULL;
13363                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13364                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13365                                 ndr->depth++;
13366                                 if (r->site_to[cntr_site_to_1]) {
13367                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13368                                 }
13369                                 ndr->depth--;
13370                                 free(idx_1);
13371                         }
13372                 }
13373                 ndr->depth--;
13374         }
13375         ndr->depth--;
13376         ndr_print_uint32(ndr, "flags", r->flags);
13377         ndr->depth--;
13378 }
13379
13380 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13381 {
13382         if (ndr_flags & NDR_SCALARS) {
13383                 int level = ndr_push_get_switch_value(ndr, r);
13384                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13385                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13386                 switch (level) {
13387                         case 1: {
13388                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13389                         break; }
13390
13391                         default:
13392                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13393                 }
13394         }
13395         if (ndr_flags & NDR_BUFFERS) {
13396                 int level = ndr_push_get_switch_value(ndr, r);
13397                 switch (level) {
13398                         case 1:
13399                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13400                         break;
13401
13402                         default:
13403                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13404                 }
13405         }
13406         return NDR_ERR_SUCCESS;
13407 }
13408
13409 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13410 {
13411         int level;
13412         int32_t _level;
13413         level = ndr_pull_get_switch_value(ndr, r);
13414         if (ndr_flags & NDR_SCALARS) {
13415                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13416                 if (_level != level) {
13417                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13418                 }
13419                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13420                 switch (level) {
13421                         case 1: {
13422                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13423                         break; }
13424
13425                         default:
13426                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13427                 }
13428         }
13429         if (ndr_flags & NDR_BUFFERS) {
13430                 switch (level) {
13431                         case 1:
13432                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13433                         break;
13434
13435                         default:
13436                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13437                 }
13438         }
13439         return NDR_ERR_SUCCESS;
13440 }
13441
13442 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13443 {
13444         int level;
13445         level = ndr_print_get_switch_value(ndr, r);
13446         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13447         switch (level) {
13448                 case 1:
13449                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13450                 break;
13451
13452                 default:
13453                         ndr_print_bad_level(ndr, name, level);
13454         }
13455 }
13456
13457 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13458 {
13459         if (flags & NDR_IN) {
13460                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13461                 if (r->in.bind_guid) {
13462                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13463                 }
13464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13465                 if (r->in.bind_info) {
13466                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13467                 }
13468         }
13469         if (flags & NDR_OUT) {
13470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13471                 if (r->out.bind_info) {
13472                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13473                 }
13474                 if (r->out.bind_handle == NULL) {
13475                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13476                 }
13477                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13478                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13479         }
13480         return NDR_ERR_SUCCESS;
13481 }
13482
13483 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13484 {
13485         uint32_t _ptr_bind_guid;
13486         uint32_t _ptr_bind_info;
13487         TALLOC_CTX *_mem_save_bind_guid_0;
13488         TALLOC_CTX *_mem_save_bind_info_0;
13489         TALLOC_CTX *_mem_save_bind_handle_0;
13490         if (flags & NDR_IN) {
13491                 ZERO_STRUCT(r->out);
13492
13493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13494                 if (_ptr_bind_guid) {
13495                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13496                 } else {
13497                         r->in.bind_guid = NULL;
13498                 }
13499                 if (r->in.bind_guid) {
13500                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13501                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13502                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13504                 }
13505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13506                 if (_ptr_bind_info) {
13507                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13508                 } else {
13509                         r->in.bind_info = NULL;
13510                 }
13511                 if (r->in.bind_info) {
13512                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13513                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13514                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13515                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13516                 }
13517                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13518                 ZERO_STRUCTP(r->out.bind_handle);
13519         }
13520         if (flags & NDR_OUT) {
13521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13522                 if (_ptr_bind_info) {
13523                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13524                 } else {
13525                         r->out.bind_info = NULL;
13526                 }
13527                 if (r->out.bind_info) {
13528                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13529                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13530                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13532                 }
13533                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13534                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13535                 }
13536                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13537                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13538                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
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_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13546 {
13547         ndr_print_struct(ndr, name, "drsuapi_DsBind");
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_DsBind");
13554                 ndr->depth++;
13555                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13556                 ndr->depth++;
13557                 if (r->in.bind_guid) {
13558                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13559                 }
13560                 ndr->depth--;
13561                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13562                 ndr->depth++;
13563                 if (r->in.bind_info) {
13564                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13565                 }
13566                 ndr->depth--;
13567                 ndr->depth--;
13568         }
13569         if (flags & NDR_OUT) {
13570                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13571                 ndr->depth++;
13572                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13573                 ndr->depth++;
13574                 if (r->out.bind_info) {
13575                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13576                 }
13577                 ndr->depth--;
13578                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13579                 ndr->depth++;
13580                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13581                 ndr->depth--;
13582                 ndr_print_WERROR(ndr, "result", r->out.result);
13583                 ndr->depth--;
13584         }
13585         ndr->depth--;
13586 }
13587
13588 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13589 {
13590         if (flags & NDR_IN) {
13591                 if (r->in.bind_handle == NULL) {
13592                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13593                 }
13594                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13595         }
13596         if (flags & NDR_OUT) {
13597                 if (r->out.bind_handle == NULL) {
13598                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13599                 }
13600                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13601                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13602         }
13603         return NDR_ERR_SUCCESS;
13604 }
13605
13606 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13607 {
13608         TALLOC_CTX *_mem_save_bind_handle_0;
13609         if (flags & NDR_IN) {
13610                 ZERO_STRUCT(r->out);
13611
13612                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13613                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13614                 }
13615                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13616                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13617                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13619                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13620                 *r->out.bind_handle = *r->in.bind_handle;
13621         }
13622         if (flags & NDR_OUT) {
13623                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13624                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13625                 }
13626                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13627                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13628                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13629                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13631         }
13632         return NDR_ERR_SUCCESS;
13633 }
13634
13635 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13636 {
13637         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13638         ndr->depth++;
13639         if (flags & NDR_SET_VALUES) {
13640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13641         }
13642         if (flags & NDR_IN) {
13643                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13644                 ndr->depth++;
13645                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13646                 ndr->depth++;
13647                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13648                 ndr->depth--;
13649                 ndr->depth--;
13650         }
13651         if (flags & NDR_OUT) {
13652                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13653                 ndr->depth++;
13654                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13655                 ndr->depth++;
13656                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13657                 ndr->depth--;
13658                 ndr_print_WERROR(ndr, "result", r->out.result);
13659                 ndr->depth--;
13660         }
13661         ndr->depth--;
13662 }
13663
13664 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13665 {
13666         if (flags & NDR_IN) {
13667                 if (r->in.bind_handle == NULL) {
13668                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13669                 }
13670                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13671                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13672                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13673                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13674         }
13675         if (flags & NDR_OUT) {
13676                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13677         }
13678         return NDR_ERR_SUCCESS;
13679 }
13680
13681 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13682 {
13683         TALLOC_CTX *_mem_save_bind_handle_0;
13684         if (flags & NDR_IN) {
13685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13686                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13687                 }
13688                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13689                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13690                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13692                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13693                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13694                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13695         }
13696         if (flags & NDR_OUT) {
13697                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13698         }
13699         return NDR_ERR_SUCCESS;
13700 }
13701
13702 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13703 {
13704         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13705         ndr->depth++;
13706         if (flags & NDR_SET_VALUES) {
13707                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13708         }
13709         if (flags & NDR_IN) {
13710                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13711                 ndr->depth++;
13712                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13713                 ndr->depth++;
13714                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13715                 ndr->depth--;
13716                 ndr_print_int32(ndr, "level", r->in.level);
13717                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13718                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13719                 ndr->depth--;
13720         }
13721         if (flags & NDR_OUT) {
13722                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13723                 ndr->depth++;
13724                 ndr_print_WERROR(ndr, "result", r->out.result);
13725                 ndr->depth--;
13726         }
13727         ndr->depth--;
13728 }
13729
13730 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13731 {
13732         if (flags & NDR_IN) {
13733                 if (r->in.bind_handle == NULL) {
13734                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13735                 }
13736                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13737                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13738                 if (r->in.req == NULL) {
13739                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13740                 }
13741                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13742                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13743         }
13744         if (flags & NDR_OUT) {
13745                 if (r->out.level_out == NULL) {
13746                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13747                 }
13748                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13749                 if (r->out.ctr == NULL) {
13750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13751                 }
13752                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13753                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13754                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13755         }
13756         return NDR_ERR_SUCCESS;
13757 }
13758
13759 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13760 {
13761         TALLOC_CTX *_mem_save_bind_handle_0;
13762         TALLOC_CTX *_mem_save_req_0;
13763         TALLOC_CTX *_mem_save_level_out_0;
13764         TALLOC_CTX *_mem_save_ctr_0;
13765         if (flags & NDR_IN) {
13766                 ZERO_STRUCT(r->out);
13767
13768                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13769                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13770                 }
13771                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13772                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13773                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13774                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13775                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13777                         NDR_PULL_ALLOC(ndr, r->in.req);
13778                 }
13779                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13780                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13781                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13782                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13783                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13784                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13785                 ZERO_STRUCTP(r->out.level_out);
13786                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13787                 ZERO_STRUCTP(r->out.ctr);
13788         }
13789         if (flags & NDR_OUT) {
13790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13791                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13792                 }
13793                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13794                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13795                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13797                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13798                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13799                 }
13800                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13801                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13802                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13803                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13805                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13806         }
13807         return NDR_ERR_SUCCESS;
13808 }
13809
13810 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13811 {
13812         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13813         ndr->depth++;
13814         if (flags & NDR_SET_VALUES) {
13815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13816         }
13817         if (flags & NDR_IN) {
13818                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13819                 ndr->depth++;
13820                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13821                 ndr->depth++;
13822                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13823                 ndr->depth--;
13824                 ndr_print_int32(ndr, "level", r->in.level);
13825                 ndr_print_ptr(ndr, "req", r->in.req);
13826                 ndr->depth++;
13827                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13828                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13829                 ndr->depth--;
13830                 ndr->depth--;
13831         }
13832         if (flags & NDR_OUT) {
13833                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13834                 ndr->depth++;
13835                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13836                 ndr->depth++;
13837                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13838                 ndr->depth--;
13839                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13840                 ndr->depth++;
13841                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13842                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13843                 ndr->depth--;
13844                 ndr_print_WERROR(ndr, "result", r->out.result);
13845                 ndr->depth--;
13846         }
13847         ndr->depth--;
13848 }
13849
13850 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13851 {
13852         if (flags & NDR_IN) {
13853                 if (r->in.bind_handle == NULL) {
13854                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13855                 }
13856                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13857                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13858                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13859                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13860         }
13861         if (flags & NDR_OUT) {
13862                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13863         }
13864         return NDR_ERR_SUCCESS;
13865 }
13866
13867 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13868 {
13869         TALLOC_CTX *_mem_save_bind_handle_0;
13870         if (flags & NDR_IN) {
13871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13872                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13873                 }
13874                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13875                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13878                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13879                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13880                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13881         }
13882         if (flags & NDR_OUT) {
13883                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13884         }
13885         return NDR_ERR_SUCCESS;
13886 }
13887
13888 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13889 {
13890         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13891         ndr->depth++;
13892         if (flags & NDR_SET_VALUES) {
13893                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13894         }
13895         if (flags & NDR_IN) {
13896                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13897                 ndr->depth++;
13898                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13899                 ndr->depth++;
13900                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13901                 ndr->depth--;
13902                 ndr_print_int32(ndr, "level", r->in.level);
13903                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13904                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13905                 ndr->depth--;
13906         }
13907         if (flags & NDR_OUT) {
13908                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13909                 ndr->depth++;
13910                 ndr_print_WERROR(ndr, "result", r->out.result);
13911                 ndr->depth--;
13912         }
13913         ndr->depth--;
13914 }
13915
13916 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13917 {
13918         if (flags & NDR_IN) {
13919                 if (r->in.bind_handle == NULL) {
13920                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13921                 }
13922                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13923                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13924                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13925                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13926         }
13927         if (flags & NDR_OUT) {
13928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13929         }
13930         return NDR_ERR_SUCCESS;
13931 }
13932
13933 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13934 {
13935         TALLOC_CTX *_mem_save_bind_handle_0;
13936         if (flags & NDR_IN) {
13937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13938                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13939                 }
13940                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13941                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13942                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13944                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13945                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13946                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13947         }
13948         if (flags & NDR_OUT) {
13949                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13950         }
13951         return NDR_ERR_SUCCESS;
13952 }
13953
13954 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13955 {
13956         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13957         ndr->depth++;
13958         if (flags & NDR_SET_VALUES) {
13959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13960         }
13961         if (flags & NDR_IN) {
13962                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13963                 ndr->depth++;
13964                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13965                 ndr->depth++;
13966                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13967                 ndr->depth--;
13968                 ndr_print_int32(ndr, "level", r->in.level);
13969                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13970                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13971                 ndr->depth--;
13972         }
13973         if (flags & NDR_OUT) {
13974                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13975                 ndr->depth++;
13976                 ndr_print_WERROR(ndr, "result", r->out.result);
13977                 ndr->depth--;
13978         }
13979         ndr->depth--;
13980 }
13981
13982 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13983 {
13984         if (flags & NDR_IN) {
13985                 if (r->in.bind_handle == NULL) {
13986                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13987                 }
13988                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13989                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13990                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13991                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13992         }
13993         if (flags & NDR_OUT) {
13994                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13995         }
13996         return NDR_ERR_SUCCESS;
13997 }
13998
13999 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
14000 {
14001         TALLOC_CTX *_mem_save_bind_handle_0;
14002         if (flags & NDR_IN) {
14003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14004                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14005                 }
14006                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14007                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14008                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14010                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14011                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14012                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14013         }
14014         if (flags & NDR_OUT) {
14015                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14016         }
14017         return NDR_ERR_SUCCESS;
14018 }
14019
14020 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
14021 {
14022         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
14023         ndr->depth++;
14024         if (flags & NDR_SET_VALUES) {
14025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14026         }
14027         if (flags & NDR_IN) {
14028                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
14029                 ndr->depth++;
14030                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14031                 ndr->depth++;
14032                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14033                 ndr->depth--;
14034                 ndr_print_int32(ndr, "level", r->in.level);
14035                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14036                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
14037                 ndr->depth--;
14038         }
14039         if (flags & NDR_OUT) {
14040                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
14041                 ndr->depth++;
14042                 ndr_print_WERROR(ndr, "result", r->out.result);
14043                 ndr->depth--;
14044         }
14045         ndr->depth--;
14046 }
14047
14048 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
14049 {
14050         if (flags & NDR_IN) {
14051                 if (r->in.bind_handle == NULL) {
14052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14053                 }
14054                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14055                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14056                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
14057                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14058         }
14059         if (flags & NDR_OUT) {
14060                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14061         }
14062         return NDR_ERR_SUCCESS;
14063 }
14064
14065 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
14066 {
14067         TALLOC_CTX *_mem_save_bind_handle_0;
14068         if (flags & NDR_IN) {
14069                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14070                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14071                 }
14072                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14073                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14074                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14075                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14076                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14077                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14078                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14079         }
14080         if (flags & NDR_OUT) {
14081                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14082         }
14083         return NDR_ERR_SUCCESS;
14084 }
14085
14086 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
14087 {
14088         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
14089         ndr->depth++;
14090         if (flags & NDR_SET_VALUES) {
14091                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14092         }
14093         if (flags & NDR_IN) {
14094                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
14095                 ndr->depth++;
14096                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14097                 ndr->depth++;
14098                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14099                 ndr->depth--;
14100                 ndr_print_int32(ndr, "level", r->in.level);
14101                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14102                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
14103                 ndr->depth--;
14104         }
14105         if (flags & NDR_OUT) {
14106                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
14107                 ndr->depth++;
14108                 ndr_print_WERROR(ndr, "result", r->out.result);
14109                 ndr->depth--;
14110         }
14111         ndr->depth--;
14112 }
14113
14114 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
14115 {
14116         if (flags & NDR_IN) {
14117         }
14118         if (flags & NDR_OUT) {
14119                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14120         }
14121         return NDR_ERR_SUCCESS;
14122 }
14123
14124 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
14125 {
14126         if (flags & NDR_IN) {
14127         }
14128         if (flags & NDR_OUT) {
14129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14130         }
14131         return NDR_ERR_SUCCESS;
14132 }
14133
14134 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
14135 {
14136         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
14137         ndr->depth++;
14138         if (flags & NDR_SET_VALUES) {
14139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14140         }
14141         if (flags & NDR_IN) {
14142                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
14143                 ndr->depth++;
14144                 ndr->depth--;
14145         }
14146         if (flags & NDR_OUT) {
14147                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
14148                 ndr->depth++;
14149                 ndr_print_WERROR(ndr, "result", r->out.result);
14150                 ndr->depth--;
14151         }
14152         ndr->depth--;
14153 }
14154
14155 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
14156 {
14157         if (flags & NDR_IN) {
14158                 if (r->in.bind_handle == NULL) {
14159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14160                 }
14161                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14162                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14163                 if (r->in.req == NULL) {
14164                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14165                 }
14166                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14167                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14168         }
14169         if (flags & NDR_OUT) {
14170                 if (r->out.level_out == NULL) {
14171                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14172                 }
14173                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14174                 if (r->out.ctr == NULL) {
14175                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14176                 }
14177                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14178                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14179                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14180         }
14181         return NDR_ERR_SUCCESS;
14182 }
14183
14184 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
14185 {
14186         TALLOC_CTX *_mem_save_bind_handle_0;
14187         TALLOC_CTX *_mem_save_req_0;
14188         TALLOC_CTX *_mem_save_level_out_0;
14189         TALLOC_CTX *_mem_save_ctr_0;
14190         if (flags & NDR_IN) {
14191                 ZERO_STRUCT(r->out);
14192
14193                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14194                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14195                 }
14196                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14197                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14198                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14199                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14200                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14201                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14202                         NDR_PULL_ALLOC(ndr, r->in.req);
14203                 }
14204                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14205                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14206                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14207                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14209                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14210                 ZERO_STRUCTP(r->out.level_out);
14211                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14212                 ZERO_STRUCTP(r->out.ctr);
14213         }
14214         if (flags & NDR_OUT) {
14215                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14216                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14217                 }
14218                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14219                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14220                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14222                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14223                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14224                 }
14225                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14226                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14227                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14228                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14229                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14230                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14231         }
14232         return NDR_ERR_SUCCESS;
14233 }
14234
14235 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14236 {
14237         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14238         ndr->depth++;
14239         if (flags & NDR_SET_VALUES) {
14240                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14241         }
14242         if (flags & NDR_IN) {
14243                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14244                 ndr->depth++;
14245                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14246                 ndr->depth++;
14247                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14248                 ndr->depth--;
14249                 ndr_print_int32(ndr, "level", r->in.level);
14250                 ndr_print_ptr(ndr, "req", r->in.req);
14251                 ndr->depth++;
14252                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14253                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14254                 ndr->depth--;
14255                 ndr->depth--;
14256         }
14257         if (flags & NDR_OUT) {
14258                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14259                 ndr->depth++;
14260                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14261                 ndr->depth++;
14262                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14263                 ndr->depth--;
14264                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14265                 ndr->depth++;
14266                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14267                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14268                 ndr->depth--;
14269                 ndr_print_WERROR(ndr, "result", r->out.result);
14270                 ndr->depth--;
14271         }
14272         ndr->depth--;
14273 }
14274
14275 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14276 {
14277         if (flags & NDR_IN) {
14278         }
14279         if (flags & NDR_OUT) {
14280                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14281         }
14282         return NDR_ERR_SUCCESS;
14283 }
14284
14285 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14286 {
14287         if (flags & NDR_IN) {
14288         }
14289         if (flags & NDR_OUT) {
14290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14291         }
14292         return NDR_ERR_SUCCESS;
14293 }
14294
14295 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14296 {
14297         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14298         ndr->depth++;
14299         if (flags & NDR_SET_VALUES) {
14300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14301         }
14302         if (flags & NDR_IN) {
14303                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14304                 ndr->depth++;
14305                 ndr->depth--;
14306         }
14307         if (flags & NDR_OUT) {
14308                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14309                 ndr->depth++;
14310                 ndr_print_WERROR(ndr, "result", r->out.result);
14311                 ndr->depth--;
14312         }
14313         ndr->depth--;
14314 }
14315
14316 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14317 {
14318         if (flags & NDR_IN) {
14319                 if (r->in.bind_handle == NULL) {
14320                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14321                 }
14322                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14324                 if (r->in.req == NULL) {
14325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14326                 }
14327                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14328                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14329         }
14330         if (flags & NDR_OUT) {
14331                 if (r->out.level_out == NULL) {
14332                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14333                 }
14334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14335                 if (r->out.info == NULL) {
14336                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14337                 }
14338                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14339                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14340                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14341         }
14342         return NDR_ERR_SUCCESS;
14343 }
14344
14345 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14346 {
14347         TALLOC_CTX *_mem_save_bind_handle_0;
14348         TALLOC_CTX *_mem_save_req_0;
14349         TALLOC_CTX *_mem_save_level_out_0;
14350         TALLOC_CTX *_mem_save_info_0;
14351         if (flags & NDR_IN) {
14352                 ZERO_STRUCT(r->out);
14353
14354                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14355                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14356                 }
14357                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14358                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14359                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14360                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14362                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14363                         NDR_PULL_ALLOC(ndr, r->in.req);
14364                 }
14365                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14366                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14367                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14368                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14370                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14371                 ZERO_STRUCTP(r->out.level_out);
14372                 NDR_PULL_ALLOC(ndr, r->out.info);
14373                 ZERO_STRUCTP(r->out.info);
14374         }
14375         if (flags & NDR_OUT) {
14376                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14377                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14378                 }
14379                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14380                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14383                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14384                         NDR_PULL_ALLOC(ndr, r->out.info);
14385                 }
14386                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14387                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14388                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14389                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14390                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14391                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14392         }
14393         return NDR_ERR_SUCCESS;
14394 }
14395
14396 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14397 {
14398         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14399         ndr->depth++;
14400         if (flags & NDR_SET_VALUES) {
14401                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14402         }
14403         if (flags & NDR_IN) {
14404                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14405                 ndr->depth++;
14406                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14407                 ndr->depth++;
14408                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14409                 ndr->depth--;
14410                 ndr_print_uint32(ndr, "level", r->in.level);
14411                 ndr_print_ptr(ndr, "req", r->in.req);
14412                 ndr->depth++;
14413                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14414                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14415                 ndr->depth--;
14416                 ndr->depth--;
14417         }
14418         if (flags & NDR_OUT) {
14419                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14420                 ndr->depth++;
14421                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14422                 ndr->depth++;
14423                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14424                 ndr->depth--;
14425                 ndr_print_ptr(ndr, "info", r->out.info);
14426                 ndr->depth++;
14427                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14428                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14429                 ndr->depth--;
14430                 ndr_print_WERROR(ndr, "result", r->out.result);
14431                 ndr->depth--;
14432         }
14433         ndr->depth--;
14434 }
14435
14436 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14437 {
14438         if (flags & NDR_IN) {
14439                 if (r->in.bind_handle == NULL) {
14440                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14441                 }
14442                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14443                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14444                 if (r->in.req == NULL) {
14445                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14446                 }
14447                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14448                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14449         }
14450         if (flags & NDR_OUT) {
14451                 if (r->out.level_out == NULL) {
14452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14453                 }
14454                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14455                 if (r->out.ctr == NULL) {
14456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14457                 }
14458                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14459                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14460                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14461         }
14462         return NDR_ERR_SUCCESS;
14463 }
14464
14465 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14466 {
14467         TALLOC_CTX *_mem_save_bind_handle_0;
14468         TALLOC_CTX *_mem_save_req_0;
14469         TALLOC_CTX *_mem_save_level_out_0;
14470         TALLOC_CTX *_mem_save_ctr_0;
14471         if (flags & NDR_IN) {
14472                 ZERO_STRUCT(r->out);
14473
14474                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14475                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14476                 }
14477                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14478                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14479                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14480                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14481                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14482                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14483                         NDR_PULL_ALLOC(ndr, r->in.req);
14484                 }
14485                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14486                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14487                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14488                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14490                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14491                 ZERO_STRUCTP(r->out.level_out);
14492                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14493                 ZERO_STRUCTP(r->out.ctr);
14494         }
14495         if (flags & NDR_OUT) {
14496                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14497                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14498                 }
14499                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14500                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14501                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14502                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14503                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14504                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14505                 }
14506                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14507                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14508                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14509                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14510                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14511                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14512         }
14513         return NDR_ERR_SUCCESS;
14514 }
14515
14516 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14517 {
14518         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14519         ndr->depth++;
14520         if (flags & NDR_SET_VALUES) {
14521                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14522         }
14523         if (flags & NDR_IN) {
14524                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14525                 ndr->depth++;
14526                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14527                 ndr->depth++;
14528                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14529                 ndr->depth--;
14530                 ndr_print_int32(ndr, "level", r->in.level);
14531                 ndr_print_ptr(ndr, "req", r->in.req);
14532                 ndr->depth++;
14533                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14534                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14535                 ndr->depth--;
14536                 ndr->depth--;
14537         }
14538         if (flags & NDR_OUT) {
14539                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14540                 ndr->depth++;
14541                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14542                 ndr->depth++;
14543                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14544                 ndr->depth--;
14545                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14546                 ndr->depth++;
14547                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14548                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14549                 ndr->depth--;
14550                 ndr_print_WERROR(ndr, "result", r->out.result);
14551                 ndr->depth--;
14552         }
14553         ndr->depth--;
14554 }
14555
14556 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14557 {
14558         if (flags & NDR_IN) {
14559                 if (r->in.bind_handle == NULL) {
14560                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14561                 }
14562                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14563                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14564                 if (r->in.req == NULL) {
14565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14566                 }
14567                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14568                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14569         }
14570         if (flags & NDR_OUT) {
14571                 if (r->out.level_out == NULL) {
14572                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14573                 }
14574                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14575                 if (r->out.res == NULL) {
14576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14577                 }
14578                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14579                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14580                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14581         }
14582         return NDR_ERR_SUCCESS;
14583 }
14584
14585 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14586 {
14587         TALLOC_CTX *_mem_save_bind_handle_0;
14588         TALLOC_CTX *_mem_save_req_0;
14589         TALLOC_CTX *_mem_save_level_out_0;
14590         TALLOC_CTX *_mem_save_res_0;
14591         if (flags & NDR_IN) {
14592                 ZERO_STRUCT(r->out);
14593
14594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14595                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14596                 }
14597                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14598                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14599                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14601                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14602                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14603                         NDR_PULL_ALLOC(ndr, r->in.req);
14604                 }
14605                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14606                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14607                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14608                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14610                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14611                 ZERO_STRUCTP(r->out.level_out);
14612                 NDR_PULL_ALLOC(ndr, r->out.res);
14613                 ZERO_STRUCTP(r->out.res);
14614         }
14615         if (flags & NDR_OUT) {
14616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14617                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14618                 }
14619                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14620                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14621                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14623                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14624                         NDR_PULL_ALLOC(ndr, r->out.res);
14625                 }
14626                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14627                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14628                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14629                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14630                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14631                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14632         }
14633         return NDR_ERR_SUCCESS;
14634 }
14635
14636 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14637 {
14638         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14639         ndr->depth++;
14640         if (flags & NDR_SET_VALUES) {
14641                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14642         }
14643         if (flags & NDR_IN) {
14644                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14645                 ndr->depth++;
14646                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14647                 ndr->depth++;
14648                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14649                 ndr->depth--;
14650                 ndr_print_int32(ndr, "level", r->in.level);
14651                 ndr_print_ptr(ndr, "req", r->in.req);
14652                 ndr->depth++;
14653                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14654                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14655                 ndr->depth--;
14656                 ndr->depth--;
14657         }
14658         if (flags & NDR_OUT) {
14659                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14660                 ndr->depth++;
14661                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14662                 ndr->depth++;
14663                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14664                 ndr->depth--;
14665                 ndr_print_ptr(ndr, "res", r->out.res);
14666                 ndr->depth++;
14667                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14668                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14669                 ndr->depth--;
14670                 ndr_print_WERROR(ndr, "result", r->out.result);
14671                 ndr->depth--;
14672         }
14673         ndr->depth--;
14674 }
14675
14676 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14677 {
14678         if (flags & NDR_IN) {
14679                 if (r->in.bind_handle == NULL) {
14680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14681                 }
14682                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14683                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14684                 if (r->in.req == NULL) {
14685                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14686                 }
14687                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14688                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14689         }
14690         if (flags & NDR_OUT) {
14691                 if (r->out.level_out == NULL) {
14692                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14693                 }
14694                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14695                 if (r->out.res == NULL) {
14696                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14697                 }
14698                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14699                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14700                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14701         }
14702         return NDR_ERR_SUCCESS;
14703 }
14704
14705 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14706 {
14707         TALLOC_CTX *_mem_save_bind_handle_0;
14708         TALLOC_CTX *_mem_save_req_0;
14709         TALLOC_CTX *_mem_save_level_out_0;
14710         TALLOC_CTX *_mem_save_res_0;
14711         if (flags & NDR_IN) {
14712                 ZERO_STRUCT(r->out);
14713
14714                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14715                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14716                 }
14717                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14718                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14719                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14720                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14721                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14722                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14723                         NDR_PULL_ALLOC(ndr, r->in.req);
14724                 }
14725                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14726                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14727                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14728                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14729                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14730                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14731                 ZERO_STRUCTP(r->out.level_out);
14732                 NDR_PULL_ALLOC(ndr, r->out.res);
14733                 ZERO_STRUCTP(r->out.res);
14734         }
14735         if (flags & NDR_OUT) {
14736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14737                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14738                 }
14739                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14740                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14741                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14743                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14744                         NDR_PULL_ALLOC(ndr, r->out.res);
14745                 }
14746                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14747                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14748                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14749                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14750                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14751                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14752         }
14753         return NDR_ERR_SUCCESS;
14754 }
14755
14756 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14757 {
14758         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14759         ndr->depth++;
14760         if (flags & NDR_SET_VALUES) {
14761                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14762         }
14763         if (flags & NDR_IN) {
14764                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14765                 ndr->depth++;
14766                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14767                 ndr->depth++;
14768                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14769                 ndr->depth--;
14770                 ndr_print_int32(ndr, "level", r->in.level);
14771                 ndr_print_ptr(ndr, "req", r->in.req);
14772                 ndr->depth++;
14773                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14774                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14775                 ndr->depth--;
14776                 ndr->depth--;
14777         }
14778         if (flags & NDR_OUT) {
14779                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14780                 ndr->depth++;
14781                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14782                 ndr->depth++;
14783                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14784                 ndr->depth--;
14785                 ndr_print_ptr(ndr, "res", r->out.res);
14786                 ndr->depth++;
14787                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14788                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14789                 ndr->depth--;
14790                 ndr_print_WERROR(ndr, "result", r->out.result);
14791                 ndr->depth--;
14792         }
14793         ndr->depth--;
14794 }
14795
14796 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14797 {
14798         if (flags & NDR_IN) {
14799         }
14800         if (flags & NDR_OUT) {
14801                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14802         }
14803         return NDR_ERR_SUCCESS;
14804 }
14805
14806 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14807 {
14808         if (flags & NDR_IN) {
14809         }
14810         if (flags & NDR_OUT) {
14811                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14812         }
14813         return NDR_ERR_SUCCESS;
14814 }
14815
14816 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14817 {
14818         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14819         ndr->depth++;
14820         if (flags & NDR_SET_VALUES) {
14821                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14822         }
14823         if (flags & NDR_IN) {
14824                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14825                 ndr->depth++;
14826                 ndr->depth--;
14827         }
14828         if (flags & NDR_OUT) {
14829                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14830                 ndr->depth++;
14831                 ndr_print_WERROR(ndr, "result", r->out.result);
14832                 ndr->depth--;
14833         }
14834         ndr->depth--;
14835 }
14836
14837 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14838 {
14839         if (flags & NDR_IN) {
14840                 if (r->in.bind_handle == NULL) {
14841                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14842                 }
14843                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14844                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14845                 if (r->in.req == NULL) {
14846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14847                 }
14848                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14849                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14850         }
14851         if (flags & NDR_OUT) {
14852                 if (r->out.level_out == NULL) {
14853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14854                 }
14855                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14856                 if (r->out.ctr == NULL) {
14857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14858                 }
14859                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14860                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14861                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14862         }
14863         return NDR_ERR_SUCCESS;
14864 }
14865
14866 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14867 {
14868         TALLOC_CTX *_mem_save_bind_handle_0;
14869         TALLOC_CTX *_mem_save_req_0;
14870         TALLOC_CTX *_mem_save_level_out_0;
14871         TALLOC_CTX *_mem_save_ctr_0;
14872         if (flags & NDR_IN) {
14873                 ZERO_STRUCT(r->out);
14874
14875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14876                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14877                 }
14878                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14879                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14880                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14882                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14883                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14884                         NDR_PULL_ALLOC(ndr, r->in.req);
14885                 }
14886                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14887                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14888                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14889                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14891                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14892                 ZERO_STRUCTP(r->out.level_out);
14893                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14894                 ZERO_STRUCTP(r->out.ctr);
14895         }
14896         if (flags & NDR_OUT) {
14897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14898                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14899                 }
14900                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14901                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14902                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14904                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14905                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14906                 }
14907                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14908                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14909                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14910                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14911                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14912                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14913         }
14914         return NDR_ERR_SUCCESS;
14915 }
14916
14917 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14918 {
14919         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14920         ndr->depth++;
14921         if (flags & NDR_SET_VALUES) {
14922                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14923         }
14924         if (flags & NDR_IN) {
14925                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14926                 ndr->depth++;
14927                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14928                 ndr->depth++;
14929                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14930                 ndr->depth--;
14931                 ndr_print_int32(ndr, "level", r->in.level);
14932                 ndr_print_ptr(ndr, "req", r->in.req);
14933                 ndr->depth++;
14934                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14935                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14936                 ndr->depth--;
14937                 ndr->depth--;
14938         }
14939         if (flags & NDR_OUT) {
14940                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14941                 ndr->depth++;
14942                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14943                 ndr->depth++;
14944                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14945                 ndr->depth--;
14946                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14947                 ndr->depth++;
14948                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14949                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14950                 ndr->depth--;
14951                 ndr_print_WERROR(ndr, "result", r->out.result);
14952                 ndr->depth--;
14953         }
14954         ndr->depth--;
14955 }
14956
14957 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14958 {
14959         if (flags & NDR_IN) {
14960                 if (r->in.bind_handle == NULL) {
14961                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14962                 }
14963                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14964                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14965                 if (r->in.req == NULL) {
14966                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14967                 }
14968                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14969                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14970         }
14971         if (flags & NDR_OUT) {
14972                 if (r->out.level_out == NULL) {
14973                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14974                 }
14975                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14976                 if (r->out.ctr == NULL) {
14977                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14978                 }
14979                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14980                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14981                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14982         }
14983         return NDR_ERR_SUCCESS;
14984 }
14985
14986 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14987 {
14988         TALLOC_CTX *_mem_save_bind_handle_0;
14989         TALLOC_CTX *_mem_save_req_0;
14990         TALLOC_CTX *_mem_save_level_out_0;
14991         TALLOC_CTX *_mem_save_ctr_0;
14992         if (flags & NDR_IN) {
14993                 ZERO_STRUCT(r->out);
14994
14995                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14996                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14997                 }
14998                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14999                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15000                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15001                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15002                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15004                         NDR_PULL_ALLOC(ndr, r->in.req);
15005                 }
15006                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15007                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15008                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15009                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15011                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15012                 ZERO_STRUCTP(r->out.level_out);
15013                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15014                 ZERO_STRUCTP(r->out.ctr);
15015         }
15016         if (flags & NDR_OUT) {
15017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15018                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15019                 }
15020                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15021                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15022                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15024                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15025                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15026                 }
15027                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15028                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15029                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15030                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15033         }
15034         return NDR_ERR_SUCCESS;
15035 }
15036
15037 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
15038 {
15039         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
15040         ndr->depth++;
15041         if (flags & NDR_SET_VALUES) {
15042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15043         }
15044         if (flags & NDR_IN) {
15045                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
15046                 ndr->depth++;
15047                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15048                 ndr->depth++;
15049                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15050                 ndr->depth--;
15051                 ndr_print_int32(ndr, "level", r->in.level);
15052                 ndr_print_ptr(ndr, "req", r->in.req);
15053                 ndr->depth++;
15054                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15055                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
15056                 ndr->depth--;
15057                 ndr->depth--;
15058         }
15059         if (flags & NDR_OUT) {
15060                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
15061                 ndr->depth++;
15062                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15063                 ndr->depth++;
15064                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15065                 ndr->depth--;
15066                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15067                 ndr->depth++;
15068                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15069                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
15070                 ndr->depth--;
15071                 ndr_print_WERROR(ndr, "result", r->out.result);
15072                 ndr->depth--;
15073         }
15074         ndr->depth--;
15075 }
15076
15077 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
15078 {
15079         if (flags & NDR_IN) {
15080                 if (r->in.bind_handle == NULL) {
15081                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15082                 }
15083                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15085                 if (r->in.req == NULL) {
15086                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15087                 }
15088                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15089                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
15090         }
15091         if (flags & NDR_OUT) {
15092                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15093         }
15094         return NDR_ERR_SUCCESS;
15095 }
15096
15097 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
15098 {
15099         TALLOC_CTX *_mem_save_bind_handle_0;
15100         TALLOC_CTX *_mem_save_req_0;
15101         if (flags & NDR_IN) {
15102                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15103                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15104                 }
15105                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15106                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15107                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15108                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15110                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15111                         NDR_PULL_ALLOC(ndr, r->in.req);
15112                 }
15113                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15114                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15115                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15116                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
15117                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15118         }
15119         if (flags & NDR_OUT) {
15120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15121         }
15122         return NDR_ERR_SUCCESS;
15123 }
15124
15125 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
15126 {
15127         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
15128         ndr->depth++;
15129         if (flags & NDR_SET_VALUES) {
15130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15131         }
15132         if (flags & NDR_IN) {
15133                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
15134                 ndr->depth++;
15135                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15136                 ndr->depth++;
15137                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15138                 ndr->depth--;
15139                 ndr_print_uint32(ndr, "level", r->in.level);
15140                 ndr_print_ptr(ndr, "req", r->in.req);
15141                 ndr->depth++;
15142                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15143                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
15144                 ndr->depth--;
15145                 ndr->depth--;
15146         }
15147         if (flags & NDR_OUT) {
15148                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
15149                 ndr->depth++;
15150                 ndr_print_WERROR(ndr, "result", r->out.result);
15151                 ndr->depth--;
15152         }
15153         ndr->depth--;
15154 }
15155
15156 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15157 {
15158         if (flags & NDR_IN) {
15159                 if (r->in.bind_handle == NULL) {
15160                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15161                 }
15162                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15163                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
15164                 if (r->in.req == NULL) {
15165                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15166                 }
15167                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15168                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15169         }
15170         if (flags & NDR_OUT) {
15171                 if (r->out.info_type == NULL) {
15172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15173                 }
15174                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
15175                 if (r->out.info == NULL) {
15176                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15177                 }
15178                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
15179                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15180                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15181         }
15182         return NDR_ERR_SUCCESS;
15183 }
15184
15185 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
15186 {
15187         TALLOC_CTX *_mem_save_bind_handle_0;
15188         TALLOC_CTX *_mem_save_req_0;
15189         TALLOC_CTX *_mem_save_info_type_0;
15190         TALLOC_CTX *_mem_save_info_0;
15191         if (flags & NDR_IN) {
15192                 ZERO_STRUCT(r->out);
15193
15194                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15195                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15196                 }
15197                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15198                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15199                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15200                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15201                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
15202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15203                         NDR_PULL_ALLOC(ndr, r->in.req);
15204                 }
15205                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15207                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15208                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15210                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15211                 ZERO_STRUCTP(r->out.info_type);
15212                 NDR_PULL_ALLOC(ndr, r->out.info);
15213                 ZERO_STRUCTP(r->out.info);
15214         }
15215         if (flags & NDR_OUT) {
15216                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15217                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15218                 }
15219                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15220                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15221                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15222                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15223                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15224                         NDR_PULL_ALLOC(ndr, r->out.info);
15225                 }
15226                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15227                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15228                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15229                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15230                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15231                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15232         }
15233         return NDR_ERR_SUCCESS;
15234 }
15235
15236 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15237 {
15238         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15239         ndr->depth++;
15240         if (flags & NDR_SET_VALUES) {
15241                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15242         }
15243         if (flags & NDR_IN) {
15244                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15245                 ndr->depth++;
15246                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15247                 ndr->depth++;
15248                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15249                 ndr->depth--;
15250                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15251                 ndr_print_ptr(ndr, "req", r->in.req);
15252                 ndr->depth++;
15253                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15254                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15255                 ndr->depth--;
15256                 ndr->depth--;
15257         }
15258         if (flags & NDR_OUT) {
15259                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15260                 ndr->depth++;
15261                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15262                 ndr->depth++;
15263                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15264                 ndr->depth--;
15265                 ndr_print_ptr(ndr, "info", r->out.info);
15266                 ndr->depth++;
15267                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15268                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15269                 ndr->depth--;
15270                 ndr_print_WERROR(ndr, "result", r->out.result);
15271                 ndr->depth--;
15272         }
15273         ndr->depth--;
15274 }
15275
15276 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15277 {
15278         if (flags & NDR_IN) {
15279         }
15280         if (flags & NDR_OUT) {
15281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15282         }
15283         return NDR_ERR_SUCCESS;
15284 }
15285
15286 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15287 {
15288         if (flags & NDR_IN) {
15289         }
15290         if (flags & NDR_OUT) {
15291                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15292         }
15293         return NDR_ERR_SUCCESS;
15294 }
15295
15296 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15297 {
15298         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15299         ndr->depth++;
15300         if (flags & NDR_SET_VALUES) {
15301                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15302         }
15303         if (flags & NDR_IN) {
15304                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15305                 ndr->depth++;
15306                 ndr->depth--;
15307         }
15308         if (flags & NDR_OUT) {
15309                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15310                 ndr->depth++;
15311                 ndr_print_WERROR(ndr, "result", r->out.result);
15312                 ndr->depth--;
15313         }
15314         ndr->depth--;
15315 }
15316
15317 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15318 {
15319         if (flags & NDR_IN) {
15320                 if (r->in.bind_handle == NULL) {
15321                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15322                 }
15323                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15324                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15325                 if (r->in.req == NULL) {
15326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15327                 }
15328                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15329                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15330         }
15331         if (flags & NDR_OUT) {
15332                 if (r->out.level_out == NULL) {
15333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15334                 }
15335                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15336                 if (r->out.ctr == NULL) {
15337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15338                 }
15339                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15340                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15342         }
15343         return NDR_ERR_SUCCESS;
15344 }
15345
15346 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15347 {
15348         TALLOC_CTX *_mem_save_bind_handle_0;
15349         TALLOC_CTX *_mem_save_req_0;
15350         TALLOC_CTX *_mem_save_level_out_0;
15351         TALLOC_CTX *_mem_save_ctr_0;
15352         if (flags & NDR_IN) {
15353                 ZERO_STRUCT(r->out);
15354
15355                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15356                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15357                 }
15358                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15359                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15360                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15361                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15362                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15364                         NDR_PULL_ALLOC(ndr, r->in.req);
15365                 }
15366                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15368                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15369                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15371                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15372                 ZERO_STRUCTP(r->out.level_out);
15373                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15374                 ZERO_STRUCTP(r->out.ctr);
15375         }
15376         if (flags & NDR_OUT) {
15377                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15378                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15379                 }
15380                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15381                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15382                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15383                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15384                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15385                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15386                 }
15387                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15388                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15389                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15390                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15392                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15393         }
15394         return NDR_ERR_SUCCESS;
15395 }
15396
15397 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15398 {
15399         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15400         ndr->depth++;
15401         if (flags & NDR_SET_VALUES) {
15402                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15403         }
15404         if (flags & NDR_IN) {
15405                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15406                 ndr->depth++;
15407                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15408                 ndr->depth++;
15409                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15410                 ndr->depth--;
15411                 ndr_print_int32(ndr, "level", r->in.level);
15412                 ndr_print_ptr(ndr, "req", r->in.req);
15413                 ndr->depth++;
15414                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15415                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15416                 ndr->depth--;
15417                 ndr->depth--;
15418         }
15419         if (flags & NDR_OUT) {
15420                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15421                 ndr->depth++;
15422                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15423                 ndr->depth++;
15424                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15425                 ndr->depth--;
15426                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15427                 ndr->depth++;
15428                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15429                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15430                 ndr->depth--;
15431                 ndr_print_WERROR(ndr, "result", r->out.result);
15432                 ndr->depth--;
15433         }
15434         ndr->depth--;
15435 }
15436
15437 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15438 {
15439         if (flags & NDR_IN) {
15440         }
15441         if (flags & NDR_OUT) {
15442                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15443         }
15444         return NDR_ERR_SUCCESS;
15445 }
15446
15447 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15448 {
15449         if (flags & NDR_IN) {
15450         }
15451         if (flags & NDR_OUT) {
15452                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15453         }
15454         return NDR_ERR_SUCCESS;
15455 }
15456
15457 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15458 {
15459         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15460         ndr->depth++;
15461         if (flags & NDR_SET_VALUES) {
15462                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15463         }
15464         if (flags & NDR_IN) {
15465                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15466                 ndr->depth++;
15467                 ndr->depth--;
15468         }
15469         if (flags & NDR_OUT) {
15470                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15471                 ndr->depth++;
15472                 ndr_print_WERROR(ndr, "result", r->out.result);
15473                 ndr->depth--;
15474         }
15475         ndr->depth--;
15476 }
15477
15478 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15479 {
15480         if (flags & NDR_IN) {
15481         }
15482         if (flags & NDR_OUT) {
15483                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15484         }
15485         return NDR_ERR_SUCCESS;
15486 }
15487
15488 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15489 {
15490         if (flags & NDR_IN) {
15491         }
15492         if (flags & NDR_OUT) {
15493                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15494         }
15495         return NDR_ERR_SUCCESS;
15496 }
15497
15498 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15499 {
15500         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15501         ndr->depth++;
15502         if (flags & NDR_SET_VALUES) {
15503                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15504         }
15505         if (flags & NDR_IN) {
15506                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15507                 ndr->depth++;
15508                 ndr->depth--;
15509         }
15510         if (flags & NDR_OUT) {
15511                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15512                 ndr->depth++;
15513                 ndr_print_WERROR(ndr, "result", r->out.result);
15514                 ndr->depth--;
15515         }
15516         ndr->depth--;
15517 }
15518
15519 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15520 {
15521         if (flags & NDR_IN) {
15522                 if (r->in.bind_handle == NULL) {
15523                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15524                 }
15525                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15526                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15527                 if (r->in.req == NULL) {
15528                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15529                 }
15530                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15531                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15532         }
15533         if (flags & NDR_OUT) {
15534                 if (r->out.level_out == NULL) {
15535                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15536                 }
15537                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15538                 if (r->out.ctr == NULL) {
15539                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15540                 }
15541                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15542                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15543                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15544         }
15545         return NDR_ERR_SUCCESS;
15546 }
15547
15548 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15549 {
15550         TALLOC_CTX *_mem_save_bind_handle_0;
15551         TALLOC_CTX *_mem_save_req_0;
15552         TALLOC_CTX *_mem_save_level_out_0;
15553         TALLOC_CTX *_mem_save_ctr_0;
15554         if (flags & NDR_IN) {
15555                 ZERO_STRUCT(r->out);
15556
15557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15558                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15559                 }
15560                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15561                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15562                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15564                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15565                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15566                         NDR_PULL_ALLOC(ndr, r->in.req);
15567                 }
15568                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15569                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15570                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15571                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15572                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15573                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15574                 ZERO_STRUCTP(r->out.level_out);
15575                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15576                 ZERO_STRUCTP(r->out.ctr);
15577         }
15578         if (flags & NDR_OUT) {
15579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15580                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15581                 }
15582                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15583                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15584                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15586                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15587                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15588                 }
15589                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15590                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15591                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15592                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15593                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15594                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15595         }
15596         return NDR_ERR_SUCCESS;
15597 }
15598
15599 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15600 {
15601         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15602         ndr->depth++;
15603         if (flags & NDR_SET_VALUES) {
15604                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15605         }
15606         if (flags & NDR_IN) {
15607                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15608                 ndr->depth++;
15609                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15610                 ndr->depth++;
15611                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15612                 ndr->depth--;
15613                 ndr_print_int32(ndr, "level", r->in.level);
15614                 ndr_print_ptr(ndr, "req", r->in.req);
15615                 ndr->depth++;
15616                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15617                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15618                 ndr->depth--;
15619                 ndr->depth--;
15620         }
15621         if (flags & NDR_OUT) {
15622                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15623                 ndr->depth++;
15624                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15625                 ndr->depth++;
15626                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15627                 ndr->depth--;
15628                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15629                 ndr->depth++;
15630                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15631                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15632                 ndr->depth--;
15633                 ndr_print_WERROR(ndr, "result", r->out.result);
15634                 ndr->depth--;
15635         }
15636         ndr->depth--;
15637 }
15638
15639 static const struct ndr_interface_call drsuapi_calls[] = {
15640         {
15641                 "drsuapi_DsBind",
15642                 sizeof(struct drsuapi_DsBind),
15643                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15644                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15645                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15646                 false,
15647         },
15648         {
15649                 "drsuapi_DsUnbind",
15650                 sizeof(struct drsuapi_DsUnbind),
15651                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15652                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15653                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15654                 false,
15655         },
15656         {
15657                 "drsuapi_DsReplicaSync",
15658                 sizeof(struct drsuapi_DsReplicaSync),
15659                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15660                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15661                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15662                 false,
15663         },
15664         {
15665                 "drsuapi_DsGetNCChanges",
15666                 sizeof(struct drsuapi_DsGetNCChanges),
15667                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15668                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15669                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15670                 false,
15671         },
15672         {
15673                 "drsuapi_DsReplicaUpdateRefs",
15674                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15675                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15676                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15677                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15678                 false,
15679         },
15680         {
15681                 "drsuapi_DsReplicaAdd",
15682                 sizeof(struct drsuapi_DsReplicaAdd),
15683                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15684                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15685                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15686                 false,
15687         },
15688         {
15689                 "drsuapi_DsReplicaDel",
15690                 sizeof(struct drsuapi_DsReplicaDel),
15691                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15692                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15693                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15694                 false,
15695         },
15696         {
15697                 "drsuapi_DsReplicaMod",
15698                 sizeof(struct drsuapi_DsReplicaMod),
15699                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15700                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15701                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15702                 false,
15703         },
15704         {
15705                 "DRSUAPI_VERIFY_NAMES",
15706                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15707                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15708                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15709                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15710                 false,
15711         },
15712         {
15713                 "drsuapi_DsGetMemberships",
15714                 sizeof(struct drsuapi_DsGetMemberships),
15715                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15716                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15717                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15718                 false,
15719         },
15720         {
15721                 "DRSUAPI_INTER_DOMAIN_MOVE",
15722                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15723                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15724                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15725                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15726                 false,
15727         },
15728         {
15729                 "drsuapi_DsGetNT4ChangeLog",
15730                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15731                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15732                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15733                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15734                 false,
15735         },
15736         {
15737                 "drsuapi_DsCrackNames",
15738                 sizeof(struct drsuapi_DsCrackNames),
15739                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15740                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15741                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15742                 false,
15743         },
15744         {
15745                 "drsuapi_DsWriteAccountSpn",
15746                 sizeof(struct drsuapi_DsWriteAccountSpn),
15747                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15748                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15749                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15750                 false,
15751         },
15752         {
15753                 "drsuapi_DsRemoveDSServer",
15754                 sizeof(struct drsuapi_DsRemoveDSServer),
15755                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15756                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15757                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15758                 false,
15759         },
15760         {
15761                 "DRSUAPI_REMOVE_DS_DOMAIN",
15762                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15763                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15764                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15765                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15766                 false,
15767         },
15768         {
15769                 "drsuapi_DsGetDomainControllerInfo",
15770                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15771                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15772                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15773                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15774                 false,
15775         },
15776         {
15777                 "drsuapi_DsAddEntry",
15778                 sizeof(struct drsuapi_DsAddEntry),
15779                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15780                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15781                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15782                 false,
15783         },
15784         {
15785                 "drsuapi_DsExecuteKCC",
15786                 sizeof(struct drsuapi_DsExecuteKCC),
15787                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15788                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15789                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15790                 false,
15791         },
15792         {
15793                 "drsuapi_DsReplicaGetInfo",
15794                 sizeof(struct drsuapi_DsReplicaGetInfo),
15795                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15796                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15797                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15798                 false,
15799         },
15800         {
15801                 "DRSUAPI_ADD_SID_HISTORY",
15802                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15803                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15804                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15805                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15806                 false,
15807         },
15808         {
15809                 "drsuapi_DsGetMemberships2",
15810                 sizeof(struct drsuapi_DsGetMemberships2),
15811                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15812                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15813                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15814                 false,
15815         },
15816         {
15817                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15818                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15819                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15820                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15821                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15822                 false,
15823         },
15824         {
15825                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15826                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15827                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15828                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15829                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15830                 false,
15831         },
15832         {
15833                 "drsuapi_QuerySitesByCost",
15834                 sizeof(struct drsuapi_QuerySitesByCost),
15835                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15836                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15837                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15838                 false,
15839         },
15840         { NULL, 0, NULL, NULL, NULL, false }
15841 };
15842
15843 static const char * const drsuapi_endpoint_strings[] = {
15844         "ncacn_np:[\\pipe\\lsass]",
15845         "ncacn_np:[\\pipe\\protected_storage]",
15846         "ncacn_ip_tcp:",
15847         "ncalrpc:",
15848 };
15849
15850 static const struct ndr_interface_string_array drsuapi_endpoints = {
15851         .count  = 4,
15852         .names  = drsuapi_endpoint_strings
15853 };
15854
15855 static const char * const drsuapi_authservice_strings[] = {
15856         "ldap",
15857 };
15858
15859 static const struct ndr_interface_string_array drsuapi_authservices = {
15860         .count  = 1,
15861         .names  = drsuapi_authservice_strings
15862 };
15863
15864
15865 const struct ndr_interface_table ndr_table_drsuapi = {
15866         .name           = "drsuapi",
15867         .syntax_id      = {
15868                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15869                 NDR_DRSUAPI_VERSION
15870         },
15871         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15872         .num_calls      = 25,
15873         .calls          = drsuapi_calls,
15874         .endpoints      = &drsuapi_endpoints,
15875         .authservices   = &drsuapi_authservices
15876 };
15877