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         }
  96         if (ndr_flags & NDR_BUFFERS) {
  97         }
  98         return NDR_ERR_SUCCESS;
  99 }
 100
 101 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo24 *r)
 102 {
 103         if (ndr_flags & NDR_SCALARS) {
 104                 NDR_CHECK(ndr_pull_align(ndr, 4));
 105                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 106                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 108         }
 109         if (ndr_flags & NDR_BUFFERS) {
 110         }
 111         return NDR_ERR_SUCCESS;
 112 }
 113
 114 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r)
 115 {
 116         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo24");
 117         ndr->depth++;
 118         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 119         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 120         ndr_print_uint32(ndr, "pid", r->pid);
 121         ndr->depth--;
 122 }
 123
 124 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo28 *r)
 125 {
 126         if (ndr_flags & NDR_SCALARS) {
 127                 NDR_CHECK(ndr_push_align(ndr, 4));
 128                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 129                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 132         }
 133         if (ndr_flags & NDR_BUFFERS) {
 134         }
 135         return NDR_ERR_SUCCESS;
 136 }
 137
 138 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo28 *r)
 139 {
 140         if (ndr_flags & NDR_SCALARS) {
 141                 NDR_CHECK(ndr_pull_align(ndr, 4));
 142                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 143                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 146         }
 147         if (ndr_flags & NDR_BUFFERS) {
 148         }
 149         return NDR_ERR_SUCCESS;
 150 }
 151
 152 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo28(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo28 *r)
 153 {
 154         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo28");
 155         ndr->depth++;
 156         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 157         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 158         ndr_print_uint32(ndr, "pid", r->pid);
 159         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 160         ndr->depth--;
 161 }
 162
 163 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo48 *r)
 164 {
 165         if (ndr_flags & NDR_SCALARS) {
 166                 NDR_CHECK(ndr_push_align(ndr, 4));
 167                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 168                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 171                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
 172                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 173         }
 174         if (ndr_flags & NDR_BUFFERS) {
 175         }
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo48 *r)
 180 {
 181         if (ndr_flags & NDR_SCALARS) {
 182                 NDR_CHECK(ndr_pull_align(ndr, 4));
 183                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 184                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 187                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
 188                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 189         }
 190         if (ndr_flags & NDR_BUFFERS) {
 191         }
 192         return NDR_ERR_SUCCESS;
 193 }
 194
 195 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo48(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo48 *r)
 196 {
 197         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo48");
 198         ndr->depth++;
 199         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 200         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 201         ndr_print_uint32(ndr, "pid", r->pid);
 202         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 203         ndr_print_drsuapi_SupportedExtensionsExt(ndr, "supported_extensions_ext", r->supported_extensions_ext);
 204         ndr_print_GUID(ndr, "config_dn_guid", &r->config_dn_guid);
 205         ndr->depth--;
 206 }
 207
 208 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoFallBack *r)
 209 {
 210         if (ndr_flags & NDR_SCALARS) {
 211                 NDR_CHECK(ndr_push_align(ndr, 4));
 212                 {
 213                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 215                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
 216                         ndr->flags = _flags_save_DATA_BLOB;
 217                 }
 218         }
 219         if (ndr_flags & NDR_BUFFERS) {
 220         }
 221         return NDR_ERR_SUCCESS;
 222 }
 223
 224 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoFallBack *r)
 225 {
 226         if (ndr_flags & NDR_SCALARS) {
 227                 NDR_CHECK(ndr_pull_align(ndr, 4));
 228                 {
 229                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 231                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
 232                         ndr->flags = _flags_save_DATA_BLOB;
 233                 }
 234         }
 235         if (ndr_flags & NDR_BUFFERS) {
 236         }
 237         return NDR_ERR_SUCCESS;
 238 }
 239
 240 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoFallBack(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoFallBack *r)
 241 {
 242         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoFallBack");
 243         ndr->depth++;
 244         ndr_print_DATA_BLOB(ndr, "info", r->info);
 245         ndr->depth--;
 246 }
 247
 248 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
 249 {
 250         if (ndr_flags & NDR_SCALARS) {
 251                 int level = ndr_push_get_switch_value(ndr, r);
 252                 switch (level) {
 253                         case 24: {
 254                                 {
 255                                         struct ndr_push *_ndr_info24;
 256                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 4, -1));
 257                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 258                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 4, -1));
 259                                 }
 260                         break; }
 261
 262                         case 28: {
 263                                 {
 264                                         struct ndr_push *_ndr_info28;
 265                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 4, -1));
 266                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 267                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 4, -1));
 268                                 }
 269                         break; }
 270
 271                         case 48: {
 272                                 {
 273                                         struct ndr_push *_ndr_info48;
 274                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 4, -1));
 275                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 276                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 4, -1));
 277                                 }
 278                         break; }
 279
 280                         default: {
 281                                 {
 282                                         struct ndr_push *_ndr_FallBack;
 283                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 284                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 285                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 286                                 }
 287                         break; }
 288
 289                 }
 290         }
 291         if (ndr_flags & NDR_BUFFERS) {
 292                 int level = ndr_push_get_switch_value(ndr, r);
 293                 switch (level) {
 294                         case 24:
 295                         break;
 296
 297                         case 28:
 298                         break;
 299
 300                         case 48:
 301                         break;
 302
 303                         default:
 304                         break;
 305
 306                 }
 307         }
 308         return NDR_ERR_SUCCESS;
 309 }
 310
 311 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
 312 {
 313         int level;
 314         level = ndr_pull_get_switch_value(ndr, r);
 315         if (ndr_flags & NDR_SCALARS) {
 316                 switch (level) {
 317                         case 24: {
 318                                 {
 319                                         struct ndr_pull *_ndr_info24;
 320                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 4, -1));
 321                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 322                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 4, -1));
 323                                 }
 324                         break; }
 325
 326                         case 28: {
 327                                 {
 328                                         struct ndr_pull *_ndr_info28;
 329                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 4, -1));
 330                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 331                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 4, -1));
 332                                 }
 333                         break; }
 334
 335                         case 48: {
 336                                 {
 337                                         struct ndr_pull *_ndr_info48;
 338                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 4, -1));
 339                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 340                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 4, -1));
 341                                 }
 342                         break; }
 343
 344                         default: {
 345                                 {
 346                                         struct ndr_pull *_ndr_FallBack;
 347                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 348                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 349                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 350                                 }
 351                         break; }
 352
 353                 }
 354         }
 355         if (ndr_flags & NDR_BUFFERS) {
 356                 switch (level) {
 357                         case 24:
 358                         break;
 359
 360                         case 28:
 361                         break;
 362
 363                         case 48:
 364                         break;
 365
 366                         default:
 367                         break;
 368
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
 375 {
 376         int level;
 377         level = ndr_print_get_switch_value(ndr, r);
 378         ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
 379         switch (level) {
 380                 case 24:
 381                         ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
 382                 break;
 383
 384                 case 28:
 385                         ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
 386                 break;
 387
 388                 case 48:
 389                         ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
 390                 break;
 391
 392                 default:
 393                         ndr_print_drsuapi_DsBindInfoFallBack(ndr, "FallBack", &r->FallBack);
 394                 break;
 395
 396         }
 397 }
 398
 399 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoCtr *r)
 400 {
 401         if (ndr_flags & NDR_SCALARS) {
 402                 NDR_CHECK(ndr_push_align(ndr, 4));
 403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 404                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
 405                 NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 406         }
 407         if (ndr_flags & NDR_BUFFERS) {
 408         }
 409         return NDR_ERR_SUCCESS;
 410 }
 411
 412 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoCtr *r)
 413 {
 414         if (ndr_flags & NDR_SCALARS) {
 415                 NDR_CHECK(ndr_pull_align(ndr, 4));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 417                 if (r->length < 1 || r->length > 10000) {
 418                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 419                 }
 420                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
 421                 NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 422         }
 423         if (ndr_flags & NDR_BUFFERS) {
 424         }
 425         return NDR_ERR_SUCCESS;
 426 }
 427
 428 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoCtr *r)
 429 {
 430         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoCtr");
 431         ndr->depth++;
 432         ndr_print_uint32(ndr, "length", r->length);
 433         ndr_print_set_switch_value(ndr, &r->info, r->length);
 434         ndr_print_drsuapi_DsBindInfo(ndr, "info", &r->info);
 435         ndr->depth--;
 436 }
 437
 438 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 439 {
 440         if (ndr_flags & NDR_SCALARS) {
 441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
 442                 NDR_CHECK(ndr_push_align(ndr, 4));
 443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4));
 444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
 445                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 446                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
 448                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
 449         }
 450         if (ndr_flags & NDR_BUFFERS) {
 451                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 452         }
 453         return NDR_ERR_SUCCESS;
 454 }
 455
 456 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier *r)
 457 {
 458         if (ndr_flags & NDR_SCALARS) {
 459                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dn));
 460                 NDR_CHECK(ndr_pull_align(ndr, 4));
 461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
 462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
 463                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 464                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
 466                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, ndr_get_array_size(ndr, &r->dn), sizeof(uint16_t), CH_UTF16));
 467                 if (r->dn) {
 468                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
 469                 }
 470         }
 471         if (ndr_flags & NDR_BUFFERS) {
 472                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 473         }
 474         return NDR_ERR_SUCCESS;
 475 }
 476
 477 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier *r)
 478 {
 479         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier");
 480         ndr->depth++;
 481         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);
 482         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);
 483         ndr_print_GUID(ndr, "guid", &r->guid);
 484         ndr_print_dom_sid28(ndr, "sid", &r->sid);
 485         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
 486         ndr_print_string(ndr, "dn", r->dn);
 487         ndr->depth--;
 488 }
 489
 490 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, struct smb_iconv_convenience *ic, int flags)
 491 {
 492         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier, ic);
 493 }
 494
 495 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 496 {
 497         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 498         return NDR_ERR_SUCCESS;
 499 }
 500
 501 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 502 {
 503         uint32_t v;
 504         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 505         *r = v;
 506         return NDR_ERR_SUCCESS;
 507 }
 508
 509 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, const char *name, uint32_t r)
 510 {
 511         ndr_print_uint32(ndr, name, r);
 512         ndr->depth++;
 513         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION, r);
 514         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_WRITEABLE", DRSUAPI_DS_REPLICA_SYNC_WRITEABLE, r);
 515         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PERIODIC", DRSUAPI_DS_REPLICA_SYNC_PERIODIC, r);
 516         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING", DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING, r);
 517         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES", DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES, r);
 518         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL", DRSUAPI_DS_REPLICA_SYNC_FULL, r);
 519         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_URGENT", DRSUAPI_DS_REPLICA_SYNC_URGENT, r);
 520         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD", DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD, r);
 521         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FORCE", DRSUAPI_DS_REPLICA_SYNC_FORCE, r);
 522         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE", DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE, r);
 523         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED", DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED, r);
 524         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_TWO_WAY", DRSUAPI_DS_REPLICA_SYNC_TWO_WAY, r);
 525         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY", DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY, r);
 526         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL", DRSUAPI_DS_REPLICA_SYNC_INITIAL, r);
 527         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION", DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION, r);
 528         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ABANDONED", DRSUAPI_DS_REPLICA_SYNC_ABANDONED, r);
 529         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS, r);
 530         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET, r);
 531         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_REQUEUE", DRSUAPI_DS_REPLICA_SYNC_REQUEUE, r);
 532         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION", DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION, r);
 533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA, r);
 534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_CRITICAL", DRSUAPI_DS_REPLICA_SYNC_CRITICAL, r);
 535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS, r);
 536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PREEMPTED", DRSUAPI_DS_REPLICA_SYNC_PREEMPTED, r);
 537         ndr->depth--;
 538 }
 539
 540 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 541 {
 542         if (ndr_flags & NDR_SCALARS) {
 543                 NDR_CHECK(ndr_push_align(ndr, 4));
 544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
 545                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 546                 {
 547                         uint32_t _flags_save_string = ndr->flags;
 548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 549                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
 550                         ndr->flags = _flags_save_string;
 551                 }
 552                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->options));
 553         }
 554         if (ndr_flags & NDR_BUFFERS) {
 555                 if (r->naming_context) {
 556                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 557                 }
 558                 {
 559                         uint32_t _flags_save_string = ndr->flags;
 560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 561                         if (r->other_info) {
 562                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->other_info));
 563                         }
 564                         ndr->flags = _flags_save_string;
 565                 }
 566         }
 567         return NDR_ERR_SUCCESS;
 568 }
 569
 570 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 571 {
 572         uint32_t _ptr_naming_context;
 573         TALLOC_CTX *_mem_save_naming_context_0;
 574         uint32_t _ptr_other_info;
 575         TALLOC_CTX *_mem_save_other_info_0;
 576         if (ndr_flags & NDR_SCALARS) {
 577                 NDR_CHECK(ndr_pull_align(ndr, 4));
 578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
 579                 if (_ptr_naming_context) {
 580                         NDR_PULL_ALLOC(ndr, r->naming_context);
 581                 } else {
 582                         r->naming_context = NULL;
 583                 }
 584                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 585                 {
 586                         uint32_t _flags_save_string = ndr->flags;
 587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 588                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 589                         if (_ptr_other_info) {
 590                                 NDR_PULL_ALLOC(ndr, r->other_info);
 591                         } else {
 592                                 r->other_info = NULL;
 593                         }
 594                         ndr->flags = _flags_save_string;
 595                 }
 596                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->options));
 597         }
 598         if (ndr_flags & NDR_BUFFERS) {
 599                 if (r->naming_context) {
 600                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 601                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 602                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 604                 }
 605                 {
 606                         uint32_t _flags_save_string = ndr->flags;
 607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 608                         if (r->other_info) {
 609                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 610                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->other_info));
 612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 613                         }
 614                         ndr->flags = _flags_save_string;
 615                 }
 616         }
 617         return NDR_ERR_SUCCESS;
 618 }
 619
 620 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 621 {
 622         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 623         ndr->depth++;
 624         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 625         ndr->depth++;
 626         if (r->naming_context) {
 627                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 628         }
 629         ndr->depth--;
 630         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 631         ndr_print_ptr(ndr, "other_info", r->other_info);
 632         ndr->depth++;
 633         if (r->other_info) {
 634                 ndr_print_string(ndr, "other_info", r->other_info);
 635         }
 636         ndr->depth--;
 637         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "options", r->options);
 638         ndr->depth--;
 639 }
 640
 641 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 642 {
 643         if (ndr_flags & NDR_SCALARS) {
 644                 int level = ndr_push_get_switch_value(ndr, r);
 645                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
 646                 switch (level) {
 647                         case 1: {
 648                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 649                         break; }
 650
 651                         default:
 652                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 653                 }
 654         }
 655         if (ndr_flags & NDR_BUFFERS) {
 656                 int level = ndr_push_get_switch_value(ndr, r);
 657                 switch (level) {
 658                         case 1:
 659                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 660                         break;
 661
 662                         default:
 663                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 664                 }
 665         }
 666         return NDR_ERR_SUCCESS;
 667 }
 668
 669 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaSyncRequest *r)
 670 {
 671         int level;
 672         int32_t _level;
 673         level = ndr_pull_get_switch_value(ndr, r);
 674         if (ndr_flags & NDR_SCALARS) {
 675                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
 676                 if (_level != level) {
 677                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 678                 }
 679                 switch (level) {
 680                         case 1: {
 681                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 682                         break; }
 683
 684                         default:
 685                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 686                 }
 687         }
 688         if (ndr_flags & NDR_BUFFERS) {
 689                 switch (level) {
 690                         case 1:
 691                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 692                         break;
 693
 694                         default:
 695                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 696                 }
 697         }
 698         return NDR_ERR_SUCCESS;
 699 }
 700
 701 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 702 {
 703         int level;
 704         level = ndr_print_get_switch_value(ndr, r);
 705         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 706         switch (level) {
 707                 case 1:
 708                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 709                 break;
 710
 711                 default:
 712                         ndr_print_bad_level(ndr, name, level);
 713         }
 714 }
 715
 716 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 717 {
 718         if (ndr_flags & NDR_SCALARS) {
 719                 NDR_CHECK(ndr_push_align(ndr, 8));
 720                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 721                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 722                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 723         }
 724         if (ndr_flags & NDR_BUFFERS) {
 725         }
 726         return NDR_ERR_SUCCESS;
 727 }
 728
 729 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 730 {
 731         if (ndr_flags & NDR_SCALARS) {
 732                 NDR_CHECK(ndr_pull_align(ndr, 8));
 733                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 734                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 735                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 736         }
 737         if (ndr_flags & NDR_BUFFERS) {
 738         }
 739         return NDR_ERR_SUCCESS;
 740 }
 741
 742 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 743 {
 744         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 745         ndr->depth++;
 746         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 747         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 748         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 749         ndr->depth--;
 750 }
 751
 752 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 753 {
 754         if (ndr_flags & NDR_SCALARS) {
 755                 NDR_CHECK(ndr_push_align(ndr, 8));
 756                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 757                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 758         }
 759         if (ndr_flags & NDR_BUFFERS) {
 760         }
 761         return NDR_ERR_SUCCESS;
 762 }
 763
 764 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 765 {
 766         if (ndr_flags & NDR_SCALARS) {
 767                 NDR_CHECK(ndr_pull_align(ndr, 8));
 768                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 769                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 770         }
 771         if (ndr_flags & NDR_BUFFERS) {
 772         }
 773         return NDR_ERR_SUCCESS;
 774 }
 775
 776 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 777 {
 778         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 779         ndr->depth++;
 780         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 781         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 782         ndr->depth--;
 783 }
 784
 785 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 786 {
 787         uint32_t cntr_cursors_0;
 788         if (ndr_flags & NDR_SCALARS) {
 789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 790                 NDR_CHECK(ndr_push_align(ndr, 8));
 791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 795                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 796                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 797                 }
 798         }
 799         if (ndr_flags & NDR_BUFFERS) {
 800         }
 801         return NDR_ERR_SUCCESS;
 802 }
 803
 804 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 805 {
 806         uint32_t cntr_cursors_0;
 807         TALLOC_CTX *_mem_save_cursors_0;
 808         if (ndr_flags & NDR_SCALARS) {
 809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 810                 NDR_CHECK(ndr_pull_align(ndr, 8));
 811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 814                 if (r->count > 0x100000) {
 815                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 816                 }
 817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 818                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
 819                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 820                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 821                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 822                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 823                 }
 824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 825                 if (r->cursors) {
 826                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 827                 }
 828         }
 829         if (ndr_flags & NDR_BUFFERS) {
 830         }
 831         return NDR_ERR_SUCCESS;
 832 }
 833
 834 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 835 {
 836         uint32_t cntr_cursors_0;
 837         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 838         ndr->depth++;
 839         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 840         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 841         ndr_print_uint32(ndr, "count", r->count);
 842         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 843         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 844         ndr->depth++;
 845         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 846                 char *idx_0=NULL;
 847                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 848                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 849                         free(idx_0);
 850                 }
 851         }
 852         ndr->depth--;
 853         ndr->depth--;
 854 }
 855
 856 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 857 {
 858         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 859         return NDR_ERR_SUCCESS;
 860 }
 861
 862 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 863 {
 864         uint32_t v;
 865         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 866         *r = v;
 867         return NDR_ERR_SUCCESS;
 868 }
 869
 870 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 871 {
 872         ndr_print_uint32(ndr, name, r);
 873         ndr->depth++;
 874         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE", DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE, r);
 875         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP", DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP, r);
 876         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS", DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS, r);
 877         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);
 878         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC, r);
 879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS", DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS, r);
 880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS, r);
 881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_NEXT_PACKET", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_NEXT_PACKET, r);
 882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED", DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED, r);
 883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED", DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED, r);
 884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS, r);
 885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC, r);
 886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES", DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES, r);
 887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS, r);
 888         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET, r);
 889         ndr->depth--;
 890 }
 891
 892 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 893 {
 894         {
 895                 uint32_t _flags_save_ENUM = ndr->flags;
 896                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 898                 ndr->flags = _flags_save_ENUM;
 899         }
 900         return NDR_ERR_SUCCESS;
 901 }
 902
 903 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 904 {
 905         uint32_t v;
 906         {
 907                 uint32_t _flags_save_ENUM = ndr->flags;
 908                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 910                 *r = v;
 911                 ndr->flags = _flags_save_ENUM;
 912         }
 913         return NDR_ERR_SUCCESS;
 914 }
 915
 916 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 917 {
 918         const char *val = NULL;
 919
 920         {
 921                 uint32_t _flags_save_ENUM = ndr->flags;
 922                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 923                 switch (r) {
 924                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
 925                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
 926                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
 927                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
 928                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
 929                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
 930                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
 931                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
 932                 }
 933                 ndr_print_enum(ndr, name, "ENUM", val, r);
 934                 ndr->flags = _flags_save_ENUM;
 935         }
 936 }
 937
 938 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
 939 {
 940         {
 941                 uint32_t _flags_save_ENUM = ndr->flags;
 942                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 944                 ndr->flags = _flags_save_ENUM;
 945         }
 946         return NDR_ERR_SUCCESS;
 947 }
 948
 949 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
 950 {
 951         uint32_t v;
 952         {
 953                 uint32_t _flags_save_ENUM = ndr->flags;
 954                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 956                 *r = v;
 957                 ndr->flags = _flags_save_ENUM;
 958         }
 959         return NDR_ERR_SUCCESS;
 960 }
 961
 962 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
 963 {
 964         const char *val = NULL;
 965
 966         {
 967                 uint32_t _flags_save_ENUM = ndr->flags;
 968                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 969                 switch (r) {
 970                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
 971                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
 972                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
 973                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
 974                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
 975                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
 976                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
 977                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
 978                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
 979                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
 980                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
 981                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
 982                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
 983                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
 984                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
 985                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
 986                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
 987                 }
 988                 ndr_print_enum(ndr, name, "ENUM", val, r);
 989                 ndr->flags = _flags_save_ENUM;
 990         }
 991 }
 992
 993 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
 994 {
 995         if (ndr_flags & NDR_SCALARS) {
 996                 NDR_CHECK(ndr_push_align(ndr, 8));
 997                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
 998                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 999                 if (r->naming_context == NULL) {
1000                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1001                 }
1002                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1003                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1005                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1008                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1009                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1010         }
1011         if (ndr_flags & NDR_BUFFERS) {
1012                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1013                 if (r->uptodateness_vector) {
1014                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1015                 }
1016         }
1017         return NDR_ERR_SUCCESS;
1018 }
1019
1020 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1021 {
1022         uint32_t _ptr_naming_context;
1023         TALLOC_CTX *_mem_save_naming_context_0;
1024         uint32_t _ptr_uptodateness_vector;
1025         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1026         if (ndr_flags & NDR_SCALARS) {
1027                 NDR_CHECK(ndr_pull_align(ndr, 8));
1028                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1029                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1030                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1031                 if (_ptr_naming_context) {
1032                         NDR_PULL_ALLOC(ndr, r->naming_context);
1033                 } else {
1034                         r->naming_context = NULL;
1035                 }
1036                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1037                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1038                 if (_ptr_uptodateness_vector) {
1039                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1040                 } else {
1041                         r->uptodateness_vector = NULL;
1042                 }
1043                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1045                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1046                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1047                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1048         }
1049         if (ndr_flags & NDR_BUFFERS) {
1050                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1051                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1052                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1053                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1054                 if (r->uptodateness_vector) {
1055                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1056                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1057                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1058                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1059                 }
1060         }
1061         return NDR_ERR_SUCCESS;
1062 }
1063
1064 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1065 {
1066         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1067         ndr->depth++;
1068         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1069         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1070         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1071         ndr->depth++;
1072         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1073         ndr->depth--;
1074         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1075         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1076         ndr->depth++;
1077         if (r->uptodateness_vector) {
1078                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1079         }
1080         ndr->depth--;
1081         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1082         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1083         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1084         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1085         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1086         ndr->depth--;
1087 }
1088
1089 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
1090 {
1091         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
1092         ndr->depth++;
1093         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaOID_oid(r->oid, 0):r->__ndr_size);
1094         ndr_print_ptr(ndr, "oid", r->oid);
1095         ndr->depth++;
1096         if (r->oid) {
1097                 ndr_print_string(ndr, "oid", r->oid);
1098         }
1099         ndr->depth--;
1100         ndr->depth--;
1101 }
1102
1103 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1104 {
1105         if (ndr_flags & NDR_SCALARS) {
1106                 NDR_CHECK(ndr_push_align(ndr, 4));
1107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1108                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1109         }
1110         if (ndr_flags & NDR_BUFFERS) {
1111                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1112         }
1113         return NDR_ERR_SUCCESS;
1114 }
1115
1116 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1117 {
1118         if (ndr_flags & NDR_SCALARS) {
1119                 NDR_CHECK(ndr_pull_align(ndr, 4));
1120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1121                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1122         }
1123         if (ndr_flags & NDR_BUFFERS) {
1124                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1125         }
1126         return NDR_ERR_SUCCESS;
1127 }
1128
1129 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1130 {
1131         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1132         ndr->depth++;
1133         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1134         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1135         ndr->depth--;
1136 }
1137
1138 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1139 {
1140         uint32_t cntr_mappings_1;
1141         if (ndr_flags & NDR_SCALARS) {
1142                 NDR_CHECK(ndr_push_align(ndr, 4));
1143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1144                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1145         }
1146         if (ndr_flags & NDR_BUFFERS) {
1147                 if (r->mappings) {
1148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1149                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1150                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1151                         }
1152                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1153                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1154                         }
1155                 }
1156         }
1157         return NDR_ERR_SUCCESS;
1158 }
1159
1160 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1161 {
1162         uint32_t _ptr_mappings;
1163         uint32_t cntr_mappings_1;
1164         TALLOC_CTX *_mem_save_mappings_0;
1165         TALLOC_CTX *_mem_save_mappings_1;
1166         if (ndr_flags & NDR_SCALARS) {
1167                 NDR_CHECK(ndr_pull_align(ndr, 4));
1168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1169                 if (r->num_mappings > 0x100000) {
1170                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1171                 }
1172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1173                 if (_ptr_mappings) {
1174                         NDR_PULL_ALLOC(ndr, r->mappings);
1175                 } else {
1176                         r->mappings = NULL;
1177                 }
1178         }
1179         if (ndr_flags & NDR_BUFFERS) {
1180                 if (r->mappings) {
1181                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1182                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1183                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1184                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1185                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1186                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1187                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1188                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1189                         }
1190                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1191                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1192                         }
1193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1195                 }
1196                 if (r->mappings) {
1197                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1198                 }
1199         }
1200         return NDR_ERR_SUCCESS;
1201 }
1202
1203 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1204 {
1205         uint32_t cntr_mappings_1;
1206         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1207         ndr->depth++;
1208         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1209         ndr_print_ptr(ndr, "mappings", r->mappings);
1210         ndr->depth++;
1211         if (r->mappings) {
1212                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1213                 ndr->depth++;
1214                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1215                         char *idx_1=NULL;
1216                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1217                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1218                                 free(idx_1);
1219                         }
1220                 }
1221                 ndr->depth--;
1222         }
1223         ndr->depth--;
1224         ndr->depth--;
1225 }
1226
1227 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1228 {
1229         {
1230                 uint32_t _flags_save_ENUM = ndr->flags;
1231                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1233                 ndr->flags = _flags_save_ENUM;
1234         }
1235         return NDR_ERR_SUCCESS;
1236 }
1237
1238 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1239 {
1240         uint32_t v;
1241         {
1242                 uint32_t _flags_save_ENUM = ndr->flags;
1243                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1245                 *r = v;
1246                 ndr->flags = _flags_save_ENUM;
1247         }
1248         return NDR_ERR_SUCCESS;
1249 }
1250
1251 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1252 {
1253         const char *val = NULL;
1254
1255         {
1256                 uint32_t _flags_save_ENUM = ndr->flags;
1257                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1258                 switch (r) {
1259                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1260                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1261                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1262                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1263                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1264                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1265                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1266                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1267                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1268                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1269                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1270                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1271                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1272                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1273                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1274                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1275                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1276                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1277                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1278                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1279                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1280                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1281                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1282                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1283                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1284                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1285                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1286                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1287                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1288                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1289                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1290                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1291                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1292                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1293                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1294                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1295                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1296                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1297                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1298                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1299                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1300                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1301                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1302                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1303                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1304                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1305                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1306                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1307                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1308                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1309                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1310                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1311                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1312                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1313                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1314                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1315                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1316                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1317                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1318                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1319                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1320                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1321                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1322                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1323                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1324                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1325                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1326                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1327                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1328                 }
1329                 ndr_print_enum(ndr, name, "ENUM", val, r);
1330                 ndr->flags = _flags_save_ENUM;
1331         }
1332 }
1333
1334 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1335 {
1336         uint32_t cntr_attids_0;
1337         if (ndr_flags & NDR_SCALARS) {
1338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1339                 NDR_CHECK(ndr_push_align(ndr, 4));
1340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1343                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1344                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1345                 }
1346         }
1347         if (ndr_flags & NDR_BUFFERS) {
1348         }
1349         return NDR_ERR_SUCCESS;
1350 }
1351
1352 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1353 {
1354         uint32_t cntr_attids_0;
1355         TALLOC_CTX *_mem_save_attids_0;
1356         if (ndr_flags & NDR_SCALARS) {
1357                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1358                 NDR_CHECK(ndr_pull_align(ndr, 4));
1359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1362                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1363                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1364                 }
1365                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1366                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1367                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1368                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1369                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1370                 }
1371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1372                 if (r->attids) {
1373                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1374                 }
1375         }
1376         if (ndr_flags & NDR_BUFFERS) {
1377         }
1378         return NDR_ERR_SUCCESS;
1379 }
1380
1381 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1382 {
1383         uint32_t cntr_attids_0;
1384         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1385         ndr->depth++;
1386         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1387         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1388         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1389         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1390         ndr->depth++;
1391         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1392                 char *idx_0=NULL;
1393                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1394                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1395                         free(idx_0);
1396                 }
1397         }
1398         ndr->depth--;
1399         ndr->depth--;
1400 }
1401
1402 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1403 {
1404         if (ndr_flags & NDR_SCALARS) {
1405                 NDR_CHECK(ndr_push_align(ndr, 8));
1406                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1407                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1408                 if (r->naming_context == NULL) {
1409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1410                 }
1411                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1412                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1414                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1417                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1418                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1421                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1422         }
1423         if (ndr_flags & NDR_BUFFERS) {
1424                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1425                 if (r->uptodateness_vector) {
1426                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1427                 }
1428                 if (r->partial_attribute_set) {
1429                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1430                 }
1431                 if (r->partial_attribute_set_ex) {
1432                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1433                 }
1434                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1435         }
1436         return NDR_ERR_SUCCESS;
1437 }
1438
1439 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1440 {
1441         uint32_t _ptr_naming_context;
1442         TALLOC_CTX *_mem_save_naming_context_0;
1443         uint32_t _ptr_uptodateness_vector;
1444         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1445         uint32_t _ptr_partial_attribute_set;
1446         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1447         uint32_t _ptr_partial_attribute_set_ex;
1448         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1449         if (ndr_flags & NDR_SCALARS) {
1450                 NDR_CHECK(ndr_pull_align(ndr, 8));
1451                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1452                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1453                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1454                 if (_ptr_naming_context) {
1455                         NDR_PULL_ALLOC(ndr, r->naming_context);
1456                 } else {
1457                         r->naming_context = NULL;
1458                 }
1459                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1461                 if (_ptr_uptodateness_vector) {
1462                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1463                 } else {
1464                         r->uptodateness_vector = NULL;
1465                 }
1466                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1469                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1470                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1471                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1472                 if (_ptr_partial_attribute_set) {
1473                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1474                 } else {
1475                         r->partial_attribute_set = NULL;
1476                 }
1477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1478                 if (_ptr_partial_attribute_set_ex) {
1479                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1480                 } else {
1481                         r->partial_attribute_set_ex = NULL;
1482                 }
1483                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1484         }
1485         if (ndr_flags & NDR_BUFFERS) {
1486                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1487                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1488                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1490                 if (r->uptodateness_vector) {
1491                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1492                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1493                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1494                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1495                 }
1496                 if (r->partial_attribute_set) {
1497                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1498                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1499                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1501                 }
1502                 if (r->partial_attribute_set_ex) {
1503                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1504                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1505                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1507                 }
1508                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1509         }
1510         return NDR_ERR_SUCCESS;
1511 }
1512
1513 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1514 {
1515         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1516         ndr->depth++;
1517         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1518         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1519         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1520         ndr->depth++;
1521         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1522         ndr->depth--;
1523         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1524         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1525         ndr->depth++;
1526         if (r->uptodateness_vector) {
1527                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1528         }
1529         ndr->depth--;
1530         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1531         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1532         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1533         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1534         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1535         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1536         ndr->depth++;
1537         if (r->partial_attribute_set) {
1538                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1539         }
1540         ndr->depth--;
1541         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1542         ndr->depth++;
1543         if (r->partial_attribute_set_ex) {
1544                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1545         }
1546         ndr->depth--;
1547         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1548         ndr->depth--;
1549 }
1550
1551 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1552 {
1553         if (ndr_flags & NDR_SCALARS) {
1554                 int level = ndr_push_get_switch_value(ndr, r);
1555                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1556                 switch (level) {
1557                         case 5: {
1558                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1559                         break; }
1560
1561                         case 8: {
1562                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1563                         break; }
1564
1565                         default:
1566                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1567                 }
1568         }
1569         if (ndr_flags & NDR_BUFFERS) {
1570                 int level = ndr_push_get_switch_value(ndr, r);
1571                 switch (level) {
1572                         case 5:
1573                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1574                         break;
1575
1576                         case 8:
1577                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1578                         break;
1579
1580                         default:
1581                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1582                 }
1583         }
1584         return NDR_ERR_SUCCESS;
1585 }
1586
1587 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1588 {
1589         int level;
1590         int32_t _level;
1591         level = ndr_pull_get_switch_value(ndr, r);
1592         if (ndr_flags & NDR_SCALARS) {
1593                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1594                 if (_level != level) {
1595                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1596                 }
1597                 switch (level) {
1598                         case 5: {
1599                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1600                         break; }
1601
1602                         case 8: {
1603                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1604                         break; }
1605
1606                         default:
1607                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1608                 }
1609         }
1610         if (ndr_flags & NDR_BUFFERS) {
1611                 switch (level) {
1612                         case 5:
1613                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1614                         break;
1615
1616                         case 8:
1617                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1618                         break;
1619
1620                         default:
1621                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1622                 }
1623         }
1624         return NDR_ERR_SUCCESS;
1625 }
1626
1627 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1628 {
1629         int level;
1630         level = ndr_print_get_switch_value(ndr, r);
1631         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1632         switch (level) {
1633                 case 5:
1634                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1635                 break;
1636
1637                 case 8:
1638                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1639                 break;
1640
1641                 default:
1642                         ndr_print_bad_level(ndr, name, level);
1643         }
1644 }
1645
1646 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1647 {
1648         if (ndr_flags & NDR_SCALARS) {
1649                 NDR_CHECK(ndr_push_align(ndr, 8));
1650                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1651                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1652                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1653         }
1654         if (ndr_flags & NDR_BUFFERS) {
1655         }
1656         return NDR_ERR_SUCCESS;
1657 }
1658
1659 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1660 {
1661         if (ndr_flags & NDR_SCALARS) {
1662                 NDR_CHECK(ndr_pull_align(ndr, 8));
1663                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1664                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1665                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1666         }
1667         if (ndr_flags & NDR_BUFFERS) {
1668         }
1669         return NDR_ERR_SUCCESS;
1670 }
1671
1672 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1673 {
1674         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1675         ndr->depth++;
1676         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1677         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1678         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1679         ndr->depth--;
1680 }
1681
1682 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1683 {
1684         uint32_t cntr_cursors_0;
1685         if (ndr_flags & NDR_SCALARS) {
1686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1687                 NDR_CHECK(ndr_push_align(ndr, 8));
1688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1692                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1693                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1694                 }
1695         }
1696         if (ndr_flags & NDR_BUFFERS) {
1697         }
1698         return NDR_ERR_SUCCESS;
1699 }
1700
1701 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1702 {
1703         uint32_t cntr_cursors_0;
1704         TALLOC_CTX *_mem_save_cursors_0;
1705         if (ndr_flags & NDR_SCALARS) {
1706                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1707                 NDR_CHECK(ndr_pull_align(ndr, 8));
1708                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1711                 if (r->count > 0x100000) {
1712                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1713                 }
1714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1715                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1716                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1717                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1718                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1719                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1720                 }
1721                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
1722                 if (r->cursors) {
1723                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
1724                 }
1725         }
1726         if (ndr_flags & NDR_BUFFERS) {
1727         }
1728         return NDR_ERR_SUCCESS;
1729 }
1730
1731 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1732 {
1733         uint32_t cntr_cursors_0;
1734         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
1735         ndr->depth++;
1736         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
1737         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1738         ndr_print_uint32(ndr, "count", r->count);
1739         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
1740         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
1741         ndr->depth++;
1742         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
1743                 char *idx_0=NULL;
1744                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
1745                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
1746                         free(idx_0);
1747                 }
1748         }
1749         ndr->depth--;
1750         ndr->depth--;
1751 }
1752
1753 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
1754 {
1755         if (ndr_flags & NDR_SCALARS) {
1756                 NDR_CHECK(ndr_push_align(ndr, 4));
1757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
1758                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
1759         }
1760         if (ndr_flags & NDR_BUFFERS) {
1761                 if (r->blob) {
1762                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
1763                 }
1764         }
1765         return NDR_ERR_SUCCESS;
1766 }
1767
1768 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
1769 {
1770         uint32_t _ptr_blob;
1771         TALLOC_CTX *_mem_save_blob_0;
1772         if (ndr_flags & NDR_SCALARS) {
1773                 NDR_CHECK(ndr_pull_align(ndr, 4));
1774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1775                 if (r->__ndr_size > 10485760) {
1776                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1777                 }
1778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
1779                 if (_ptr_blob) {
1780                         NDR_PULL_ALLOC(ndr, r->blob);
1781                 } else {
1782                         r->blob = NULL;
1783                 }
1784         }
1785         if (ndr_flags & NDR_BUFFERS) {
1786                 if (r->blob) {
1787                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
1788                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
1789                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
1790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
1791                 }
1792         }
1793         return NDR_ERR_SUCCESS;
1794 }
1795
1796 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
1797 {
1798         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
1799         ndr->depth++;
1800         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
1801         ndr_print_ptr(ndr, "blob", r->blob);
1802         ndr->depth++;
1803         if (r->blob) {
1804                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
1805         }
1806         ndr->depth--;
1807         ndr->depth--;
1808 }
1809
1810 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
1811 {
1812         uint32_t cntr_values_1;
1813         if (ndr_flags & NDR_SCALARS) {
1814                 NDR_CHECK(ndr_push_align(ndr, 4));
1815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
1816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
1817         }
1818         if (ndr_flags & NDR_BUFFERS) {
1819                 if (r->values) {
1820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
1821                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1822                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
1823                         }
1824                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1825                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
1826                         }
1827                 }
1828         }
1829         return NDR_ERR_SUCCESS;
1830 }
1831
1832 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
1833 {
1834         uint32_t _ptr_values;
1835         uint32_t cntr_values_1;
1836         TALLOC_CTX *_mem_save_values_0;
1837         TALLOC_CTX *_mem_save_values_1;
1838         if (ndr_flags & NDR_SCALARS) {
1839                 NDR_CHECK(ndr_pull_align(ndr, 4));
1840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
1841                 if (r->num_values > 10485760) {
1842                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1843                 }
1844                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
1845                 if (_ptr_values) {
1846                         NDR_PULL_ALLOC(ndr, r->values);
1847                 } else {
1848                         r->values = NULL;
1849                 }
1850         }
1851         if (ndr_flags & NDR_BUFFERS) {
1852                 if (r->values) {
1853                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
1854                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
1855                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
1856                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
1857                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
1858                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
1859                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1860                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
1861                         }
1862                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1863                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
1864                         }
1865                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
1866                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
1867                 }
1868                 if (r->values) {
1869                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
1870                 }
1871         }
1872         return NDR_ERR_SUCCESS;
1873 }
1874
1875 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
1876 {
1877         uint32_t cntr_values_1;
1878         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
1879         ndr->depth++;
1880         ndr_print_uint32(ndr, "num_values", r->num_values);
1881         ndr_print_ptr(ndr, "values", r->values);
1882         ndr->depth++;
1883         if (r->values) {
1884                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
1885                 ndr->depth++;
1886                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
1887                         char *idx_1=NULL;
1888                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
1889                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
1890                                 free(idx_1);
1891                         }
1892                 }
1893                 ndr->depth--;
1894         }
1895         ndr->depth--;
1896         ndr->depth--;
1897 }
1898
1899 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
1900 {
1901         if (ndr_flags & NDR_SCALARS) {
1902                 NDR_CHECK(ndr_push_align(ndr, 4));
1903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
1904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
1905                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
1906                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
1908                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
1909         }
1910         if (ndr_flags & NDR_BUFFERS) {
1911                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1912         }
1913         return NDR_ERR_SUCCESS;
1914 }
1915
1916 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
1917 {
1918         if (ndr_flags & NDR_SCALARS) {
1919                 NDR_CHECK(ndr_pull_align(ndr, 4));
1920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
1922                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
1923                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
1925                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
1926         }
1927         if (ndr_flags & NDR_BUFFERS) {
1928                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1929         }
1930         return NDR_ERR_SUCCESS;
1931 }
1932
1933 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
1934 {
1935         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
1936         ndr->depth++;
1937         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);
1938         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);
1939         ndr_print_GUID(ndr, "guid", &r->guid);
1940         ndr_print_dom_sid28(ndr, "sid", &r->sid);
1941         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
1942         ndr_print_string(ndr, "dn", r->dn);
1943         ndr->depth--;
1944 }
1945
1946 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
1947 {
1948         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
1949 }
1950
1951 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
1952 {
1953         if (ndr_flags & NDR_SCALARS) {
1954                 NDR_CHECK(ndr_push_align(ndr, 4));
1955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(r, ndr->iconv_convenience, ndr->flags)));
1956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
1957                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
1958                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
1960                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
1961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
1962                 {
1963                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1965                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
1966                         ndr->flags = _flags_save_DATA_BLOB;
1967                 }
1968         }
1969         if (ndr_flags & NDR_BUFFERS) {
1970                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1971         }
1972         return NDR_ERR_SUCCESS;
1973 }
1974
1975 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
1976 {
1977         if (ndr_flags & NDR_SCALARS) {
1978                 NDR_CHECK(ndr_pull_align(ndr, 4));
1979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
1981                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
1982                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
1984                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
1985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
1986                 {
1987                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1989                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
1990                         ndr->flags = _flags_save_DATA_BLOB;
1991                 }
1992         }
1993         if (ndr_flags & NDR_BUFFERS) {
1994                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1995         }
1996         return NDR_ERR_SUCCESS;
1997 }
1998
1999 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2000 {
2001         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2002         ndr->depth++;
2003         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
2004         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);
2005         ndr_print_GUID(ndr, "guid", &r->guid);
2006         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2007         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2008         ndr_print_string(ndr, "dn", r->dn);
2009         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2010         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2011         ndr->depth--;
2012 }
2013
2014 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, struct smb_iconv_convenience *ic, int flags)
2015 {
2016         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary, ic);
2017 }
2018
2019 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2020 {
2021         if (ndr_flags & NDR_SCALARS) {
2022                 NDR_CHECK(ndr_push_align(ndr, 4));
2023                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2024                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2025         }
2026         if (ndr_flags & NDR_BUFFERS) {
2027                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2028         }
2029         return NDR_ERR_SUCCESS;
2030 }
2031
2032 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2033 {
2034         if (ndr_flags & NDR_SCALARS) {
2035                 NDR_CHECK(ndr_pull_align(ndr, 4));
2036                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2037                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2038         }
2039         if (ndr_flags & NDR_BUFFERS) {
2040                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2041         }
2042         return NDR_ERR_SUCCESS;
2043 }
2044
2045 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2046 {
2047         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2048         ndr->depth++;
2049         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2050         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2051         ndr->depth--;
2052 }
2053
2054 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2055 {
2056         uint32_t cntr_attributes_1;
2057         if (ndr_flags & NDR_SCALARS) {
2058                 NDR_CHECK(ndr_push_align(ndr, 4));
2059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2061         }
2062         if (ndr_flags & NDR_BUFFERS) {
2063                 if (r->attributes) {
2064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2065                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2066                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2067                         }
2068                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2069                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2070                         }
2071                 }
2072         }
2073         return NDR_ERR_SUCCESS;
2074 }
2075
2076 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2077 {
2078         uint32_t _ptr_attributes;
2079         uint32_t cntr_attributes_1;
2080         TALLOC_CTX *_mem_save_attributes_0;
2081         TALLOC_CTX *_mem_save_attributes_1;
2082         if (ndr_flags & NDR_SCALARS) {
2083                 NDR_CHECK(ndr_pull_align(ndr, 4));
2084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2085                 if (r->num_attributes > 1048576) {
2086                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2087                 }
2088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2089                 if (_ptr_attributes) {
2090                         NDR_PULL_ALLOC(ndr, r->attributes);
2091                 } else {
2092                         r->attributes = NULL;
2093                 }
2094         }
2095         if (ndr_flags & NDR_BUFFERS) {
2096                 if (r->attributes) {
2097                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2098                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2099                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2100                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2101                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2102                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2103                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2104                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2105                         }
2106                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2107                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2108                         }
2109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2111                 }
2112                 if (r->attributes) {
2113                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2114                 }
2115         }
2116         return NDR_ERR_SUCCESS;
2117 }
2118
2119 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2120 {
2121         uint32_t cntr_attributes_1;
2122         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2123         ndr->depth++;
2124         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2125         ndr_print_ptr(ndr, "attributes", r->attributes);
2126         ndr->depth++;
2127         if (r->attributes) {
2128                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2129                 ndr->depth++;
2130                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2131                         char *idx_1=NULL;
2132                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2133                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2134                                 free(idx_1);
2135                         }
2136                 }
2137                 ndr->depth--;
2138         }
2139         ndr->depth--;
2140         ndr->depth--;
2141 }
2142
2143 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2144 {
2145         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2146         return NDR_ERR_SUCCESS;
2147 }
2148
2149 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2150 {
2151         uint32_t v;
2152         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2153         *r = v;
2154         return NDR_ERR_SUCCESS;
2155 }
2156
2157 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2158 {
2159         ndr_print_uint32(ndr, name, r);
2160         ndr->depth++;
2161         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2162         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2163         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2164         ndr->depth--;
2165 }
2166
2167 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2168 {
2169         if (ndr_flags & NDR_SCALARS) {
2170                 NDR_CHECK(ndr_push_align(ndr, 4));
2171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2172                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2173                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2174         }
2175         if (ndr_flags & NDR_BUFFERS) {
2176                 if (r->identifier) {
2177                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2178                 }
2179                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2180         }
2181         return NDR_ERR_SUCCESS;
2182 }
2183
2184 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2185 {
2186         uint32_t _ptr_identifier;
2187         TALLOC_CTX *_mem_save_identifier_0;
2188         if (ndr_flags & NDR_SCALARS) {
2189                 NDR_CHECK(ndr_pull_align(ndr, 4));
2190                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2191                 if (_ptr_identifier) {
2192                         NDR_PULL_ALLOC(ndr, r->identifier);
2193                 } else {
2194                         r->identifier = NULL;
2195                 }
2196                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2197                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2198         }
2199         if (ndr_flags & NDR_BUFFERS) {
2200                 if (r->identifier) {
2201                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2202                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2203                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2205                 }
2206                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2207         }
2208         return NDR_ERR_SUCCESS;
2209 }
2210
2211 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2212 {
2213         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2214         ndr->depth++;
2215         ndr_print_ptr(ndr, "identifier", r->identifier);
2216         ndr->depth++;
2217         if (r->identifier) {
2218                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2219         }
2220         ndr->depth--;
2221         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2222         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2223         ndr->depth--;
2224 }
2225
2226 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2227 {
2228         if (ndr_flags & NDR_SCALARS) {
2229                 NDR_CHECK(ndr_push_align(ndr, 8));
2230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2231                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2232                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2233                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2234         }
2235         if (ndr_flags & NDR_BUFFERS) {
2236         }
2237         return NDR_ERR_SUCCESS;
2238 }
2239
2240 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2241 {
2242         if (ndr_flags & NDR_SCALARS) {
2243                 NDR_CHECK(ndr_pull_align(ndr, 8));
2244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2245                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2246                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2247                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2248         }
2249         if (ndr_flags & NDR_BUFFERS) {
2250         }
2251         return NDR_ERR_SUCCESS;
2252 }
2253
2254 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2255 {
2256         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2257         ndr->depth++;
2258         ndr_print_uint32(ndr, "version", r->version);
2259         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2260         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2261         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2262         ndr->depth--;
2263 }
2264
2265 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2266 {
2267         uint32_t cntr_meta_data_0;
2268         if (ndr_flags & NDR_SCALARS) {
2269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2270                 NDR_CHECK(ndr_push_align(ndr, 8));
2271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2272                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2273                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2274                 }
2275         }
2276         if (ndr_flags & NDR_BUFFERS) {
2277         }
2278         return NDR_ERR_SUCCESS;
2279 }
2280
2281 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2282 {
2283         uint32_t cntr_meta_data_0;
2284         TALLOC_CTX *_mem_save_meta_data_0;
2285         if (ndr_flags & NDR_SCALARS) {
2286                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2287                 NDR_CHECK(ndr_pull_align(ndr, 8));
2288                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2289                 if (r->count > 1048576) {
2290                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2291                 }
2292                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2293                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2294                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2295                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2296                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2297                 }
2298                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2299                 if (r->meta_data) {
2300                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2301                 }
2302         }
2303         if (ndr_flags & NDR_BUFFERS) {
2304         }
2305         return NDR_ERR_SUCCESS;
2306 }
2307
2308 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2309 {
2310         uint32_t cntr_meta_data_0;
2311         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2312         ndr->depth++;
2313         ndr_print_uint32(ndr, "count", r->count);
2314         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2315         ndr->depth++;
2316         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2317                 char *idx_0=NULL;
2318                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2319                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2320                         free(idx_0);
2321                 }
2322         }
2323         ndr->depth--;
2324         ndr->depth--;
2325 }
2326
2327 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2328 {
2329         if (ndr_flags & NDR_SCALARS) {
2330                 NDR_CHECK(ndr_push_align(ndr, 4));
2331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2332                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2335                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2336         }
2337         if (ndr_flags & NDR_BUFFERS) {
2338                 if (r->next_object) {
2339                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2340                 }
2341                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2342                 if (r->parent_object_guid) {
2343                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2344                 }
2345                 if (r->meta_data_ctr) {
2346                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2347                 }
2348         }
2349         return NDR_ERR_SUCCESS;
2350 }
2351
2352 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2353 {
2354         uint32_t _ptr_next_object;
2355         TALLOC_CTX *_mem_save_next_object_0;
2356         uint32_t _ptr_parent_object_guid;
2357         TALLOC_CTX *_mem_save_parent_object_guid_0;
2358         uint32_t _ptr_meta_data_ctr;
2359         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2360         if (ndr_flags & NDR_SCALARS) {
2361                 NDR_CHECK(ndr_pull_align(ndr, 4));
2362                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2363                 if (_ptr_next_object) {
2364                         NDR_PULL_ALLOC(ndr, r->next_object);
2365                 } else {
2366                         r->next_object = NULL;
2367                 }
2368                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2371                 if (_ptr_parent_object_guid) {
2372                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2373                 } else {
2374                         r->parent_object_guid = NULL;
2375                 }
2376                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2377                 if (_ptr_meta_data_ctr) {
2378                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2379                 } else {
2380                         r->meta_data_ctr = NULL;
2381                 }
2382         }
2383         if (ndr_flags & NDR_BUFFERS) {
2384                 if (r->next_object) {
2385                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2386                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2387                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2388                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2389                 }
2390                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2391                 if (r->parent_object_guid) {
2392                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2393                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2394                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2395                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2396                 }
2397                 if (r->meta_data_ctr) {
2398                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2399                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2400                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2401                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2402                 }
2403         }
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2408 {
2409         if (ndr_flags & NDR_SCALARS) {
2410                 NDR_CHECK(ndr_push_align(ndr, 8));
2411                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2412                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2414                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2415                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2416                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2417                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2418                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2423         }
2424         if (ndr_flags & NDR_BUFFERS) {
2425                 if (r->naming_context) {
2426                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2427                 }
2428                 if (r->uptodateness_vector) {
2429                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2430                 }
2431                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2432                 if (r->first_object) {
2433                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2434                 }
2435         }
2436         return NDR_ERR_SUCCESS;
2437 }
2438
2439 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2440 {
2441         uint32_t _ptr_naming_context;
2442         TALLOC_CTX *_mem_save_naming_context_0;
2443         uint32_t _ptr_uptodateness_vector;
2444         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2445         uint32_t _ptr_first_object;
2446         TALLOC_CTX *_mem_save_first_object_0;
2447         if (ndr_flags & NDR_SCALARS) {
2448                 NDR_CHECK(ndr_pull_align(ndr, 8));
2449                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2450                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2452                 if (_ptr_naming_context) {
2453                         NDR_PULL_ALLOC(ndr, r->naming_context);
2454                 } else {
2455                         r->naming_context = NULL;
2456                 }
2457                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2458                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2460                 if (_ptr_uptodateness_vector) {
2461                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2462                 } else {
2463                         r->uptodateness_vector = NULL;
2464                 }
2465                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2466                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2469                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2470                 if (_ptr_first_object) {
2471                         NDR_PULL_ALLOC(ndr, r->first_object);
2472                 } else {
2473                         r->first_object = NULL;
2474                 }
2475                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2476         }
2477         if (ndr_flags & NDR_BUFFERS) {
2478                 if (r->naming_context) {
2479                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2480                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2481                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2482                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2483                 }
2484                 if (r->uptodateness_vector) {
2485                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2486                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2487                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2489                 }
2490                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2491                 if (r->first_object) {
2492                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2493                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2494                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2496                 }
2497         }
2498         return NDR_ERR_SUCCESS;
2499 }
2500
2501 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2502 {
2503         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2504         ndr->depth++;
2505         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2506         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2507         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2508         ndr->depth++;
2509         if (r->naming_context) {
2510                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2511         }
2512         ndr->depth--;
2513         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2514         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2515         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2516         ndr->depth++;
2517         if (r->uptodateness_vector) {
2518                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2519         }
2520         ndr->depth--;
2521         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2522         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2523         ndr_print_uint32(ndr, "object_count", r->object_count);
2524         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);
2525         ndr_print_ptr(ndr, "first_object", r->first_object);
2526         ndr->depth++;
2527         if (r->first_object) {
2528                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2529         }
2530         ndr->depth--;
2531         ndr_print_uint32(ndr, "more_data", r->more_data);
2532         ndr->depth--;
2533 }
2534
2535 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2536 {
2537         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2538 }
2539
2540 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2541 {
2542         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2543         return NDR_ERR_SUCCESS;
2544 }
2545
2546 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2547 {
2548         uint32_t v;
2549         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2550         *r = v;
2551         return NDR_ERR_SUCCESS;
2552 }
2553
2554 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2555 {
2556         ndr_print_uint32(ndr, name, r);
2557         ndr->depth++;
2558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2559         ndr->depth--;
2560 }
2561
2562 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2563 {
2564         if (ndr_flags & NDR_SCALARS) {
2565                 NDR_CHECK(ndr_push_align(ndr, 8));
2566                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2567                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2568                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2569                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2570                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2571                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2572         }
2573         if (ndr_flags & NDR_BUFFERS) {
2574                 if (r->identifier) {
2575                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2576                 }
2577                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2578         }
2579         return NDR_ERR_SUCCESS;
2580 }
2581
2582 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2583 {
2584         uint32_t _ptr_identifier;
2585         TALLOC_CTX *_mem_save_identifier_0;
2586         if (ndr_flags & NDR_SCALARS) {
2587                 NDR_CHECK(ndr_pull_align(ndr, 8));
2588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2589                 if (_ptr_identifier) {
2590                         NDR_PULL_ALLOC(ndr, r->identifier);
2591                 } else {
2592                         r->identifier = NULL;
2593                 }
2594                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2595                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2596                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2597                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2598                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2599         }
2600         if (ndr_flags & NDR_BUFFERS) {
2601                 if (r->identifier) {
2602                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2603                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2604                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2606                 }
2607                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2608         }
2609         return NDR_ERR_SUCCESS;
2610 }
2611
2612 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2613 {
2614         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2615         ndr->depth++;
2616         ndr_print_ptr(ndr, "identifier", r->identifier);
2617         ndr->depth++;
2618         if (r->identifier) {
2619                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2620         }
2621         ndr->depth--;
2622         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2623         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2624         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2625         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2626         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2627         ndr->depth--;
2628 }
2629
2630 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2631 {
2632         uint32_t cntr_linked_attributes_1;
2633         if (ndr_flags & NDR_SCALARS) {
2634                 NDR_CHECK(ndr_push_align(ndr, 8));
2635                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2636                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2638                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2639                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2641                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2642                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2650                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2651                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2652         }
2653         if (ndr_flags & NDR_BUFFERS) {
2654                 if (r->naming_context) {
2655                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2656                 }
2657                 if (r->uptodateness_vector) {
2658                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2659                 }
2660                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2661                 if (r->first_object) {
2662                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2663                 }
2664                 if (r->linked_attributes) {
2665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2666                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2667                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2668                         }
2669                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2670                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2671                         }
2672                 }
2673         }
2674         return NDR_ERR_SUCCESS;
2675 }
2676
2677 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2678 {
2679         uint32_t _ptr_naming_context;
2680         TALLOC_CTX *_mem_save_naming_context_0;
2681         uint32_t _ptr_uptodateness_vector;
2682         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2683         uint32_t _ptr_first_object;
2684         TALLOC_CTX *_mem_save_first_object_0;
2685         uint32_t _ptr_linked_attributes;
2686         uint32_t cntr_linked_attributes_1;
2687         TALLOC_CTX *_mem_save_linked_attributes_0;
2688         TALLOC_CTX *_mem_save_linked_attributes_1;
2689         if (ndr_flags & NDR_SCALARS) {
2690                 NDR_CHECK(ndr_pull_align(ndr, 8));
2691                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2692                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2694                 if (_ptr_naming_context) {
2695                         NDR_PULL_ALLOC(ndr, r->naming_context);
2696                 } else {
2697                         r->naming_context = NULL;
2698                 }
2699                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2700                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2701                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2702                 if (_ptr_uptodateness_vector) {
2703                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2704                 } else {
2705                         r->uptodateness_vector = NULL;
2706                 }
2707                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2708                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2712                 if (_ptr_first_object) {
2713                         NDR_PULL_ALLOC(ndr, r->first_object);
2714                 } else {
2715                         r->first_object = NULL;
2716                 }
2717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
2719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
2720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
2721                 if (r->linked_attributes_count > 1048576) {
2722                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2723                 }
2724                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
2725                 if (_ptr_linked_attributes) {
2726                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
2727                 } else {
2728                         r->linked_attributes = NULL;
2729                 }
2730                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
2731         }
2732         if (ndr_flags & NDR_BUFFERS) {
2733                 if (r->naming_context) {
2734                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2735                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2736                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2738                 }
2739                 if (r->uptodateness_vector) {
2740                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2741                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2742                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2743                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2744                 }
2745                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2746                 if (r->first_object) {
2747                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2748                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2749                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2751                 }
2752                 if (r->linked_attributes) {
2753                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2754                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
2756                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
2757                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2758                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2759                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2760                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2761                         }
2762                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2763                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2764                         }
2765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
2766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
2767                 }
2768                 if (r->linked_attributes) {
2769                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
2770                 }
2771         }
2772         return NDR_ERR_SUCCESS;
2773 }
2774
2775 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
2776 {
2777         uint32_t cntr_linked_attributes_1;
2778         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
2779         ndr->depth++;
2780         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2781         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2782         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2783         ndr->depth++;
2784         if (r->naming_context) {
2785                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2786         }
2787         ndr->depth--;
2788         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2789         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2790         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2791         ndr->depth++;
2792         if (r->uptodateness_vector) {
2793                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2794         }
2795         ndr->depth--;
2796         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2797         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2798         ndr_print_uint32(ndr, "object_count", r->object_count);
2799         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);
2800         ndr_print_ptr(ndr, "first_object", r->first_object);
2801         ndr->depth++;
2802         if (r->first_object) {
2803                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2804         }
2805         ndr->depth--;
2806         ndr_print_uint32(ndr, "more_data", r->more_data);
2807         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
2808         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
2809         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
2810         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
2811         ndr->depth++;
2812         if (r->linked_attributes) {
2813                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
2814                 ndr->depth++;
2815                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
2816                         char *idx_1=NULL;
2817                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
2818                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
2819                                 free(idx_1);
2820                         }
2821                 }
2822                 ndr->depth--;
2823         }
2824         ndr->depth--;
2825         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
2826         ndr->depth--;
2827 }
2828
2829 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
2830 {
2831         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
2832 }
2833
2834 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
2835 {
2836         if (ndr_flags & NDR_SCALARS) {
2837                 NDR_CHECK(ndr_push_align(ndr, 1));
2838                 {
2839                         struct ndr_push *_ndr_ctr1;
2840                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
2841                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
2842                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
2843                 }
2844         }
2845         if (ndr_flags & NDR_BUFFERS) {
2846         }
2847         return NDR_ERR_SUCCESS;
2848 }
2849
2850 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
2851 {
2852         if (ndr_flags & NDR_SCALARS) {
2853                 NDR_CHECK(ndr_pull_align(ndr, 1));
2854                 {
2855                         struct ndr_pull *_ndr_ctr1;
2856                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
2857                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
2858                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
2859                 }
2860         }
2861         if (ndr_flags & NDR_BUFFERS) {
2862         }
2863         return NDR_ERR_SUCCESS;
2864 }
2865
2866 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
2867 {
2868         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
2869         ndr->depth++;
2870         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
2871         ndr->depth--;
2872 }
2873
2874 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
2875 {
2876         if (ndr_flags & NDR_SCALARS) {
2877                 NDR_CHECK(ndr_push_align(ndr, 1));
2878                 {
2879                         struct ndr_push *_ndr_ctr6;
2880                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
2881                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
2882                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
2883                 }
2884         }
2885         if (ndr_flags & NDR_BUFFERS) {
2886         }
2887         return NDR_ERR_SUCCESS;
2888 }
2889
2890 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
2891 {
2892         if (ndr_flags & NDR_SCALARS) {
2893                 NDR_CHECK(ndr_pull_align(ndr, 1));
2894                 {
2895                         struct ndr_pull *_ndr_ctr6;
2896                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
2897                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
2898                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
2899                 }
2900         }
2901         if (ndr_flags & NDR_BUFFERS) {
2902         }
2903         return NDR_ERR_SUCCESS;
2904 }
2905
2906 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
2907 {
2908         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
2909         ndr->depth++;
2910         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
2911         ndr->depth--;
2912 }
2913
2914 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
2915 {
2916         uint32_t _ptr_ts;
2917         TALLOC_CTX *_mem_save_ts_0;
2918         if (ndr_flags & NDR_SCALARS) {
2919                 NDR_CHECK(ndr_pull_align(ndr, 4));
2920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
2921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
2922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
2923                 if (_ptr_ts) {
2924                         NDR_PULL_ALLOC(ndr, r->ts);
2925                 } else {
2926                         r->ts = NULL;
2927                 }
2928         }
2929         if (ndr_flags & NDR_BUFFERS) {
2930                 if (r->ts) {
2931                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
2932                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
2933                         {
2934                                 struct ndr_pull *_ndr_ts;
2935                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
2936                                 {
2937                                         struct ndr_pull *_ndr_ts_compressed;
2938                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2939                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
2940                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2941                                 }
2942                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
2943                         }
2944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
2945                 }
2946         }
2947         return NDR_ERR_SUCCESS;
2948 }
2949
2950 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
2951 {
2952         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
2953         ndr->depth++;
2954         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
2955         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
2956         ndr_print_ptr(ndr, "ts", r->ts);
2957         ndr->depth++;
2958         if (r->ts) {
2959                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
2960         }
2961         ndr->depth--;
2962         ndr->depth--;
2963 }
2964
2965 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
2966 {
2967         uint32_t _ptr_ts;
2968         TALLOC_CTX *_mem_save_ts_0;
2969         if (ndr_flags & NDR_SCALARS) {
2970                 NDR_CHECK(ndr_pull_align(ndr, 4));
2971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
2972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
2973                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
2974                 if (_ptr_ts) {
2975                         NDR_PULL_ALLOC(ndr, r->ts);
2976                 } else {
2977                         r->ts = NULL;
2978                 }
2979         }
2980         if (ndr_flags & NDR_BUFFERS) {
2981                 if (r->ts) {
2982                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
2983                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
2984                         {
2985                                 struct ndr_pull *_ndr_ts;
2986                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
2987                                 {
2988                                         struct ndr_pull *_ndr_ts_compressed;
2989                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2990                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
2991                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2992                                 }
2993                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
2994                         }
2995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
2996                 }
2997         }
2998         return NDR_ERR_SUCCESS;
2999 }
3000
3001 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3002 {
3003         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3004         ndr->depth++;
3005         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3006         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3007         ndr_print_ptr(ndr, "ts", r->ts);
3008         ndr->depth++;
3009         if (r->ts) {
3010                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3011         }
3012         ndr->depth--;
3013         ndr->depth--;
3014 }
3015
3016 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3017 {
3018         uint32_t _ptr_ts;
3019         TALLOC_CTX *_mem_save_ts_0;
3020         if (ndr_flags & NDR_SCALARS) {
3021                 NDR_CHECK(ndr_pull_align(ndr, 4));
3022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3024                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3025                 if (_ptr_ts) {
3026                         NDR_PULL_ALLOC(ndr, r->ts);
3027                 } else {
3028                         r->ts = NULL;
3029                 }
3030         }
3031         if (ndr_flags & NDR_BUFFERS) {
3032                 if (r->ts) {
3033                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3034                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3035                         {
3036                                 struct ndr_pull *_ndr_ts;
3037                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3038                                 {
3039                                         struct ndr_pull *_ndr_ts_compressed;
3040                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3041                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3042                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3043                                 }
3044                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3045                         }
3046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3047                 }
3048         }
3049         return NDR_ERR_SUCCESS;
3050 }
3051
3052 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3053 {
3054         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3055         ndr->depth++;
3056         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3057         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3058         ndr_print_ptr(ndr, "ts", r->ts);
3059         ndr->depth++;
3060         if (r->ts) {
3061                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3062         }
3063         ndr->depth--;
3064         ndr->depth--;
3065 }
3066
3067 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3068 {
3069         uint32_t _ptr_ts;
3070         TALLOC_CTX *_mem_save_ts_0;
3071         if (ndr_flags & NDR_SCALARS) {
3072                 NDR_CHECK(ndr_pull_align(ndr, 4));
3073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3076                 if (_ptr_ts) {
3077                         NDR_PULL_ALLOC(ndr, r->ts);
3078                 } else {
3079                         r->ts = NULL;
3080                 }
3081         }
3082         if (ndr_flags & NDR_BUFFERS) {
3083                 if (r->ts) {
3084                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3085                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3086                         {
3087                                 struct ndr_pull *_ndr_ts;
3088                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3089                                 {
3090                                         struct ndr_pull *_ndr_ts_compressed;
3091                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3092                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3093                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3094                                 }
3095                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3096                         }
3097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3098                 }
3099         }
3100         return NDR_ERR_SUCCESS;
3101 }
3102
3103 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3104 {
3105         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3106         ndr->depth++;
3107         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3108         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3109         ndr_print_ptr(ndr, "ts", r->ts);
3110         ndr->depth++;
3111         if (r->ts) {
3112                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3113         }
3114         ndr->depth--;
3115         ndr->depth--;
3116 }
3117
3118 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3119 {
3120         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
3121         return NDR_ERR_SUCCESS;
3122 }
3123
3124 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3125 {
3126         uint16_t v;
3127         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
3128         *r = v;
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3133 {
3134         const char *val = NULL;
3135
3136         switch (r) {
3137                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3138                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3139         }
3140         ndr_print_enum(ndr, name, "ENUM", val, r);
3141 }
3142
3143 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3144 {
3145         {
3146                 uint32_t _flags_save_UNION = ndr->flags;
3147                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3148                 if (ndr_flags & NDR_SCALARS) {
3149                         int level = ndr_push_get_switch_value(ndr, r);
3150                         switch (level) {
3151                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3152                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3153                                 break; }
3154
3155                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3156                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3157                                 break; }
3158
3159                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3160                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3161                                 break; }
3162
3163                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3164                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3165                                 break; }
3166
3167                                 default:
3168                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3169                         }
3170                 }
3171                 if (ndr_flags & NDR_BUFFERS) {
3172                         int level = ndr_push_get_switch_value(ndr, r);
3173                         switch (level) {
3174                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3175                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3176                                 break;
3177
3178                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3179                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3180                                 break;
3181
3182                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3183                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3184                                 break;
3185
3186                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3187                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3188                                 break;
3189
3190                                 default:
3191                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3192                         }
3193                 }
3194                 ndr->flags = _flags_save_UNION;
3195         }
3196         return NDR_ERR_SUCCESS;
3197 }
3198
3199 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3200 {
3201         int level;
3202         {
3203                 uint32_t _flags_save_UNION = ndr->flags;
3204                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3205                 level = ndr_pull_get_switch_value(ndr, r);
3206                 if (ndr_flags & NDR_SCALARS) {
3207                         switch (level) {
3208                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3209                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3210                                 break; }
3211
3212                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3213                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3214                                 break; }
3215
3216                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3217                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3218                                 break; }
3219
3220                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3221                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3222                                 break; }
3223
3224                                 default:
3225                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3226                         }
3227                 }
3228                 if (ndr_flags & NDR_BUFFERS) {
3229                         switch (level) {
3230                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3231                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3232                                 break;
3233
3234                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3235                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3236                                 break;
3237
3238                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3239                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3240                                 break;
3241
3242                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3243                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3244                                 break;
3245
3246                                 default:
3247                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3248                         }
3249                 }
3250                 ndr->flags = _flags_save_UNION;
3251         }
3252         return NDR_ERR_SUCCESS;
3253 }
3254
3255 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3256 {
3257         int level;
3258         {
3259                 uint32_t _flags_save_UNION = ndr->flags;
3260                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3261                 level = ndr_print_get_switch_value(ndr, r);
3262                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3263                 switch (level) {
3264                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3265                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3266                         break;
3267
3268                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3269                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3270                         break;
3271
3272                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3273                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3274                         break;
3275
3276                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3277                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3278                         break;
3279
3280                         default:
3281                                 ndr_print_bad_level(ndr, name, level);
3282                 }
3283                 ndr->flags = _flags_save_UNION;
3284         }
3285 }
3286
3287 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3288 {
3289         if (ndr_flags & NDR_SCALARS) {
3290                 NDR_CHECK(ndr_push_align(ndr, 4));
3291                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3292         }
3293         if (ndr_flags & NDR_BUFFERS) {
3294                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3295         }
3296         return NDR_ERR_SUCCESS;
3297 }
3298
3299 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3300 {
3301         if (ndr_flags & NDR_SCALARS) {
3302                 NDR_CHECK(ndr_pull_align(ndr, 4));
3303                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3304         }
3305         if (ndr_flags & NDR_BUFFERS) {
3306                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3307         }
3308         return NDR_ERR_SUCCESS;
3309 }
3310
3311 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3312 {
3313         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3314         ndr->depth++;
3315         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3316         ndr->depth--;
3317 }
3318
3319 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3320 {
3321         if (ndr_flags & NDR_SCALARS) {
3322                 NDR_CHECK(ndr_push_align(ndr, 4));
3323                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3324                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3325                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3326                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3327         }
3328         if (ndr_flags & NDR_BUFFERS) {
3329                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3330         }
3331         return NDR_ERR_SUCCESS;
3332 }
3333
3334 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3335 {
3336         if (ndr_flags & NDR_SCALARS) {
3337                 NDR_CHECK(ndr_pull_align(ndr, 4));
3338                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3339                 if (r->level < 0 || r->level > 6) {
3340                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3341                 }
3342                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3343                 if (r->type < 2 || r->type > 3) {
3344                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3345                 }
3346                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3347                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3348         }
3349         if (ndr_flags & NDR_BUFFERS) {
3350                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3351         }
3352         return NDR_ERR_SUCCESS;
3353 }
3354
3355 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3356 {
3357         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3358         ndr->depth++;
3359         ndr_print_int32(ndr, "level", r->level);
3360         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3361         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3362         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3363         ndr->depth--;
3364 }
3365
3366 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3367 {
3368         if (ndr_flags & NDR_SCALARS) {
3369                 int level = ndr_push_get_switch_value(ndr, r);
3370                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3371                 switch (level) {
3372                         case 1: {
3373                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3374                         break; }
3375
3376                         case 2: {
3377                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3378                         break; }
3379
3380                         case 6: {
3381                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3382                         break; }
3383
3384                         case 7: {
3385                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3386                         break; }
3387
3388                         default:
3389                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3390                 }
3391         }
3392         if (ndr_flags & NDR_BUFFERS) {
3393                 int level = ndr_push_get_switch_value(ndr, r);
3394                 switch (level) {
3395                         case 1:
3396                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3397                         break;
3398
3399                         case 2:
3400                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3401                         break;
3402
3403                         case 6:
3404                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3405                         break;
3406
3407                         case 7:
3408                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3409                         break;
3410
3411                         default:
3412                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3413                 }
3414         }
3415         return NDR_ERR_SUCCESS;
3416 }
3417
3418 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3419 {
3420         int level;
3421         int32_t _level;
3422         level = ndr_pull_get_switch_value(ndr, r);
3423         if (ndr_flags & NDR_SCALARS) {
3424                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3425                 if (_level != level) {
3426                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3427                 }
3428                 switch (level) {
3429                         case 1: {
3430                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3431                         break; }
3432
3433                         case 2: {
3434                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3435                         break; }
3436
3437                         case 6: {
3438                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3439                         break; }
3440
3441                         case 7: {
3442                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3443                         break; }
3444
3445                         default:
3446                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3447                 }
3448         }
3449         if (ndr_flags & NDR_BUFFERS) {
3450                 switch (level) {
3451                         case 1:
3452                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3453                         break;
3454
3455                         case 2:
3456                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3457                         break;
3458
3459                         case 6:
3460                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3461                         break;
3462
3463                         case 7:
3464                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3465                         break;
3466
3467                         default:
3468                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3469                 }
3470         }
3471         return NDR_ERR_SUCCESS;
3472 }
3473
3474 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3475 {
3476         int level;
3477         level = ndr_print_get_switch_value(ndr, r);
3478         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3479         switch (level) {
3480                 case 1:
3481                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3482                 break;
3483
3484                 case 2:
3485                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3486                 break;
3487
3488                 case 6:
3489                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3490                 break;
3491
3492                 case 7:
3493                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3494                 break;
3495
3496                 default:
3497                         ndr_print_bad_level(ndr, name, level);
3498         }
3499 }
3500
3501 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3502 {
3503         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3504         return NDR_ERR_SUCCESS;
3505 }
3506
3507 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3508 {
3509         uint32_t v;
3510         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3511         *r = v;
3512         return NDR_ERR_SUCCESS;
3513 }
3514
3515 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3516 {
3517         ndr_print_uint32(ndr, name, r);
3518         ndr->depth++;
3519         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION, r);
3520         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK", DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK, r);
3521         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE, r);
3522         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE, r);
3523         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE", DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE, r);
3524         ndr->depth--;
3525 }
3526
3527 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3528 {
3529         if (ndr_flags & NDR_SCALARS) {
3530                 NDR_CHECK(ndr_push_align(ndr, 4));
3531                 if (r->naming_context == NULL) {
3532                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3533                 }
3534                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3535                 if (r->dest_dsa_dns_name == NULL) {
3536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3537                 }
3538                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3539                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3540                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
3541         }
3542         if (ndr_flags & NDR_BUFFERS) {
3543                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3547                 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));
3548         }
3549         return NDR_ERR_SUCCESS;
3550 }
3551
3552 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3553 {
3554         uint32_t _ptr_naming_context;
3555         TALLOC_CTX *_mem_save_naming_context_0;
3556         uint32_t _ptr_dest_dsa_dns_name;
3557         if (ndr_flags & NDR_SCALARS) {
3558                 NDR_CHECK(ndr_pull_align(ndr, 4));
3559                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3560                 if (_ptr_naming_context) {
3561                         NDR_PULL_ALLOC(ndr, r->naming_context);
3562                 } else {
3563                         r->naming_context = NULL;
3564                 }
3565                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3566                 if (_ptr_dest_dsa_dns_name) {
3567                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3568                 } else {
3569                         r->dest_dsa_dns_name = NULL;
3570                 }
3571                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3572                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
3573         }
3574         if (ndr_flags & NDR_BUFFERS) {
3575                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3576                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3577                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3579                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3580                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3581                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3582                         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));
3583                 }
3584                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3585                 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));
3586         }
3587         return NDR_ERR_SUCCESS;
3588 }
3589
3590 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3591 {
3592         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3593         ndr->depth++;
3594         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3595         ndr->depth++;
3596         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3597         ndr->depth--;
3598         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3599         ndr->depth++;
3600         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3601         ndr->depth--;
3602         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3603         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "options", r->options);
3604         ndr->depth--;
3605 }
3606
3607 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3608 {
3609         if (ndr_flags & NDR_SCALARS) {
3610                 int level = ndr_push_get_switch_value(ndr, r);
3611                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3612                 switch (level) {
3613                         case 1: {
3614                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3615                         break; }
3616
3617                         default:
3618                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3619                 }
3620         }
3621         if (ndr_flags & NDR_BUFFERS) {
3622                 int level = ndr_push_get_switch_value(ndr, r);
3623                 switch (level) {
3624                         case 1:
3625                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3626                         break;
3627
3628                         default:
3629                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3630                 }
3631         }
3632         return NDR_ERR_SUCCESS;
3633 }
3634
3635 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3636 {
3637         int level;
3638         int32_t _level;
3639         level = ndr_pull_get_switch_value(ndr, r);
3640         if (ndr_flags & NDR_SCALARS) {
3641                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3642                 if (_level != level) {
3643                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3644                 }
3645                 switch (level) {
3646                         case 1: {
3647                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3648                         break; }
3649
3650                         default:
3651                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3652                 }
3653         }
3654         if (ndr_flags & NDR_BUFFERS) {
3655                 switch (level) {
3656                         case 1:
3657                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3658                         break;
3659
3660                         default:
3661                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3662                 }
3663         }
3664         return NDR_ERR_SUCCESS;
3665 }
3666
3667 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3668 {
3669         int level;
3670         level = ndr_print_get_switch_value(ndr, r);
3671         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3672         switch (level) {
3673                 case 1:
3674                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3675                 break;
3676
3677                 default:
3678                         ndr_print_bad_level(ndr, name, level);
3679         }
3680 }
3681
3682 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3683 {
3684         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3685         return NDR_ERR_SUCCESS;
3686 }
3687
3688 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3689 {
3690         uint32_t v;
3691         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3692         *r = v;
3693         return NDR_ERR_SUCCESS;
3694 }
3695
3696 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3697 {
3698         ndr_print_uint32(ndr, name, r);
3699         ndr->depth++;
3700         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
3701         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
3702         ndr->depth--;
3703 }
3704
3705 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
3706 {
3707         if (ndr_flags & NDR_SCALARS) {
3708                 NDR_CHECK(ndr_push_align(ndr, 4));
3709                 if (r->naming_context == NULL) {
3710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3711                 }
3712                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3714                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3715                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
3716         }
3717         if (ndr_flags & NDR_BUFFERS) {
3718                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3719                 if (r->source_dsa_address) {
3720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3723                         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));
3724                 }
3725         }
3726         return NDR_ERR_SUCCESS;
3727 }
3728
3729 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
3730 {
3731         uint32_t _ptr_naming_context;
3732         TALLOC_CTX *_mem_save_naming_context_0;
3733         uint32_t _ptr_source_dsa_address;
3734         TALLOC_CTX *_mem_save_source_dsa_address_0;
3735         if (ndr_flags & NDR_SCALARS) {
3736                 NDR_CHECK(ndr_pull_align(ndr, 4));
3737                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3738                 if (_ptr_naming_context) {
3739                         NDR_PULL_ALLOC(ndr, r->naming_context);
3740                 } else {
3741                         r->naming_context = NULL;
3742                 }
3743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
3744                 if (_ptr_source_dsa_address) {
3745                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
3746                 } else {
3747                         r->source_dsa_address = NULL;
3748                 }
3749                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3750                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
3751         }
3752         if (ndr_flags & NDR_BUFFERS) {
3753                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3754                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3755                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3757                 if (r->source_dsa_address) {
3758                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
3759                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
3760                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
3761                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
3762                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
3763                                 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));
3764                         }
3765                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
3766                         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));
3767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
3768                 }
3769         }
3770         return NDR_ERR_SUCCESS;
3771 }
3772
3773 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
3774 {
3775         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
3776         ndr->depth++;
3777         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3778         ndr->depth++;
3779         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3780         ndr->depth--;
3781         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
3782         ndr->depth++;
3783         if (r->source_dsa_address) {
3784                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
3785         }
3786         ndr->depth--;
3787         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
3788         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
3789         ndr->depth--;
3790 }
3791
3792 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
3793 {
3794         if (ndr_flags & NDR_SCALARS) {
3795                 NDR_CHECK(ndr_push_align(ndr, 4));
3796                 if (r->naming_context == NULL) {
3797                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3798                 }
3799                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
3801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
3802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3803                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3804                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
3805         }
3806         if (ndr_flags & NDR_BUFFERS) {
3807                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3808                 if (r->source_dsa_dn) {
3809                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
3810                 }
3811                 if (r->transport_dn) {
3812                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
3813                 }
3814                 if (r->source_dsa_address) {
3815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3818                         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));
3819                 }
3820         }
3821         return NDR_ERR_SUCCESS;
3822 }
3823
3824 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
3825 {
3826         uint32_t _ptr_naming_context;
3827         TALLOC_CTX *_mem_save_naming_context_0;
3828         uint32_t _ptr_source_dsa_dn;
3829         TALLOC_CTX *_mem_save_source_dsa_dn_0;
3830         uint32_t _ptr_transport_dn;
3831         TALLOC_CTX *_mem_save_transport_dn_0;
3832         uint32_t _ptr_source_dsa_address;
3833         TALLOC_CTX *_mem_save_source_dsa_address_0;
3834         if (ndr_flags & NDR_SCALARS) {
3835                 NDR_CHECK(ndr_pull_align(ndr, 4));
3836                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3837                 if (_ptr_naming_context) {
3838                         NDR_PULL_ALLOC(ndr, r->naming_context);
3839                 } else {
3840                         r->naming_context = NULL;
3841                 }
3842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
3843                 if (_ptr_source_dsa_dn) {
3844                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
3845                 } else {
3846                         r->source_dsa_dn = NULL;
3847                 }
3848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
3849                 if (_ptr_transport_dn) {
3850                         NDR_PULL_ALLOC(ndr, r->transport_dn);
3851                 } else {
3852                         r->transport_dn = NULL;
3853                 }
3854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
3855                 if (_ptr_source_dsa_address) {
3856                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
3857                 } else {
3858                         r->source_dsa_address = NULL;
3859                 }
3860                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3861                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
3862         }
3863         if (ndr_flags & NDR_BUFFERS) {
3864                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3865                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3866                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3867                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3868                 if (r->source_dsa_dn) {
3869                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
3870                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
3871                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
3872                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
3873                 }
3874                 if (r->transport_dn) {
3875                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
3876                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
3877                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
3878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
3879                 }
3880                 if (r->source_dsa_address) {
3881                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
3882                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
3883                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
3884                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
3885                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
3886                                 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));
3887                         }
3888                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
3889                         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));
3890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
3891                 }
3892         }
3893         return NDR_ERR_SUCCESS;
3894 }
3895
3896 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
3897 {
3898         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
3899         ndr->depth++;
3900         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3901         ndr->depth++;
3902         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3903         ndr->depth--;
3904         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
3905         ndr->depth++;
3906         if (r->source_dsa_dn) {
3907                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
3908         }
3909         ndr->depth--;
3910         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
3911         ndr->depth++;
3912         if (r->transport_dn) {
3913                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
3914         }
3915         ndr->depth--;
3916         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
3917         ndr->depth++;
3918         if (r->source_dsa_address) {
3919                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
3920         }
3921         ndr->depth--;
3922         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
3923         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
3924         ndr->depth--;
3925 }
3926
3927 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
3928 {
3929         if (ndr_flags & NDR_SCALARS) {
3930                 int level = ndr_push_get_switch_value(ndr, r);
3931                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3932                 switch (level) {
3933                         case 1: {
3934                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
3935                         break; }
3936
3937                         case 2: {
3938                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
3939                         break; }
3940
3941                         default:
3942                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3943                 }
3944         }
3945         if (ndr_flags & NDR_BUFFERS) {
3946                 int level = ndr_push_get_switch_value(ndr, r);
3947                 switch (level) {
3948                         case 1:
3949                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
3950                         break;
3951
3952                         case 2:
3953                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
3954                         break;
3955
3956                         default:
3957                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3958                 }
3959         }
3960         return NDR_ERR_SUCCESS;
3961 }
3962
3963 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
3964 {
3965         int level;
3966         int32_t _level;
3967         level = ndr_pull_get_switch_value(ndr, r);
3968         if (ndr_flags & NDR_SCALARS) {
3969                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3970                 if (_level != level) {
3971                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3972                 }
3973                 switch (level) {
3974                         case 1: {
3975                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
3976                         break; }
3977
3978                         case 2: {
3979                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
3980                         break; }
3981
3982                         default:
3983                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3984                 }
3985         }
3986         if (ndr_flags & NDR_BUFFERS) {
3987                 switch (level) {
3988                         case 1:
3989                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
3990                         break;
3991
3992                         case 2:
3993                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
3994                         break;
3995
3996                         default:
3997                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3998                 }
3999         }
4000         return NDR_ERR_SUCCESS;
4001 }
4002
4003 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4004 {
4005         int level;
4006         level = ndr_print_get_switch_value(ndr, r);
4007         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4008         switch (level) {
4009                 case 1:
4010                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4011                 break;
4012
4013                 case 2:
4014                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4015                 break;
4016
4017                 default:
4018                         ndr_print_bad_level(ndr, name, level);
4019         }
4020 }
4021
4022 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4023 {
4024         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4025         return NDR_ERR_SUCCESS;
4026 }
4027
4028 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4029 {
4030         uint32_t v;
4031         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4032         *r = v;
4033         return NDR_ERR_SUCCESS;
4034 }
4035
4036 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4037 {
4038         ndr_print_uint32(ndr, name, r);
4039         ndr->depth++;
4040         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4041         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4042         ndr->depth--;
4043 }
4044
4045 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4046 {
4047         if (ndr_flags & NDR_SCALARS) {
4048                 NDR_CHECK(ndr_push_align(ndr, 4));
4049                 if (r->naming_context == NULL) {
4050                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4051                 }
4052                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4054                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->options));
4055         }
4056         if (ndr_flags & NDR_BUFFERS) {
4057                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4058                 if (r->source_dsa_address) {
4059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4062                         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));
4063                 }
4064         }
4065         return NDR_ERR_SUCCESS;
4066 }
4067
4068 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4069 {
4070         uint32_t _ptr_naming_context;
4071         TALLOC_CTX *_mem_save_naming_context_0;
4072         uint32_t _ptr_source_dsa_address;
4073         TALLOC_CTX *_mem_save_source_dsa_address_0;
4074         if (ndr_flags & NDR_SCALARS) {
4075                 NDR_CHECK(ndr_pull_align(ndr, 4));
4076                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4077                 if (_ptr_naming_context) {
4078                         NDR_PULL_ALLOC(ndr, r->naming_context);
4079                 } else {
4080                         r->naming_context = NULL;
4081                 }
4082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4083                 if (_ptr_source_dsa_address) {
4084                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4085                 } else {
4086                         r->source_dsa_address = NULL;
4087                 }
4088                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->options));
4089         }
4090         if (ndr_flags & NDR_BUFFERS) {
4091                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4092                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4093                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4095                 if (r->source_dsa_address) {
4096                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4097                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4098                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4099                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4100                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4101                                 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));
4102                         }
4103                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4104                         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));
4105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4106                 }
4107         }
4108         return NDR_ERR_SUCCESS;
4109 }
4110
4111 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4112 {
4113         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4114         ndr->depth++;
4115         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4116         ndr->depth++;
4117         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4118         ndr->depth--;
4119         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4120         ndr->depth++;
4121         if (r->source_dsa_address) {
4122                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4123         }
4124         ndr->depth--;
4125         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "options", r->options);
4126         ndr->depth--;
4127 }
4128
4129 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4130 {
4131         if (ndr_flags & NDR_SCALARS) {
4132                 int level = ndr_push_get_switch_value(ndr, r);
4133                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4134                 switch (level) {
4135                         case 1: {
4136                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4137                         break; }
4138
4139                         default:
4140                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4141                 }
4142         }
4143         if (ndr_flags & NDR_BUFFERS) {
4144                 int level = ndr_push_get_switch_value(ndr, r);
4145                 switch (level) {
4146                         case 1:
4147                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4148                         break;
4149
4150                         default:
4151                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4152                 }
4153         }
4154         return NDR_ERR_SUCCESS;
4155 }
4156
4157 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4158 {
4159         int level;
4160         int32_t _level;
4161         level = ndr_pull_get_switch_value(ndr, r);
4162         if (ndr_flags & NDR_SCALARS) {
4163                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4164                 if (_level != level) {
4165                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4166                 }
4167                 switch (level) {
4168                         case 1: {
4169                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4170                         break; }
4171
4172                         default:
4173                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4174                 }
4175         }
4176         if (ndr_flags & NDR_BUFFERS) {
4177                 switch (level) {
4178                         case 1:
4179                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4180                         break;
4181
4182                         default:
4183                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4184                 }
4185         }
4186         return NDR_ERR_SUCCESS;
4187 }
4188
4189 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4190 {
4191         int level;
4192         level = ndr_print_get_switch_value(ndr, r);
4193         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4194         switch (level) {
4195                 case 1:
4196                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4197                 break;
4198
4199                 default:
4200                         ndr_print_bad_level(ndr, name, level);
4201         }
4202 }
4203
4204 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4205 {
4206         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4207         return NDR_ERR_SUCCESS;
4208 }
4209
4210 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModifyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4211 {
4212         uint32_t v;
4213         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4214         *r = v;
4215         return NDR_ERR_SUCCESS;
4216 }
4217
4218 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4219 {
4220         ndr_print_uint32(ndr, name, r);
4221         ndr->depth++;
4222         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4223         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4224         ndr->depth--;
4225 }
4226
4227 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4228 {
4229         if (ndr_flags & NDR_SCALARS) {
4230                 NDR_CHECK(ndr_push_align(ndr, 4));
4231                 if (r->naming_context == NULL) {
4232                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4233                 }
4234                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4235                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4237                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4240                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->options));
4241         }
4242         if (ndr_flags & NDR_BUFFERS) {
4243                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4244                 if (r->source_dra_address) {
4245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4248                         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));
4249                 }
4250         }
4251         return NDR_ERR_SUCCESS;
4252 }
4253
4254 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4255 {
4256         uint32_t _ptr_naming_context;
4257         TALLOC_CTX *_mem_save_naming_context_0;
4258         uint32_t _ptr_source_dra_address;
4259         TALLOC_CTX *_mem_save_source_dra_address_0;
4260         if (ndr_flags & NDR_SCALARS) {
4261                 NDR_CHECK(ndr_pull_align(ndr, 4));
4262                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4263                 if (_ptr_naming_context) {
4264                         NDR_PULL_ALLOC(ndr, r->naming_context);
4265                 } else {
4266                         r->naming_context = NULL;
4267                 }
4268                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4270                 if (_ptr_source_dra_address) {
4271                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4272                 } else {
4273                         r->source_dra_address = NULL;
4274                 }
4275                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4278                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->options));
4279         }
4280         if (ndr_flags & NDR_BUFFERS) {
4281                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4282                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4283                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4284                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4285                 if (r->source_dra_address) {
4286                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4287                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4288                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4289                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4290                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4291                                 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));
4292                         }
4293                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4294                         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));
4295                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4296                 }
4297         }
4298         return NDR_ERR_SUCCESS;
4299 }
4300
4301 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4302 {
4303         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4304         ndr->depth++;
4305         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4306         ndr->depth++;
4307         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4308         ndr->depth--;
4309         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4310         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4311         ndr->depth++;
4312         if (r->source_dra_address) {
4313                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4314         }
4315         ndr->depth--;
4316         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4317         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4318         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4319         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "options", r->options);
4320         ndr->depth--;
4321 }
4322
4323 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4324 {
4325         if (ndr_flags & NDR_SCALARS) {
4326                 int level = ndr_push_get_switch_value(ndr, r);
4327                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4328                 switch (level) {
4329                         case 1: {
4330                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4331                         break; }
4332
4333                         default:
4334                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4335                 }
4336         }
4337         if (ndr_flags & NDR_BUFFERS) {
4338                 int level = ndr_push_get_switch_value(ndr, r);
4339                 switch (level) {
4340                         case 1:
4341                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4342                         break;
4343
4344                         default:
4345                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4346                 }
4347         }
4348         return NDR_ERR_SUCCESS;
4349 }
4350
4351 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4352 {
4353         int level;
4354         int32_t _level;
4355         level = ndr_pull_get_switch_value(ndr, r);
4356         if (ndr_flags & NDR_SCALARS) {
4357                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4358                 if (_level != level) {
4359                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4360                 }
4361                 switch (level) {
4362                         case 1: {
4363                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4364                         break; }
4365
4366                         default:
4367                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4368                 }
4369         }
4370         if (ndr_flags & NDR_BUFFERS) {
4371                 switch (level) {
4372                         case 1:
4373                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4374                         break;
4375
4376                         default:
4377                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4378                 }
4379         }
4380         return NDR_ERR_SUCCESS;
4381 }
4382
4383 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4384 {
4385         int level;
4386         level = ndr_print_get_switch_value(ndr, r);
4387         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4388         switch (level) {
4389                 case 1:
4390                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4391                 break;
4392
4393                 default:
4394                         ndr_print_bad_level(ndr, name, level);
4395         }
4396 }
4397
4398 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4399 {
4400         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4401         return NDR_ERR_SUCCESS;
4402 }
4403
4404 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4405 {
4406         uint32_t v;
4407         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4408         *r = v;
4409         return NDR_ERR_SUCCESS;
4410 }
4411
4412 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4413 {
4414         const char *val = NULL;
4415
4416         switch (r) {
4417                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4418                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4419                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4420                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4421                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4422                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4423                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4424         }
4425         ndr_print_enum(ndr, name, "ENUM", val, r);
4426 }
4427
4428 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4429 {
4430         uint32_t cntr_info_array_1;
4431         uint32_t cntr_group_attrs_1;
4432         uint32_t cntr_sids_1;
4433         if (ndr_flags & NDR_SCALARS) {
4434                 NDR_CHECK(ndr_push_align(ndr, 4));
4435                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4441         }
4442         if (ndr_flags & NDR_BUFFERS) {
4443                 if (r->info_array) {
4444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4445                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4446                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4447                         }
4448                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4449                                 if (r->info_array[cntr_info_array_1]) {
4450                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4451                                 }
4452                         }
4453                 }
4454                 if (r->group_attrs) {
4455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4456                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4457                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4458                         }
4459                 }
4460                 if (r->sids) {
4461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4462                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4463                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4464                         }
4465                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4466                                 if (r->sids[cntr_sids_1]) {
4467                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4468                                 }
4469                         }
4470                 }
4471         }
4472         return NDR_ERR_SUCCESS;
4473 }
4474
4475 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4476 {
4477         uint32_t _ptr_info_array;
4478         uint32_t cntr_info_array_1;
4479         TALLOC_CTX *_mem_save_info_array_0;
4480         TALLOC_CTX *_mem_save_info_array_1;
4481         TALLOC_CTX *_mem_save_info_array_2;
4482         uint32_t _ptr_group_attrs;
4483         uint32_t cntr_group_attrs_1;
4484         TALLOC_CTX *_mem_save_group_attrs_0;
4485         TALLOC_CTX *_mem_save_group_attrs_1;
4486         uint32_t _ptr_sids;
4487         uint32_t cntr_sids_1;
4488         TALLOC_CTX *_mem_save_sids_0;
4489         TALLOC_CTX *_mem_save_sids_1;
4490         TALLOC_CTX *_mem_save_sids_2;
4491         if (ndr_flags & NDR_SCALARS) {
4492                 NDR_CHECK(ndr_pull_align(ndr, 4));
4493                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4495                 if (r->num_memberships > 10000) {
4496                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4497                 }
4498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4499                 if (r->num_sids > 10000) {
4500                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4501                 }
4502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4503                 if (_ptr_info_array) {
4504                         NDR_PULL_ALLOC(ndr, r->info_array);
4505                 } else {
4506                         r->info_array = NULL;
4507                 }
4508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4509                 if (_ptr_group_attrs) {
4510                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4511                 } else {
4512                         r->group_attrs = NULL;
4513                 }
4514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4515                 if (_ptr_sids) {
4516                         NDR_PULL_ALLOC(ndr, r->sids);
4517                 } else {
4518                         r->sids = NULL;
4519                 }
4520         }
4521         if (ndr_flags & NDR_BUFFERS) {
4522                 if (r->info_array) {
4523                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4524                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4526                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4527                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4528                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4529                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4530                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4531                                 if (_ptr_info_array) {
4532                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4533                                 } else {
4534                                         r->info_array[cntr_info_array_1] = NULL;
4535                                 }
4536                         }
4537                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4538                                 if (r->info_array[cntr_info_array_1]) {
4539                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4540                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4541                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4542                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4543                                 }
4544                         }
4545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4547                 }
4548                 if (r->group_attrs) {
4549                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4550                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4551                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4552                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4553                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4554                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4555                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4556                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4557                         }
4558                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4560                 }
4561                 if (r->sids) {
4562                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4563                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4565                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4566                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4567                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4568                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4569                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4570                                 if (_ptr_sids) {
4571                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4572                                 } else {
4573                                         r->sids[cntr_sids_1] = NULL;
4574                                 }
4575                         }
4576                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4577                                 if (r->sids[cntr_sids_1]) {
4578                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4579                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4580                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4581                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4582                                 }
4583                         }
4584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4585                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4586                 }
4587                 if (r->info_array) {
4588                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4589                 }
4590                 if (r->group_attrs) {
4591                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4592                 }
4593                 if (r->sids) {
4594                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4595                 }
4596         }
4597         return NDR_ERR_SUCCESS;
4598 }
4599
4600 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4601 {
4602         uint32_t cntr_info_array_1;
4603         uint32_t cntr_group_attrs_1;
4604         uint32_t cntr_sids_1;
4605         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4606         ndr->depth++;
4607         ndr_print_NTSTATUS(ndr, "status", r->status);
4608         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4609         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4610         ndr_print_ptr(ndr, "info_array", r->info_array);
4611         ndr->depth++;
4612         if (r->info_array) {
4613                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4614                 ndr->depth++;
4615                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4616                         char *idx_1=NULL;
4617                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4618                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4619                                 ndr->depth++;
4620                                 if (r->info_array[cntr_info_array_1]) {
4621                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4622                                 }
4623                                 ndr->depth--;
4624                                 free(idx_1);
4625                         }
4626                 }
4627                 ndr->depth--;
4628         }
4629         ndr->depth--;
4630         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4631         ndr->depth++;
4632         if (r->group_attrs) {
4633                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4634                 ndr->depth++;
4635                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4636                         char *idx_1=NULL;
4637                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4638                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4639                                 free(idx_1);
4640                         }
4641                 }
4642                 ndr->depth--;
4643         }
4644         ndr->depth--;
4645         ndr_print_ptr(ndr, "sids", r->sids);
4646         ndr->depth++;
4647         if (r->sids) {
4648                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4649                 ndr->depth++;
4650                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4651                         char *idx_1=NULL;
4652                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4653                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4654                                 ndr->depth++;
4655                                 if (r->sids[cntr_sids_1]) {
4656                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4657                                 }
4658                                 ndr->depth--;
4659                                 free(idx_1);
4660                         }
4661                 }
4662                 ndr->depth--;
4663         }
4664         ndr->depth--;
4665         ndr->depth--;
4666 }
4667
4668 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4669 {
4670         if (ndr_flags & NDR_SCALARS) {
4671                 int level = ndr_push_get_switch_value(ndr, r);
4672                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4673                 switch (level) {
4674                         case 1: {
4675                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4676                         break; }
4677
4678                         default:
4679                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4680                 }
4681         }
4682         if (ndr_flags & NDR_BUFFERS) {
4683                 int level = ndr_push_get_switch_value(ndr, r);
4684                 switch (level) {
4685                         case 1:
4686                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4687                         break;
4688
4689                         default:
4690                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4691                 }
4692         }
4693         return NDR_ERR_SUCCESS;
4694 }
4695
4696 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4697 {
4698         int level;
4699         int32_t _level;
4700         level = ndr_pull_get_switch_value(ndr, r);
4701         if (ndr_flags & NDR_SCALARS) {
4702                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4703                 if (_level != level) {
4704                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4705                 }
4706                 switch (level) {
4707                         case 1: {
4708                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4709                         break; }
4710
4711                         default:
4712                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4713                 }
4714         }
4715         if (ndr_flags & NDR_BUFFERS) {
4716                 switch (level) {
4717                         case 1:
4718                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4719                         break;
4720
4721                         default:
4722                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4723                 }
4724         }
4725         return NDR_ERR_SUCCESS;
4726 }
4727
4728 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
4729 {
4730         int level;
4731         level = ndr_print_get_switch_value(ndr, r);
4732         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
4733         switch (level) {
4734                 case 1:
4735                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
4736                 break;
4737
4738                 default:
4739                         ndr_print_bad_level(ndr, name, level);
4740         }
4741 }
4742
4743 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
4744 {
4745         uint32_t cntr_info_array_1;
4746         if (ndr_flags & NDR_SCALARS) {
4747                 NDR_CHECK(ndr_push_align(ndr, 4));
4748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4751                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
4752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
4753         }
4754         if (ndr_flags & NDR_BUFFERS) {
4755                 if (r->info_array) {
4756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4757                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4758                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4759                         }
4760                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4761                                 if (r->info_array[cntr_info_array_1]) {
4762                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4763                                 }
4764                         }
4765                 }
4766                 if (r->domain) {
4767                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
4768                 }
4769         }
4770         return NDR_ERR_SUCCESS;
4771 }
4772
4773 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
4774 {
4775         uint32_t _ptr_info_array;
4776         uint32_t cntr_info_array_1;
4777         TALLOC_CTX *_mem_save_info_array_0;
4778         TALLOC_CTX *_mem_save_info_array_1;
4779         TALLOC_CTX *_mem_save_info_array_2;
4780         uint32_t _ptr_domain;
4781         TALLOC_CTX *_mem_save_domain_0;
4782         if (ndr_flags & NDR_SCALARS) {
4783                 NDR_CHECK(ndr_pull_align(ndr, 4));
4784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4785                 if (r->count < 1 || r->count > 10000) {
4786                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4787                 }
4788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4789                 if (_ptr_info_array) {
4790                         NDR_PULL_ALLOC(ndr, r->info_array);
4791                 } else {
4792                         r->info_array = NULL;
4793                 }
4794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4795                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
4796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
4797                 if (_ptr_domain) {
4798                         NDR_PULL_ALLOC(ndr, r->domain);
4799                 } else {
4800                         r->domain = NULL;
4801                 }
4802         }
4803         if (ndr_flags & NDR_BUFFERS) {
4804                 if (r->info_array) {
4805                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4806                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4807                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4808                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4809                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4810                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4811                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4812                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4813                                 if (_ptr_info_array) {
4814                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4815                                 } else {
4816                                         r->info_array[cntr_info_array_1] = NULL;
4817                                 }
4818                         }
4819                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4820                                 if (r->info_array[cntr_info_array_1]) {
4821                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4822                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4823                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4824                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4825                                 }
4826                         }
4827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4829                 }
4830                 if (r->domain) {
4831                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
4832                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
4833                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
4834                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
4835                 }
4836                 if (r->info_array) {
4837                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
4838                 }
4839         }
4840         return NDR_ERR_SUCCESS;
4841 }
4842
4843 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
4844 {
4845         uint32_t cntr_info_array_1;
4846         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
4847         ndr->depth++;
4848         ndr_print_uint32(ndr, "count", r->count);
4849         ndr_print_ptr(ndr, "info_array", r->info_array);
4850         ndr->depth++;
4851         if (r->info_array) {
4852                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
4853                 ndr->depth++;
4854                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
4855                         char *idx_1=NULL;
4856                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4857                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4858                                 ndr->depth++;
4859                                 if (r->info_array[cntr_info_array_1]) {
4860                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4861                                 }
4862                                 ndr->depth--;
4863                                 free(idx_1);
4864                         }
4865                 }
4866                 ndr->depth--;
4867         }
4868         ndr->depth--;
4869         ndr_print_uint32(ndr, "flags", r->flags);
4870         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
4871         ndr_print_ptr(ndr, "domain", r->domain);
4872         ndr->depth++;
4873         if (r->domain) {
4874                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
4875         }
4876         ndr->depth--;
4877         ndr->depth--;
4878 }
4879
4880 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
4881 {
4882         if (ndr_flags & NDR_SCALARS) {
4883                 int level = ndr_push_get_switch_value(ndr, r);
4884                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4885                 switch (level) {
4886                         case 1: {
4887                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
4888                         break; }
4889
4890                         default:
4891                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4892                 }
4893         }
4894         if (ndr_flags & NDR_BUFFERS) {
4895                 int level = ndr_push_get_switch_value(ndr, r);
4896                 switch (level) {
4897                         case 1:
4898                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
4899                         break;
4900
4901                         default:
4902                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4903                 }
4904         }
4905         return NDR_ERR_SUCCESS;
4906 }
4907
4908 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
4909 {
4910         int level;
4911         int32_t _level;
4912         level = ndr_pull_get_switch_value(ndr, r);
4913         if (ndr_flags & NDR_SCALARS) {
4914                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4915                 if (_level != level) {
4916                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4917                 }
4918                 switch (level) {
4919                         case 1: {
4920                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
4921                         break; }
4922
4923                         default:
4924                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4925                 }
4926         }
4927         if (ndr_flags & NDR_BUFFERS) {
4928                 switch (level) {
4929                         case 1:
4930                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
4931                         break;
4932
4933                         default:
4934                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4935                 }
4936         }
4937         return NDR_ERR_SUCCESS;
4938 }
4939
4940 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
4941 {
4942         int level;
4943         level = ndr_print_get_switch_value(ndr, r);
4944         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
4945         switch (level) {
4946                 case 1:
4947                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
4948                 break;
4949
4950                 default:
4951                         ndr_print_bad_level(ndr, name, level);
4952         }
4953 }
4954
4955 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
4956 {
4957         if (ndr_flags & NDR_SCALARS) {
4958                 NDR_CHECK(ndr_push_align(ndr, 4));
4959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
4960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4962                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4963         }
4964         if (ndr_flags & NDR_BUFFERS) {
4965                 if (r->data) {
4966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4967                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4968                 }
4969         }
4970         return NDR_ERR_SUCCESS;
4971 }
4972
4973 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
4974 {
4975         uint32_t _ptr_data;
4976         TALLOC_CTX *_mem_save_data_0;
4977         if (ndr_flags & NDR_SCALARS) {
4978                 NDR_CHECK(ndr_pull_align(ndr, 4));
4979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
4980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4982                 if (r->length > 0x00A00000) {
4983                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4984                 }
4985                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4986                 if (_ptr_data) {
4987                         NDR_PULL_ALLOC(ndr, r->data);
4988                 } else {
4989                         r->data = NULL;
4990                 }
4991         }
4992         if (ndr_flags & NDR_BUFFERS) {
4993                 if (r->data) {
4994                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4995                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4996                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4997                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
4998                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
4999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5000                 }
5001                 if (r->data) {
5002                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5003                 }
5004         }
5005         return NDR_ERR_SUCCESS;
5006 }
5007
5008 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5009 {
5010         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5011         ndr->depth++;
5012         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5013         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5014         ndr_print_uint32(ndr, "length", r->length);
5015         ndr_print_ptr(ndr, "data", r->data);
5016         ndr->depth++;
5017         if (r->data) {
5018                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5019         }
5020         ndr->depth--;
5021         ndr->depth--;
5022 }
5023
5024 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5025 {
5026         if (ndr_flags & NDR_SCALARS) {
5027                 int level = ndr_push_get_switch_value(ndr, r);
5028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5029                 switch (level) {
5030                         case 1: {
5031                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5032                         break; }
5033
5034                         default:
5035                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5036                 }
5037         }
5038         if (ndr_flags & NDR_BUFFERS) {
5039                 int level = ndr_push_get_switch_value(ndr, r);
5040                 switch (level) {
5041                         case 1:
5042                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5043                         break;
5044
5045                         default:
5046                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5047                 }
5048         }
5049         return NDR_ERR_SUCCESS;
5050 }
5051
5052 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5053 {
5054         int level;
5055         uint32_t _level;
5056         level = ndr_pull_get_switch_value(ndr, r);
5057         if (ndr_flags & NDR_SCALARS) {
5058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5059                 if (_level != level) {
5060                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5061                 }
5062                 switch (level) {
5063                         case 1: {
5064                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5065                         break; }
5066
5067                         default:
5068                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5069                 }
5070         }
5071         if (ndr_flags & NDR_BUFFERS) {
5072                 switch (level) {
5073                         case 1:
5074                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5075                         break;
5076
5077                         default:
5078                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5079                 }
5080         }
5081         return NDR_ERR_SUCCESS;
5082 }
5083
5084 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5085 {
5086         int level;
5087         level = ndr_print_get_switch_value(ndr, r);
5088         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5089         switch (level) {
5090                 case 1:
5091                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5092                 break;
5093
5094                 default:
5095                         ndr_print_bad_level(ndr, name, level);
5096         }
5097 }
5098
5099 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5100 {
5101         if (ndr_flags & NDR_SCALARS) {
5102                 NDR_CHECK(ndr_push_align(ndr, 8));
5103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5105                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5106                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5107                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5108                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5109                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5110                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5111                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5113                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5114         }
5115         if (ndr_flags & NDR_BUFFERS) {
5116                 if (r->data1) {
5117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5118                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5119                 }
5120                 if (r->data2) {
5121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5122                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5123                 }
5124         }
5125         return NDR_ERR_SUCCESS;
5126 }
5127
5128 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5129 {
5130         uint32_t _ptr_data1;
5131         TALLOC_CTX *_mem_save_data1_0;
5132         uint32_t _ptr_data2;
5133         TALLOC_CTX *_mem_save_data2_0;
5134         if (ndr_flags & NDR_SCALARS) {
5135                 NDR_CHECK(ndr_pull_align(ndr, 8));
5136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5137                 if (r->length1 > 0x00A00000) {
5138                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5139                 }
5140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5141                 if (r->length2 > 0x00A00000) {
5142                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5143                 }
5144                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5145                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5146                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5147                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5148                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5149                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5150                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5152                 if (_ptr_data1) {
5153                         NDR_PULL_ALLOC(ndr, r->data1);
5154                 } else {
5155                         r->data1 = NULL;
5156                 }
5157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5158                 if (_ptr_data2) {
5159                         NDR_PULL_ALLOC(ndr, r->data2);
5160                 } else {
5161                         r->data2 = NULL;
5162                 }
5163         }
5164         if (ndr_flags & NDR_BUFFERS) {
5165                 if (r->data1) {
5166                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5167                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5168                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5169                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5170                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5172                 }
5173                 if (r->data2) {
5174                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5175                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5177                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5178                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5180                 }
5181                 if (r->data1) {
5182                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5183                 }
5184                 if (r->data2) {
5185                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5186                 }
5187         }
5188         return NDR_ERR_SUCCESS;
5189 }
5190
5191 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5192 {
5193         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5194         ndr->depth++;
5195         ndr_print_uint32(ndr, "length1", r->length1);
5196         ndr_print_uint32(ndr, "length2", r->length2);
5197         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5198         ndr_print_NTTIME(ndr, "time2", r->time2);
5199         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5200         ndr_print_NTTIME(ndr, "time4", r->time4);
5201         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5202         ndr_print_NTTIME(ndr, "time6", r->time6);
5203         ndr_print_NTSTATUS(ndr, "status", r->status);
5204         ndr_print_ptr(ndr, "data1", r->data1);
5205         ndr->depth++;
5206         if (r->data1) {
5207                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5208         }
5209         ndr->depth--;
5210         ndr_print_ptr(ndr, "data2", r->data2);
5211         ndr->depth++;
5212         if (r->data2) {
5213                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5214         }
5215         ndr->depth--;
5216         ndr->depth--;
5217 }
5218
5219 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5220 {
5221         if (ndr_flags & NDR_SCALARS) {
5222                 int level = ndr_push_get_switch_value(ndr, r);
5223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5224                 switch (level) {
5225                         case 1: {
5226                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5227                         break; }
5228
5229                         default:
5230                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5231                 }
5232         }
5233         if (ndr_flags & NDR_BUFFERS) {
5234                 int level = ndr_push_get_switch_value(ndr, r);
5235                 switch (level) {
5236                         case 1:
5237                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5238                         break;
5239
5240                         default:
5241                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5242                 }
5243         }
5244         return NDR_ERR_SUCCESS;
5245 }
5246
5247 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5248 {
5249         int level;
5250         uint32_t _level;
5251         level = ndr_pull_get_switch_value(ndr, r);
5252         if (ndr_flags & NDR_SCALARS) {
5253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5254                 if (_level != level) {
5255                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5256                 }
5257                 switch (level) {
5258                         case 1: {
5259                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5260                         break; }
5261
5262                         default:
5263                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5264                 }
5265         }
5266         if (ndr_flags & NDR_BUFFERS) {
5267                 switch (level) {
5268                         case 1:
5269                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5270                         break;
5271
5272                         default:
5273                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5274                 }
5275         }
5276         return NDR_ERR_SUCCESS;
5277 }
5278
5279 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5280 {
5281         int level;
5282         level = ndr_print_get_switch_value(ndr, r);
5283         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5284         switch (level) {
5285                 case 1:
5286                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5287                 break;
5288
5289                 default:
5290                         ndr_print_bad_level(ndr, name, level);
5291         }
5292 }
5293
5294 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5295 {
5296         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5297         return NDR_ERR_SUCCESS;
5298 }
5299
5300 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5301 {
5302         uint32_t v;
5303         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5304         *r = v;
5305         return NDR_ERR_SUCCESS;
5306 }
5307
5308 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5309 {
5310         const char *val = NULL;
5311
5312         switch (r) {
5313                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5314                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5315                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5316                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5317                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5318                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5319                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5320                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5321         }
5322         ndr_print_enum(ndr, name, "ENUM", val, r);
5323 }
5324
5325 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5326 {
5327         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5328         return NDR_ERR_SUCCESS;
5329 }
5330
5331 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5332 {
5333         uint32_t v;
5334         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5335         *r = v;
5336         return NDR_ERR_SUCCESS;
5337 }
5338
5339 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5340 {
5341         const char *val = NULL;
5342
5343         switch (r) {
5344                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5345                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5346                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5347                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5348                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5349         }
5350         ndr_print_enum(ndr, name, "ENUM", val, r);
5351 }
5352
5353 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5354 {
5355         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5356         return NDR_ERR_SUCCESS;
5357 }
5358
5359 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5360 {
5361         uint32_t v;
5362         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5363         *r = v;
5364         return NDR_ERR_SUCCESS;
5365 }
5366
5367 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5368 {
5369         const char *val = NULL;
5370
5371         switch (r) {
5372                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5373                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5374                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5375                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5376                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5377                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5378                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5379                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5380                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5381                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5382                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5383         }
5384         ndr_print_enum(ndr, name, "ENUM", val, r);
5385 }
5386
5387 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5388 {
5389         if (ndr_flags & NDR_SCALARS) {
5390                 NDR_CHECK(ndr_push_align(ndr, 4));
5391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5392         }
5393         if (ndr_flags & NDR_BUFFERS) {
5394                 if (r->str) {
5395                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5398                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5399                 }
5400         }
5401         return NDR_ERR_SUCCESS;
5402 }
5403
5404 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5405 {
5406         uint32_t _ptr_str;
5407         TALLOC_CTX *_mem_save_str_0;
5408         if (ndr_flags & NDR_SCALARS) {
5409                 NDR_CHECK(ndr_pull_align(ndr, 4));
5410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5411                 if (_ptr_str) {
5412                         NDR_PULL_ALLOC(ndr, r->str);
5413                 } else {
5414                         r->str = NULL;
5415                 }
5416         }
5417         if (ndr_flags & NDR_BUFFERS) {
5418                 if (r->str) {
5419                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5420                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5421                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5422                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5423                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5424                                 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));
5425                         }
5426                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5427                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5428                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5429                 }
5430         }
5431         return NDR_ERR_SUCCESS;
5432 }
5433
5434 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5435 {
5436         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5437         ndr->depth++;
5438         ndr_print_ptr(ndr, "str", r->str);
5439         ndr->depth++;
5440         if (r->str) {
5441                 ndr_print_string(ndr, "str", r->str);
5442         }
5443         ndr->depth--;
5444         ndr->depth--;
5445 }
5446
5447 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5448 {
5449         uint32_t cntr_names_1;
5450         if (ndr_flags & NDR_SCALARS) {
5451                 NDR_CHECK(ndr_push_align(ndr, 4));
5452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5454                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5455                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5456                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5458                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5459         }
5460         if (ndr_flags & NDR_BUFFERS) {
5461                 if (r->names) {
5462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5463                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5464                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5465                         }
5466                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5467                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5468                         }
5469                 }
5470         }
5471         return NDR_ERR_SUCCESS;
5472 }
5473
5474 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5475 {
5476         uint32_t _ptr_names;
5477         uint32_t cntr_names_1;
5478         TALLOC_CTX *_mem_save_names_0;
5479         TALLOC_CTX *_mem_save_names_1;
5480         if (ndr_flags & NDR_SCALARS) {
5481                 NDR_CHECK(ndr_pull_align(ndr, 4));
5482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5484                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5485                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5486                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5488                 if (r->count < 1 || r->count > 10000) {
5489                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5490                 }
5491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5492                 if (_ptr_names) {
5493                         NDR_PULL_ALLOC(ndr, r->names);
5494                 } else {
5495                         r->names = NULL;
5496                 }
5497         }
5498         if (ndr_flags & NDR_BUFFERS) {
5499                 if (r->names) {
5500                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5501                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5503                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5504                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5505                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5506                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5507                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5508                         }
5509                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5510                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5511                         }
5512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5514                 }
5515                 if (r->names) {
5516                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5517                 }
5518         }
5519         return NDR_ERR_SUCCESS;
5520 }
5521
5522 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5523 {
5524         uint32_t cntr_names_1;
5525         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5526         ndr->depth++;
5527         ndr_print_uint32(ndr, "codepage", r->codepage);
5528         ndr_print_uint32(ndr, "language", r->language);
5529         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5530         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5531         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5532         ndr_print_uint32(ndr, "count", r->count);
5533         ndr_print_ptr(ndr, "names", r->names);
5534         ndr->depth++;
5535         if (r->names) {
5536                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5537                 ndr->depth++;
5538                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5539                         char *idx_1=NULL;
5540                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5541                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5542                                 free(idx_1);
5543                         }
5544                 }
5545                 ndr->depth--;
5546         }
5547         ndr->depth--;
5548         ndr->depth--;
5549 }
5550
5551 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5552 {
5553         if (ndr_flags & NDR_SCALARS) {
5554                 int level = ndr_push_get_switch_value(ndr, r);
5555                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5556                 switch (level) {
5557                         case 1: {
5558                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5559                         break; }
5560
5561                         default:
5562                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5563                 }
5564         }
5565         if (ndr_flags & NDR_BUFFERS) {
5566                 int level = ndr_push_get_switch_value(ndr, r);
5567                 switch (level) {
5568                         case 1:
5569                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5570                         break;
5571
5572                         default:
5573                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5574                 }
5575         }
5576         return NDR_ERR_SUCCESS;
5577 }
5578
5579 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5580 {
5581         int level;
5582         int32_t _level;
5583         level = ndr_pull_get_switch_value(ndr, r);
5584         if (ndr_flags & NDR_SCALARS) {
5585                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5586                 if (_level != level) {
5587                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5588                 }
5589                 switch (level) {
5590                         case 1: {
5591                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5592                         break; }
5593
5594                         default:
5595                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5596                 }
5597         }
5598         if (ndr_flags & NDR_BUFFERS) {
5599                 switch (level) {
5600                         case 1:
5601                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5602                         break;
5603
5604                         default:
5605                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5606                 }
5607         }
5608         return NDR_ERR_SUCCESS;
5609 }
5610
5611 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5612 {
5613         int level;
5614         level = ndr_print_get_switch_value(ndr, r);
5615         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5616         switch (level) {
5617                 case 1:
5618                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5619                 break;
5620
5621                 default:
5622                         ndr_print_bad_level(ndr, name, level);
5623         }
5624 }
5625
5626 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5627 {
5628         if (ndr_flags & NDR_SCALARS) {
5629                 NDR_CHECK(ndr_push_align(ndr, 4));
5630                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5631                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5632                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5633         }
5634         if (ndr_flags & NDR_BUFFERS) {
5635                 if (r->dns_domain_name) {
5636                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5637                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5639                         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));
5640                 }
5641                 if (r->result_name) {
5642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5644                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5645                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5646                 }
5647         }
5648         return NDR_ERR_SUCCESS;
5649 }
5650
5651 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5652 {
5653         uint32_t _ptr_dns_domain_name;
5654         TALLOC_CTX *_mem_save_dns_domain_name_0;
5655         uint32_t _ptr_result_name;
5656         TALLOC_CTX *_mem_save_result_name_0;
5657         if (ndr_flags & NDR_SCALARS) {
5658                 NDR_CHECK(ndr_pull_align(ndr, 4));
5659                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5661                 if (_ptr_dns_domain_name) {
5662                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5663                 } else {
5664                         r->dns_domain_name = NULL;
5665                 }
5666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5667                 if (_ptr_result_name) {
5668                         NDR_PULL_ALLOC(ndr, r->result_name);
5669                 } else {
5670                         r->result_name = NULL;
5671                 }
5672         }
5673         if (ndr_flags & NDR_BUFFERS) {
5674                 if (r->dns_domain_name) {
5675                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5676                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5677                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5678                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5679                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5680                                 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));
5681                         }
5682                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5683                         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));
5684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5685                 }
5686                 if (r->result_name) {
5687                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5688                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5689                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5690                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5691                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5692                                 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));
5693                         }
5694                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5695                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5697                 }
5698         }
5699         return NDR_ERR_SUCCESS;
5700 }
5701
5702 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5703 {
5704         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5705         ndr->depth++;
5706         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5707         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5708         ndr->depth++;
5709         if (r->dns_domain_name) {
5710                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5711         }
5712         ndr->depth--;
5713         ndr_print_ptr(ndr, "result_name", r->result_name);
5714         ndr->depth++;
5715         if (r->result_name) {
5716                 ndr_print_string(ndr, "result_name", r->result_name);
5717         }
5718         ndr->depth--;
5719         ndr->depth--;
5720 }
5721
5722 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5723 {
5724         uint32_t cntr_array_1;
5725         if (ndr_flags & NDR_SCALARS) {
5726                 NDR_CHECK(ndr_push_align(ndr, 4));
5727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5728                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5729         }
5730         if (ndr_flags & NDR_BUFFERS) {
5731                 if (r->array) {
5732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5733                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5734                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5735                         }
5736                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5737                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5738                         }
5739                 }
5740         }
5741         return NDR_ERR_SUCCESS;
5742 }
5743
5744 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
5745 {
5746         uint32_t _ptr_array;
5747         uint32_t cntr_array_1;
5748         TALLOC_CTX *_mem_save_array_0;
5749         TALLOC_CTX *_mem_save_array_1;
5750         if (ndr_flags & NDR_SCALARS) {
5751                 NDR_CHECK(ndr_pull_align(ndr, 4));
5752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5754                 if (_ptr_array) {
5755                         NDR_PULL_ALLOC(ndr, r->array);
5756                 } else {
5757                         r->array = NULL;
5758                 }
5759         }
5760         if (ndr_flags & NDR_BUFFERS) {
5761                 if (r->array) {
5762                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5763                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5764                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5765                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5766                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5767                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5768                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5769                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5770                         }
5771                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5772                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5773                         }
5774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5776                 }
5777                 if (r->array) {
5778                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5779                 }
5780         }
5781         return NDR_ERR_SUCCESS;
5782 }
5783
5784 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
5785 {
5786         uint32_t cntr_array_1;
5787         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
5788         ndr->depth++;
5789         ndr_print_uint32(ndr, "count", r->count);
5790         ndr_print_ptr(ndr, "array", r->array);
5791         ndr->depth++;
5792         if (r->array) {
5793                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5794                 ndr->depth++;
5795                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5796                         char *idx_1=NULL;
5797                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5798                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
5799                                 free(idx_1);
5800                         }
5801                 }
5802                 ndr->depth--;
5803         }
5804         ndr->depth--;
5805         ndr->depth--;
5806 }
5807
5808 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
5809 {
5810         if (ndr_flags & NDR_SCALARS) {
5811                 int level = ndr_push_get_switch_value(ndr, r);
5812                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5813                 switch (level) {
5814                         case 1: {
5815                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5816                         break; }
5817
5818                         default:
5819                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5820                 }
5821         }
5822         if (ndr_flags & NDR_BUFFERS) {
5823                 int level = ndr_push_get_switch_value(ndr, r);
5824                 switch (level) {
5825                         case 1:
5826                                 if (r->ctr1) {
5827                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5828                                 }
5829                         break;
5830
5831                         default:
5832                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5833                 }
5834         }
5835         return NDR_ERR_SUCCESS;
5836 }
5837
5838 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
5839 {
5840         int level;
5841         int32_t _level;
5842         TALLOC_CTX *_mem_save_ctr1_0;
5843         level = ndr_pull_get_switch_value(ndr, r);
5844         if (ndr_flags & NDR_SCALARS) {
5845                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5846                 if (_level != level) {
5847                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5848                 }
5849                 switch (level) {
5850                         case 1: {
5851                                 uint32_t _ptr_ctr1;
5852                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
5853                                 if (_ptr_ctr1) {
5854                                         NDR_PULL_ALLOC(ndr, r->ctr1);
5855                                 } else {
5856                                         r->ctr1 = NULL;
5857                                 }
5858                         break; }
5859
5860                         default:
5861                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5862                 }
5863         }
5864         if (ndr_flags & NDR_BUFFERS) {
5865                 switch (level) {
5866                         case 1:
5867                                 if (r->ctr1) {
5868                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5869                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
5870                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5871                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
5872                                 }
5873                         break;
5874
5875                         default:
5876                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5877                 }
5878         }
5879         return NDR_ERR_SUCCESS;
5880 }
5881
5882 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
5883 {
5884         int level;
5885         level = ndr_print_get_switch_value(ndr, r);
5886         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
5887         switch (level) {
5888                 case 1:
5889                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
5890                         ndr->depth++;
5891                         if (r->ctr1) {
5892                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
5893                         }
5894                         ndr->depth--;
5895                 break;
5896
5897                 default:
5898                         ndr_print_bad_level(ndr, name, level);
5899         }
5900 }
5901
5902 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
5903 {
5904         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5905         return NDR_ERR_SUCCESS;
5906 }
5907
5908 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
5909 {
5910         uint32_t v;
5911         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5912         *r = v;
5913         return NDR_ERR_SUCCESS;
5914 }
5915
5916 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
5917 {
5918         const char *val = NULL;
5919
5920         switch (r) {
5921                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
5922                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
5923                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
5924         }
5925         ndr_print_enum(ndr, name, "ENUM", val, r);
5926 }
5927
5928 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
5929 {
5930         uint32_t cntr_spn_names_1;
5931         if (ndr_flags & NDR_SCALARS) {
5932                 NDR_CHECK(ndr_push_align(ndr, 4));
5933                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
5934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5935                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
5936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5937                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
5938         }
5939         if (ndr_flags & NDR_BUFFERS) {
5940                 if (r->object_dn) {
5941                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
5942                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5943                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
5944                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5945                 }
5946                 if (r->spn_names) {
5947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5948                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
5949                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
5950                         }
5951                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
5952                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
5953                         }
5954                 }
5955         }
5956         return NDR_ERR_SUCCESS;
5957 }
5958
5959 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
5960 {
5961         uint32_t _ptr_object_dn;
5962         TALLOC_CTX *_mem_save_object_dn_0;
5963         uint32_t _ptr_spn_names;
5964         uint32_t cntr_spn_names_1;
5965         TALLOC_CTX *_mem_save_spn_names_0;
5966         TALLOC_CTX *_mem_save_spn_names_1;
5967         if (ndr_flags & NDR_SCALARS) {
5968                 NDR_CHECK(ndr_pull_align(ndr, 4));
5969                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
5970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
5972                 if (_ptr_object_dn) {
5973                         NDR_PULL_ALLOC(ndr, r->object_dn);
5974                 } else {
5975                         r->object_dn = NULL;
5976                 }
5977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5978                 if (r->count > 10000) {
5979                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5980                 }
5981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
5982                 if (_ptr_spn_names) {
5983                         NDR_PULL_ALLOC(ndr, r->spn_names);
5984                 } else {
5985                         r->spn_names = NULL;
5986                 }
5987         }
5988         if (ndr_flags & NDR_BUFFERS) {
5989                 if (r->object_dn) {
5990                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
5991                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
5992                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
5993                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
5994                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
5995                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
5996                         }
5997                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
5998                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
5999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6000                 }
6001                 if (r->spn_names) {
6002                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6003                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6004                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6005                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6006                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6007                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6008                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6009                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6010                         }
6011                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6012                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6013                         }
6014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6016                 }
6017                 if (r->spn_names) {
6018                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6019                 }
6020         }
6021         return NDR_ERR_SUCCESS;
6022 }
6023
6024 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6025 {
6026         uint32_t cntr_spn_names_1;
6027         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6028         ndr->depth++;
6029         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6030         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6031         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6032         ndr->depth++;
6033         if (r->object_dn) {
6034                 ndr_print_string(ndr, "object_dn", r->object_dn);
6035         }
6036         ndr->depth--;
6037         ndr_print_uint32(ndr, "count", r->count);
6038         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6039         ndr->depth++;
6040         if (r->spn_names) {
6041                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6042                 ndr->depth++;
6043                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6044                         char *idx_1=NULL;
6045                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6046                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6047                                 free(idx_1);
6048                         }
6049                 }
6050                 ndr->depth--;
6051         }
6052         ndr->depth--;
6053         ndr->depth--;
6054 }
6055
6056 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6057 {
6058         if (ndr_flags & NDR_SCALARS) {
6059                 int level = ndr_push_get_switch_value(ndr, r);
6060                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6061                 switch (level) {
6062                         case 1: {
6063                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6064                         break; }
6065
6066                         default:
6067                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6068                 }
6069         }
6070         if (ndr_flags & NDR_BUFFERS) {
6071                 int level = ndr_push_get_switch_value(ndr, r);
6072                 switch (level) {
6073                         case 1:
6074                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6075                         break;
6076
6077                         default:
6078                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6079                 }
6080         }
6081         return NDR_ERR_SUCCESS;
6082 }
6083
6084 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6085 {
6086         int level;
6087         int32_t _level;
6088         level = ndr_pull_get_switch_value(ndr, r);
6089         if (ndr_flags & NDR_SCALARS) {
6090                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6091                 if (_level != level) {
6092                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6093                 }
6094                 switch (level) {
6095                         case 1: {
6096                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6097                         break; }
6098
6099                         default:
6100                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6101                 }
6102         }
6103         if (ndr_flags & NDR_BUFFERS) {
6104                 switch (level) {
6105                         case 1:
6106                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6107                         break;
6108
6109                         default:
6110                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6111                 }
6112         }
6113         return NDR_ERR_SUCCESS;
6114 }
6115
6116 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6117 {
6118         int level;
6119         level = ndr_print_get_switch_value(ndr, r);
6120         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6121         switch (level) {
6122                 case 1:
6123                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6124                 break;
6125
6126                 default:
6127                         ndr_print_bad_level(ndr, name, level);
6128         }
6129 }
6130
6131 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6132 {
6133         if (ndr_flags & NDR_SCALARS) {
6134                 NDR_CHECK(ndr_push_align(ndr, 4));
6135                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6136         }
6137         if (ndr_flags & NDR_BUFFERS) {
6138         }
6139         return NDR_ERR_SUCCESS;
6140 }
6141
6142 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6143 {
6144         if (ndr_flags & NDR_SCALARS) {
6145                 NDR_CHECK(ndr_pull_align(ndr, 4));
6146                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6147         }
6148         if (ndr_flags & NDR_BUFFERS) {
6149         }
6150         return NDR_ERR_SUCCESS;
6151 }
6152
6153 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6154 {
6155         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6156         ndr->depth++;
6157         ndr_print_WERROR(ndr, "status", r->status);
6158         ndr->depth--;
6159 }
6160
6161 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6162 {
6163         if (ndr_flags & NDR_SCALARS) {
6164                 int level = ndr_push_get_switch_value(ndr, r);
6165                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6166                 switch (level) {
6167                         case 1: {
6168                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6169                         break; }
6170
6171                         default:
6172                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6173                 }
6174         }
6175         if (ndr_flags & NDR_BUFFERS) {
6176                 int level = ndr_push_get_switch_value(ndr, r);
6177                 switch (level) {
6178                         case 1:
6179                         break;
6180
6181                         default:
6182                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6183                 }
6184         }
6185         return NDR_ERR_SUCCESS;
6186 }
6187
6188 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6189 {
6190         int level;
6191         int32_t _level;
6192         level = ndr_pull_get_switch_value(ndr, r);
6193         if (ndr_flags & NDR_SCALARS) {
6194                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6195                 if (_level != level) {
6196                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6197                 }
6198                 switch (level) {
6199                         case 1: {
6200                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6201                         break; }
6202
6203                         default:
6204                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6205                 }
6206         }
6207         if (ndr_flags & NDR_BUFFERS) {
6208                 switch (level) {
6209                         case 1:
6210                         break;
6211
6212                         default:
6213                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6214                 }
6215         }
6216         return NDR_ERR_SUCCESS;
6217 }
6218
6219 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6220 {
6221         int level;
6222         level = ndr_print_get_switch_value(ndr, r);
6223         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6224         switch (level) {
6225                 case 1:
6226                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6227                 break;
6228
6229                 default:
6230                         ndr_print_bad_level(ndr, name, level);
6231         }
6232 }
6233
6234 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6235 {
6236         if (ndr_flags & NDR_SCALARS) {
6237                 NDR_CHECK(ndr_push_align(ndr, 4));
6238                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6239                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6241         }
6242         if (ndr_flags & NDR_BUFFERS) {
6243                 if (r->server_dn) {
6244                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6247                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6248                 }
6249                 if (r->domain_dn) {
6250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6252                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6253                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6254                 }
6255         }
6256         return NDR_ERR_SUCCESS;
6257 }
6258
6259 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6260 {
6261         uint32_t _ptr_server_dn;
6262         TALLOC_CTX *_mem_save_server_dn_0;
6263         uint32_t _ptr_domain_dn;
6264         TALLOC_CTX *_mem_save_domain_dn_0;
6265         if (ndr_flags & NDR_SCALARS) {
6266                 NDR_CHECK(ndr_pull_align(ndr, 4));
6267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6268                 if (_ptr_server_dn) {
6269                         NDR_PULL_ALLOC(ndr, r->server_dn);
6270                 } else {
6271                         r->server_dn = NULL;
6272                 }
6273                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6274                 if (_ptr_domain_dn) {
6275                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6276                 } else {
6277                         r->domain_dn = NULL;
6278                 }
6279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6280         }
6281         if (ndr_flags & NDR_BUFFERS) {
6282                 if (r->server_dn) {
6283                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6284                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6286                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6287                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6288                                 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));
6289                         }
6290                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6291                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6293                 }
6294                 if (r->domain_dn) {
6295                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6296                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6297                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6298                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6299                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6300                                 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));
6301                         }
6302                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6303                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6304                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6305                 }
6306         }
6307         return NDR_ERR_SUCCESS;
6308 }
6309
6310 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6311 {
6312         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6313         ndr->depth++;
6314         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6315         ndr->depth++;
6316         if (r->server_dn) {
6317                 ndr_print_string(ndr, "server_dn", r->server_dn);
6318         }
6319         ndr->depth--;
6320         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6321         ndr->depth++;
6322         if (r->domain_dn) {
6323                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6324         }
6325         ndr->depth--;
6326         ndr_print_uint32(ndr, "commit", r->commit);
6327         ndr->depth--;
6328 }
6329
6330 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6331 {
6332         if (ndr_flags & NDR_SCALARS) {
6333                 int level = ndr_push_get_switch_value(ndr, r);
6334                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6335                 switch (level) {
6336                         case 1: {
6337                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6338                         break; }
6339
6340                         default:
6341                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6342                 }
6343         }
6344         if (ndr_flags & NDR_BUFFERS) {
6345                 int level = ndr_push_get_switch_value(ndr, r);
6346                 switch (level) {
6347                         case 1:
6348                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6349                         break;
6350
6351                         default:
6352                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6353                 }
6354         }
6355         return NDR_ERR_SUCCESS;
6356 }
6357
6358 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6359 {
6360         int level;
6361         int32_t _level;
6362         level = ndr_pull_get_switch_value(ndr, r);
6363         if (ndr_flags & NDR_SCALARS) {
6364                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6365                 if (_level != level) {
6366                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6367                 }
6368                 switch (level) {
6369                         case 1: {
6370                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6371                         break; }
6372
6373                         default:
6374                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6375                 }
6376         }
6377         if (ndr_flags & NDR_BUFFERS) {
6378                 switch (level) {
6379                         case 1:
6380                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6381                         break;
6382
6383                         default:
6384                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6385                 }
6386         }
6387         return NDR_ERR_SUCCESS;
6388 }
6389
6390 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6391 {
6392         int level;
6393         level = ndr_print_get_switch_value(ndr, r);
6394         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6395         switch (level) {
6396                 case 1:
6397                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6398                 break;
6399
6400                 default:
6401                         ndr_print_bad_level(ndr, name, level);
6402         }
6403 }
6404
6405 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6406 {
6407         if (ndr_flags & NDR_SCALARS) {
6408                 NDR_CHECK(ndr_push_align(ndr, 4));
6409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6410         }
6411         if (ndr_flags & NDR_BUFFERS) {
6412         }
6413         return NDR_ERR_SUCCESS;
6414 }
6415
6416 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6417 {
6418         if (ndr_flags & NDR_SCALARS) {
6419                 NDR_CHECK(ndr_pull_align(ndr, 4));
6420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6421         }
6422         if (ndr_flags & NDR_BUFFERS) {
6423         }
6424         return NDR_ERR_SUCCESS;
6425 }
6426
6427 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6428 {
6429         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6430         ndr->depth++;
6431         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6432         ndr->depth--;
6433 }
6434
6435 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6436 {
6437         if (ndr_flags & NDR_SCALARS) {
6438                 int level = ndr_push_get_switch_value(ndr, r);
6439                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6440                 switch (level) {
6441                         case 1: {
6442                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6443                         break; }
6444
6445                         default:
6446                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6447                 }
6448         }
6449         if (ndr_flags & NDR_BUFFERS) {
6450                 int level = ndr_push_get_switch_value(ndr, r);
6451                 switch (level) {
6452                         case 1:
6453                         break;
6454
6455                         default:
6456                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6457                 }
6458         }
6459         return NDR_ERR_SUCCESS;
6460 }
6461
6462 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6463 {
6464         int level;
6465         int32_t _level;
6466         level = ndr_pull_get_switch_value(ndr, r);
6467         if (ndr_flags & NDR_SCALARS) {
6468                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6469                 if (_level != level) {
6470                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6471                 }
6472                 switch (level) {
6473                         case 1: {
6474                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6475                         break; }
6476
6477                         default:
6478                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6479                 }
6480         }
6481         if (ndr_flags & NDR_BUFFERS) {
6482                 switch (level) {
6483                         case 1:
6484                         break;
6485
6486                         default:
6487                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6488                 }
6489         }
6490         return NDR_ERR_SUCCESS;
6491 }
6492
6493 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6494 {
6495         int level;
6496         level = ndr_print_get_switch_value(ndr, r);
6497         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6498         switch (level) {
6499                 case 1:
6500                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6501                 break;
6502
6503                 default:
6504                         ndr_print_bad_level(ndr, name, level);
6505         }
6506 }
6507
6508 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6509 {
6510         if (ndr_flags & NDR_SCALARS) {
6511                 NDR_CHECK(ndr_push_align(ndr, 4));
6512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6513                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6514         }
6515         if (ndr_flags & NDR_BUFFERS) {
6516                 if (r->domain_name) {
6517                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6520                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6521                 }
6522         }
6523         return NDR_ERR_SUCCESS;
6524 }
6525
6526 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6527 {
6528         uint32_t _ptr_domain_name;
6529         TALLOC_CTX *_mem_save_domain_name_0;
6530         if (ndr_flags & NDR_SCALARS) {
6531                 NDR_CHECK(ndr_pull_align(ndr, 4));
6532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6533                 if (_ptr_domain_name) {
6534                         NDR_PULL_ALLOC(ndr, r->domain_name);
6535                 } else {
6536                         r->domain_name = NULL;
6537                 }
6538                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6539         }
6540         if (ndr_flags & NDR_BUFFERS) {
6541                 if (r->domain_name) {
6542                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6543                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6544                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6545                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6546                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6547                                 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));
6548                         }
6549                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6550                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6551                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6552                 }
6553         }
6554         return NDR_ERR_SUCCESS;
6555 }
6556
6557 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6558 {
6559         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6560         ndr->depth++;
6561         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6562         ndr->depth++;
6563         if (r->domain_name) {
6564                 ndr_print_string(ndr, "domain_name", r->domain_name);
6565         }
6566         ndr->depth--;
6567         ndr_print_int32(ndr, "level", r->level);
6568         ndr->depth--;
6569 }
6570
6571 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6572 {
6573         if (ndr_flags & NDR_SCALARS) {
6574                 int level = ndr_push_get_switch_value(ndr, r);
6575                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6576                 switch (level) {
6577                         case 1: {
6578                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6579                         break; }
6580
6581                         default:
6582                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6583                 }
6584         }
6585         if (ndr_flags & NDR_BUFFERS) {
6586                 int level = ndr_push_get_switch_value(ndr, r);
6587                 switch (level) {
6588                         case 1:
6589                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6590                         break;
6591
6592                         default:
6593                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6594                 }
6595         }
6596         return NDR_ERR_SUCCESS;
6597 }
6598
6599 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6600 {
6601         int level;
6602         int32_t _level;
6603         level = ndr_pull_get_switch_value(ndr, r);
6604         if (ndr_flags & NDR_SCALARS) {
6605                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6606                 if (_level != level) {
6607                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6608                 }
6609                 switch (level) {
6610                         case 1: {
6611                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6612                         break; }
6613
6614                         default:
6615                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6616                 }
6617         }
6618         if (ndr_flags & NDR_BUFFERS) {
6619                 switch (level) {
6620                         case 1:
6621                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6622                         break;
6623
6624                         default:
6625                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6626                 }
6627         }
6628         return NDR_ERR_SUCCESS;
6629 }
6630
6631 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6632 {
6633         int level;
6634         level = ndr_print_get_switch_value(ndr, r);
6635         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6636         switch (level) {
6637                 case 1:
6638                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6639                 break;
6640
6641                 default:
6642                         ndr_print_bad_level(ndr, name, level);
6643         }
6644 }
6645
6646 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6647 {
6648         if (ndr_flags & NDR_SCALARS) {
6649                 NDR_CHECK(ndr_push_align(ndr, 4));
6650                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6651                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6653                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6654                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6657         }
6658         if (ndr_flags & NDR_BUFFERS) {
6659                 if (r->netbios_name) {
6660                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6663                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6664                 }
6665                 if (r->dns_name) {
6666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6669                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6670                 }
6671                 if (r->site_name) {
6672                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6675                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6676                 }
6677                 if (r->computer_dn) {
6678                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6679                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6680                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6681                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6682                 }
6683                 if (r->server_dn) {
6684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6687                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6688                 }
6689         }
6690         return NDR_ERR_SUCCESS;
6691 }
6692
6693 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6694 {
6695         uint32_t _ptr_netbios_name;
6696         TALLOC_CTX *_mem_save_netbios_name_0;
6697         uint32_t _ptr_dns_name;
6698         TALLOC_CTX *_mem_save_dns_name_0;
6699         uint32_t _ptr_site_name;
6700         TALLOC_CTX *_mem_save_site_name_0;
6701         uint32_t _ptr_computer_dn;
6702         TALLOC_CTX *_mem_save_computer_dn_0;
6703         uint32_t _ptr_server_dn;
6704         TALLOC_CTX *_mem_save_server_dn_0;
6705         if (ndr_flags & NDR_SCALARS) {
6706                 NDR_CHECK(ndr_pull_align(ndr, 4));
6707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6708                 if (_ptr_netbios_name) {
6709                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6710                 } else {
6711                         r->netbios_name = NULL;
6712                 }
6713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6714                 if (_ptr_dns_name) {
6715                         NDR_PULL_ALLOC(ndr, r->dns_name);
6716                 } else {
6717                         r->dns_name = NULL;
6718                 }
6719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6720                 if (_ptr_site_name) {
6721                         NDR_PULL_ALLOC(ndr, r->site_name);
6722                 } else {
6723                         r->site_name = NULL;
6724                 }
6725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6726                 if (_ptr_computer_dn) {
6727                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6728                 } else {
6729                         r->computer_dn = NULL;
6730                 }
6731                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6732                 if (_ptr_server_dn) {
6733                         NDR_PULL_ALLOC(ndr, r->server_dn);
6734                 } else {
6735                         r->server_dn = NULL;
6736                 }
6737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
6738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
6739         }
6740         if (ndr_flags & NDR_BUFFERS) {
6741                 if (r->netbios_name) {
6742                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6743                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
6744                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
6745                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
6746                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
6747                                 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));
6748                         }
6749                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
6750                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
6751                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
6752                 }
6753                 if (r->dns_name) {
6754                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6755                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
6756                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
6757                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
6758                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
6759                                 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));
6760                         }
6761                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
6762                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
6763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
6764                 }
6765                 if (r->site_name) {
6766                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6767                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
6768                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
6769                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
6770                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
6771                                 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));
6772                         }
6773                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
6774                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
6775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
6776                 }
6777                 if (r->computer_dn) {
6778                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6779                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
6780                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
6781                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
6782                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
6783                                 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));
6784                         }
6785                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
6786                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
6787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
6788                 }
6789                 if (r->server_dn) {
6790                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6791                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6794                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6795                                 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));
6796                         }
6797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6798                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6800                 }
6801         }
6802         return NDR_ERR_SUCCESS;
6803 }
6804
6805 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
6806 {
6807         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
6808         ndr->depth++;
6809         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
6810         ndr->depth++;
6811         if (r->netbios_name) {
6812                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
6813         }
6814         ndr->depth--;
6815         ndr_print_ptr(ndr, "dns_name", r->dns_name);
6816         ndr->depth++;
6817         if (r->dns_name) {
6818                 ndr_print_string(ndr, "dns_name", r->dns_name);
6819         }
6820         ndr->depth--;
6821         ndr_print_ptr(ndr, "site_name", r->site_name);
6822         ndr->depth++;
6823         if (r->site_name) {
6824                 ndr_print_string(ndr, "site_name", r->site_name);
6825         }
6826         ndr->depth--;
6827         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
6828         ndr->depth++;
6829         if (r->computer_dn) {
6830                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
6831         }
6832         ndr->depth--;
6833         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6834         ndr->depth++;
6835         if (r->server_dn) {
6836                 ndr_print_string(ndr, "server_dn", r->server_dn);
6837         }
6838         ndr->depth--;
6839         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
6840         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
6841         ndr->depth--;
6842 }
6843
6844 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
6845 {
6846         uint32_t cntr_array_1;
6847         if (ndr_flags & NDR_SCALARS) {
6848                 NDR_CHECK(ndr_push_align(ndr, 4));
6849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6851         }
6852         if (ndr_flags & NDR_BUFFERS) {
6853                 if (r->array) {
6854                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6855                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6856                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6857                         }
6858                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6859                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6860                         }
6861                 }
6862         }
6863         return NDR_ERR_SUCCESS;
6864 }
6865
6866 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
6867 {
6868         uint32_t _ptr_array;
6869         uint32_t cntr_array_1;
6870         TALLOC_CTX *_mem_save_array_0;
6871         TALLOC_CTX *_mem_save_array_1;
6872         if (ndr_flags & NDR_SCALARS) {
6873                 NDR_CHECK(ndr_pull_align(ndr, 4));
6874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6875                 if (r->count > 10000) {
6876                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6877                 }
6878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6879                 if (_ptr_array) {
6880                         NDR_PULL_ALLOC(ndr, r->array);
6881                 } else {
6882                         r->array = NULL;
6883                 }
6884         }
6885         if (ndr_flags & NDR_BUFFERS) {
6886                 if (r->array) {
6887                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6888                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6889                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6890                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6891                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6892                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6893                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6894                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6895                         }
6896                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6897                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6898                         }
6899                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6901                 }
6902                 if (r->array) {
6903                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6904                 }
6905         }
6906         return NDR_ERR_SUCCESS;
6907 }
6908
6909 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
6910 {
6911         uint32_t cntr_array_1;
6912         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
6913         ndr->depth++;
6914         ndr_print_uint32(ndr, "count", r->count);
6915         ndr_print_ptr(ndr, "array", r->array);
6916         ndr->depth++;
6917         if (r->array) {
6918                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6919                 ndr->depth++;
6920                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6921                         char *idx_1=NULL;
6922                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6923                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
6924                                 free(idx_1);
6925                         }
6926                 }
6927                 ndr->depth--;
6928         }
6929         ndr->depth--;
6930         ndr->depth--;
6931 }
6932
6933 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
6934 {
6935         if (ndr_flags & NDR_SCALARS) {
6936                 NDR_CHECK(ndr_push_align(ndr, 4));
6937                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
6941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
6944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
6947                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
6948                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
6949                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
6950                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
6951         }
6952         if (ndr_flags & NDR_BUFFERS) {
6953                 if (r->netbios_name) {
6954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6956                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6957                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6958                 }
6959                 if (r->dns_name) {
6960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6962                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6963                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6964                 }
6965                 if (r->site_name) {
6966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6968                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6969                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6970                 }
6971                 if (r->site_dn) {
6972                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6976                 }
6977                 if (r->computer_dn) {
6978                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6981                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6982                 }
6983                 if (r->server_dn) {
6984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6987                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6988                 }
6989                 if (r->ntds_dn) {
6990                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6993                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6994                 }
6995         }
6996         return NDR_ERR_SUCCESS;
6997 }
6998
6999 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7000 {
7001         uint32_t _ptr_netbios_name;
7002         TALLOC_CTX *_mem_save_netbios_name_0;
7003         uint32_t _ptr_dns_name;
7004         TALLOC_CTX *_mem_save_dns_name_0;
7005         uint32_t _ptr_site_name;
7006         TALLOC_CTX *_mem_save_site_name_0;
7007         uint32_t _ptr_site_dn;
7008         TALLOC_CTX *_mem_save_site_dn_0;
7009         uint32_t _ptr_computer_dn;
7010         TALLOC_CTX *_mem_save_computer_dn_0;
7011         uint32_t _ptr_server_dn;
7012         TALLOC_CTX *_mem_save_server_dn_0;
7013         uint32_t _ptr_ntds_dn;
7014         TALLOC_CTX *_mem_save_ntds_dn_0;
7015         if (ndr_flags & NDR_SCALARS) {
7016                 NDR_CHECK(ndr_pull_align(ndr, 4));
7017                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7018                 if (_ptr_netbios_name) {
7019                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7020                 } else {
7021                         r->netbios_name = NULL;
7022                 }
7023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7024                 if (_ptr_dns_name) {
7025                         NDR_PULL_ALLOC(ndr, r->dns_name);
7026                 } else {
7027                         r->dns_name = NULL;
7028                 }
7029                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7030                 if (_ptr_site_name) {
7031                         NDR_PULL_ALLOC(ndr, r->site_name);
7032                 } else {
7033                         r->site_name = NULL;
7034                 }
7035                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7036                 if (_ptr_site_dn) {
7037                         NDR_PULL_ALLOC(ndr, r->site_dn);
7038                 } else {
7039                         r->site_dn = NULL;
7040                 }
7041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7042                 if (_ptr_computer_dn) {
7043                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7044                 } else {
7045                         r->computer_dn = NULL;
7046                 }
7047                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7048                 if (_ptr_server_dn) {
7049                         NDR_PULL_ALLOC(ndr, r->server_dn);
7050                 } else {
7051                         r->server_dn = NULL;
7052                 }
7053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7054                 if (_ptr_ntds_dn) {
7055                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7056                 } else {
7057                         r->ntds_dn = NULL;
7058                 }
7059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7062                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7063                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7064                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7065                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7066         }
7067         if (ndr_flags & NDR_BUFFERS) {
7068                 if (r->netbios_name) {
7069                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7070                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7071                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7072                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7073                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7074                                 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));
7075                         }
7076                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7077                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7079                 }
7080                 if (r->dns_name) {
7081                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7082                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7083                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7084                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7085                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7086                                 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));
7087                         }
7088                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7089                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7090                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7091                 }
7092                 if (r->site_name) {
7093                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7094                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7095                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7096                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7097                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7098                                 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));
7099                         }
7100                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7101                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7103                 }
7104                 if (r->site_dn) {
7105                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7106                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7109                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7110                                 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));
7111                         }
7112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7115                 }
7116                 if (r->computer_dn) {
7117                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7118                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7121                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7122                                 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));
7123                         }
7124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7127                 }
7128                 if (r->server_dn) {
7129                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7130                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7133                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7134                                 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));
7135                         }
7136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7139                 }
7140                 if (r->ntds_dn) {
7141                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7142                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7145                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7146                                 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));
7147                         }
7148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7151                 }
7152         }
7153         return NDR_ERR_SUCCESS;
7154 }
7155
7156 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7157 {
7158         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7159         ndr->depth++;
7160         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7161         ndr->depth++;
7162         if (r->netbios_name) {
7163                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7164         }
7165         ndr->depth--;
7166         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7167         ndr->depth++;
7168         if (r->dns_name) {
7169                 ndr_print_string(ndr, "dns_name", r->dns_name);
7170         }
7171         ndr->depth--;
7172         ndr_print_ptr(ndr, "site_name", r->site_name);
7173         ndr->depth++;
7174         if (r->site_name) {
7175                 ndr_print_string(ndr, "site_name", r->site_name);
7176         }
7177         ndr->depth--;
7178         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7179         ndr->depth++;
7180         if (r->site_dn) {
7181                 ndr_print_string(ndr, "site_dn", r->site_dn);
7182         }
7183         ndr->depth--;
7184         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7185         ndr->depth++;
7186         if (r->computer_dn) {
7187                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7188         }
7189         ndr->depth--;
7190         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7191         ndr->depth++;
7192         if (r->server_dn) {
7193                 ndr_print_string(ndr, "server_dn", r->server_dn);
7194         }
7195         ndr->depth--;
7196         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7197         ndr->depth++;
7198         if (r->ntds_dn) {
7199                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7200         }
7201         ndr->depth--;
7202         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7203         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7204         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7205         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7206         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7207         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7208         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7209         ndr->depth--;
7210 }
7211
7212 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7213 {
7214         uint32_t cntr_array_1;
7215         if (ndr_flags & NDR_SCALARS) {
7216                 NDR_CHECK(ndr_push_align(ndr, 4));
7217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7218                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7219         }
7220         if (ndr_flags & NDR_BUFFERS) {
7221                 if (r->array) {
7222                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7223                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7224                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(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_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7228                         }
7229                 }
7230         }
7231         return NDR_ERR_SUCCESS;
7232 }
7233
7234 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7235 {
7236         uint32_t _ptr_array;
7237         uint32_t cntr_array_1;
7238         TALLOC_CTX *_mem_save_array_0;
7239         TALLOC_CTX *_mem_save_array_1;
7240         if (ndr_flags & NDR_SCALARS) {
7241                 NDR_CHECK(ndr_pull_align(ndr, 4));
7242                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7243                 if (r->count > 10000) {
7244                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7245                 }
7246                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7247                 if (_ptr_array) {
7248                         NDR_PULL_ALLOC(ndr, r->array);
7249                 } else {
7250                         r->array = NULL;
7251                 }
7252         }
7253         if (ndr_flags & NDR_BUFFERS) {
7254                 if (r->array) {
7255                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7256                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7258                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7259                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7260                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7261                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7262                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7263                         }
7264                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7265                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7266                         }
7267                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7268                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7269                 }
7270                 if (r->array) {
7271                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7272                 }
7273         }
7274         return NDR_ERR_SUCCESS;
7275 }
7276
7277 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7278 {
7279         uint32_t cntr_array_1;
7280         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7281         ndr->depth++;
7282         ndr_print_uint32(ndr, "count", r->count);
7283         ndr_print_ptr(ndr, "array", r->array);
7284         ndr->depth++;
7285         if (r->array) {
7286                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7287                 ndr->depth++;
7288                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7289                         char *idx_1=NULL;
7290                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7291                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7292                                 free(idx_1);
7293                         }
7294                 }
7295                 ndr->depth--;
7296         }
7297         ndr->depth--;
7298         ndr->depth--;
7299 }
7300
7301 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7302 {
7303         if (ndr_flags & NDR_SCALARS) {
7304                 NDR_CHECK(ndr_push_align(ndr, 4));
7305                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7306                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7307                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7308                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7310                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7311                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7316                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7317                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7318                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7319                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7320         }
7321         if (ndr_flags & NDR_BUFFERS) {
7322                 if (r->netbios_name) {
7323                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7326                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7327                 }
7328                 if (r->dns_name) {
7329                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7330                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7331                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7332                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7333                 }
7334                 if (r->site_name) {
7335                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7336                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7338                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7339                 }
7340                 if (r->site_dn) {
7341                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7344                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7345                 }
7346                 if (r->computer_dn) {
7347                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7348                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7350                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7351                 }
7352                 if (r->server_dn) {
7353                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7354                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7356                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7357                 }
7358                 if (r->ntds_dn) {
7359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7361                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7362                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7363                 }
7364         }
7365         return NDR_ERR_SUCCESS;
7366 }
7367
7368 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7369 {
7370         uint32_t _ptr_netbios_name;
7371         TALLOC_CTX *_mem_save_netbios_name_0;
7372         uint32_t _ptr_dns_name;
7373         TALLOC_CTX *_mem_save_dns_name_0;
7374         uint32_t _ptr_site_name;
7375         TALLOC_CTX *_mem_save_site_name_0;
7376         uint32_t _ptr_site_dn;
7377         TALLOC_CTX *_mem_save_site_dn_0;
7378         uint32_t _ptr_computer_dn;
7379         TALLOC_CTX *_mem_save_computer_dn_0;
7380         uint32_t _ptr_server_dn;
7381         TALLOC_CTX *_mem_save_server_dn_0;
7382         uint32_t _ptr_ntds_dn;
7383         TALLOC_CTX *_mem_save_ntds_dn_0;
7384         if (ndr_flags & NDR_SCALARS) {
7385                 NDR_CHECK(ndr_pull_align(ndr, 4));
7386                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7387                 if (_ptr_netbios_name) {
7388                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7389                 } else {
7390                         r->netbios_name = NULL;
7391                 }
7392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7393                 if (_ptr_dns_name) {
7394                         NDR_PULL_ALLOC(ndr, r->dns_name);
7395                 } else {
7396                         r->dns_name = NULL;
7397                 }
7398                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7399                 if (_ptr_site_name) {
7400                         NDR_PULL_ALLOC(ndr, r->site_name);
7401                 } else {
7402                         r->site_name = NULL;
7403                 }
7404                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7405                 if (_ptr_site_dn) {
7406                         NDR_PULL_ALLOC(ndr, r->site_dn);
7407                 } else {
7408                         r->site_dn = NULL;
7409                 }
7410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7411                 if (_ptr_computer_dn) {
7412                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7413                 } else {
7414                         r->computer_dn = NULL;
7415                 }
7416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7417                 if (_ptr_server_dn) {
7418                         NDR_PULL_ALLOC(ndr, r->server_dn);
7419                 } else {
7420                         r->server_dn = NULL;
7421                 }
7422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7423                 if (_ptr_ntds_dn) {
7424                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7425                 } else {
7426                         r->ntds_dn = NULL;
7427                 }
7428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7432                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7433                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7434                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7435                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7436         }
7437         if (ndr_flags & NDR_BUFFERS) {
7438                 if (r->netbios_name) {
7439                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7440                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7441                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7442                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7443                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7444                                 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));
7445                         }
7446                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7447                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7449                 }
7450                 if (r->dns_name) {
7451                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7452                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7453                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7454                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7455                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7456                                 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));
7457                         }
7458                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7459                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7460                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7461                 }
7462                 if (r->site_name) {
7463                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7464                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7465                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7466                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7467                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7468                                 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));
7469                         }
7470                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7471                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7472                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7473                 }
7474                 if (r->site_dn) {
7475                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7476                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7477                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7478                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7479                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7480                                 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));
7481                         }
7482                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7483                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7485                 }
7486                 if (r->computer_dn) {
7487                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7488                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7489                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7490                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7491                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7492                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7493                         }
7494                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7495                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7496                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7497                 }
7498                 if (r->server_dn) {
7499                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7500                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7501                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7502                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7503                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7504                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_dn), ndr_get_array_length(ndr, &r->server_dn));
7505                         }
7506                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7507                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7508                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7509                 }
7510                 if (r->ntds_dn) {
7511                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7512                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7515                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7516                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->ntds_dn), ndr_get_array_length(ndr, &r->ntds_dn));
7517                         }
7518                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7519                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7521                 }
7522         }
7523         return NDR_ERR_SUCCESS;
7524 }
7525
7526 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7527 {
7528         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7529         ndr->depth++;
7530         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7531         ndr->depth++;
7532         if (r->netbios_name) {
7533                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7534         }
7535         ndr->depth--;
7536         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7537         ndr->depth++;
7538         if (r->dns_name) {
7539                 ndr_print_string(ndr, "dns_name", r->dns_name);
7540         }
7541         ndr->depth--;
7542         ndr_print_ptr(ndr, "site_name", r->site_name);
7543         ndr->depth++;
7544         if (r->site_name) {
7545                 ndr_print_string(ndr, "site_name", r->site_name);
7546         }
7547         ndr->depth--;
7548         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7549         ndr->depth++;
7550         if (r->site_dn) {
7551                 ndr_print_string(ndr, "site_dn", r->site_dn);
7552         }
7553         ndr->depth--;
7554         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7555         ndr->depth++;
7556         if (r->computer_dn) {
7557                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7558         }
7559         ndr->depth--;
7560         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7561         ndr->depth++;
7562         if (r->server_dn) {
7563                 ndr_print_string(ndr, "server_dn", r->server_dn);
7564         }
7565         ndr->depth--;
7566         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7567         ndr->depth++;
7568         if (r->ntds_dn) {
7569                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7570         }
7571         ndr->depth--;
7572         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7573         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7574         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7575         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7576         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7577         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7578         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7579         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7580         ndr->depth--;
7581 }
7582
7583 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7584 {
7585         uint32_t cntr_array_1;
7586         if (ndr_flags & NDR_SCALARS) {
7587                 NDR_CHECK(ndr_push_align(ndr, 4));
7588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7589                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7590         }
7591         if (ndr_flags & NDR_BUFFERS) {
7592                 if (r->array) {
7593                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7594                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7595                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7596                         }
7597                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7598                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7599                         }
7600                 }
7601         }
7602         return NDR_ERR_SUCCESS;
7603 }
7604
7605 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7606 {
7607         uint32_t _ptr_array;
7608         uint32_t cntr_array_1;
7609         TALLOC_CTX *_mem_save_array_0;
7610         TALLOC_CTX *_mem_save_array_1;
7611         if (ndr_flags & NDR_SCALARS) {
7612                 NDR_CHECK(ndr_pull_align(ndr, 4));
7613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7614                 if (r->count > 10000) {
7615                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7616                 }
7617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7618                 if (_ptr_array) {
7619                         NDR_PULL_ALLOC(ndr, r->array);
7620                 } else {
7621                         r->array = NULL;
7622                 }
7623         }
7624         if (ndr_flags & NDR_BUFFERS) {
7625                 if (r->array) {
7626                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7627                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7628                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7629                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7630                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7631                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7632                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7633                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7634                         }
7635                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7636                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7637                         }
7638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7640                 }
7641                 if (r->array) {
7642                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7643                 }
7644         }
7645         return NDR_ERR_SUCCESS;
7646 }
7647
7648 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7649 {
7650         uint32_t cntr_array_1;
7651         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7652         ndr->depth++;
7653         ndr_print_uint32(ndr, "count", r->count);
7654         ndr_print_ptr(ndr, "array", r->array);
7655         ndr->depth++;
7656         if (r->array) {
7657                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7658                 ndr->depth++;
7659                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7660                         char *idx_1=NULL;
7661                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7662                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7663                                 free(idx_1);
7664                         }
7665                 }
7666                 ndr->depth--;
7667         }
7668         ndr->depth--;
7669         ndr->depth--;
7670 }
7671
7672 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7673 {
7674         if (ndr_flags & NDR_SCALARS) {
7675                 NDR_CHECK(ndr_push_align(ndr, 4));
7676                 {
7677                         uint32_t _flags_save_ipv4address = ndr->flags;
7678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7679                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7680                         ndr->flags = _flags_save_ipv4address;
7681                 }
7682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7688         }
7689         if (ndr_flags & NDR_BUFFERS) {
7690                 if (r->client_account) {
7691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7694                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7695                 }
7696         }
7697         return NDR_ERR_SUCCESS;
7698 }
7699
7700 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
7701 {
7702         uint32_t _ptr_client_account;
7703         TALLOC_CTX *_mem_save_client_account_0;
7704         if (ndr_flags & NDR_SCALARS) {
7705                 NDR_CHECK(ndr_pull_align(ndr, 4));
7706                 {
7707                         uint32_t _flags_save_ipv4address = ndr->flags;
7708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7709                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
7710                         ndr->flags = _flags_save_ipv4address;
7711                 }
7712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
7714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
7715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
7716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
7717                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
7718                 if (_ptr_client_account) {
7719                         NDR_PULL_ALLOC(ndr, r->client_account);
7720                 } else {
7721                         r->client_account = NULL;
7722                 }
7723         }
7724         if (ndr_flags & NDR_BUFFERS) {
7725                 if (r->client_account) {
7726                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7727                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
7728                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
7729                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
7730                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
7731                                 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));
7732                         }
7733                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
7734                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
7735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
7736                 }
7737         }
7738         return NDR_ERR_SUCCESS;
7739 }
7740
7741 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
7742 {
7743         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
7744         ndr->depth++;
7745         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
7746         ndr_print_uint32(ndr, "unknown2", r->unknown2);
7747         ndr_print_uint32(ndr, "connection_time", r->connection_time);
7748         ndr_print_uint32(ndr, "unknown4", r->unknown4);
7749         ndr_print_uint32(ndr, "unknown5", r->unknown5);
7750         ndr_print_uint32(ndr, "unknown6", r->unknown6);
7751         ndr_print_ptr(ndr, "client_account", r->client_account);
7752         ndr->depth++;
7753         if (r->client_account) {
7754                 ndr_print_string(ndr, "client_account", r->client_account);
7755         }
7756         ndr->depth--;
7757         ndr->depth--;
7758 }
7759
7760 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
7761 {
7762         uint32_t cntr_array_1;
7763         if (ndr_flags & NDR_SCALARS) {
7764                 NDR_CHECK(ndr_push_align(ndr, 4));
7765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7766                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7767         }
7768         if (ndr_flags & NDR_BUFFERS) {
7769                 if (r->array) {
7770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7771                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7772                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7773                         }
7774                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7775                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7776                         }
7777                 }
7778         }
7779         return NDR_ERR_SUCCESS;
7780 }
7781
7782 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
7783 {
7784         uint32_t _ptr_array;
7785         uint32_t cntr_array_1;
7786         TALLOC_CTX *_mem_save_array_0;
7787         TALLOC_CTX *_mem_save_array_1;
7788         if (ndr_flags & NDR_SCALARS) {
7789                 NDR_CHECK(ndr_pull_align(ndr, 4));
7790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7791                 if (r->count > 10000) {
7792                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7793                 }
7794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7795                 if (_ptr_array) {
7796                         NDR_PULL_ALLOC(ndr, r->array);
7797                 } else {
7798                         r->array = NULL;
7799                 }
7800         }
7801         if (ndr_flags & NDR_BUFFERS) {
7802                 if (r->array) {
7803                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7804                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7806                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7807                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7808                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7809                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7810                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7811                         }
7812                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7813                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7814                         }
7815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7816                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7817                 }
7818                 if (r->array) {
7819                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7820                 }
7821         }
7822         return NDR_ERR_SUCCESS;
7823 }
7824
7825 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
7826 {
7827         uint32_t cntr_array_1;
7828         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
7829         ndr->depth++;
7830         ndr_print_uint32(ndr, "count", r->count);
7831         ndr_print_ptr(ndr, "array", r->array);
7832         ndr->depth++;
7833         if (r->array) {
7834                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7835                 ndr->depth++;
7836                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7837                         char *idx_1=NULL;
7838                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7839                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
7840                                 free(idx_1);
7841                         }
7842                 }
7843                 ndr->depth--;
7844         }
7845         ndr->depth--;
7846         ndr->depth--;
7847 }
7848
7849 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
7850 {
7851         if (ndr_flags & NDR_SCALARS) {
7852                 int level = ndr_push_get_switch_value(ndr, r);
7853                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
7854                 switch (level) {
7855                         case DRSUAPI_DC_INFO_CTR_1: {
7856                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
7857                         break; }
7858
7859                         case DRSUAPI_DC_INFO_CTR_2: {
7860                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
7861                         break; }
7862
7863                         case DRSUAPI_DC_INFO_CTR_3: {
7864                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
7865                         break; }
7866
7867                         case DRSUAPI_DC_CONNECTION_CTR_01: {
7868                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
7869                         break; }
7870
7871                         default:
7872                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7873                 }
7874         }
7875         if (ndr_flags & NDR_BUFFERS) {
7876                 int level = ndr_push_get_switch_value(ndr, r);
7877                 switch (level) {
7878                         case DRSUAPI_DC_INFO_CTR_1:
7879                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
7880                         break;
7881
7882                         case DRSUAPI_DC_INFO_CTR_2:
7883                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
7884                         break;
7885
7886                         case DRSUAPI_DC_INFO_CTR_3:
7887                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
7888                         break;
7889
7890                         case DRSUAPI_DC_CONNECTION_CTR_01:
7891                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
7892                         break;
7893
7894                         default:
7895                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7896                 }
7897         }
7898         return NDR_ERR_SUCCESS;
7899 }
7900
7901 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
7902 {
7903         int level;
7904         int32_t _level;
7905         level = ndr_pull_get_switch_value(ndr, r);
7906         if (ndr_flags & NDR_SCALARS) {
7907                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
7908                 if (_level != level) {
7909                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7910                 }
7911                 switch (level) {
7912                         case DRSUAPI_DC_INFO_CTR_1: {
7913                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
7914                         break; }
7915
7916                         case DRSUAPI_DC_INFO_CTR_2: {
7917                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
7918                         break; }
7919
7920                         case DRSUAPI_DC_INFO_CTR_3: {
7921                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
7922                         break; }
7923
7924                         case DRSUAPI_DC_CONNECTION_CTR_01: {
7925                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
7926                         break; }
7927
7928                         default:
7929                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7930                 }
7931         }
7932         if (ndr_flags & NDR_BUFFERS) {
7933                 switch (level) {
7934                         case DRSUAPI_DC_INFO_CTR_1:
7935                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
7936                         break;
7937
7938                         case DRSUAPI_DC_INFO_CTR_2:
7939                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
7940                         break;
7941
7942                         case DRSUAPI_DC_INFO_CTR_3:
7943                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
7944                         break;
7945
7946                         case DRSUAPI_DC_CONNECTION_CTR_01:
7947                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
7948                         break;
7949
7950                         default:
7951                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7952                 }
7953         }
7954         return NDR_ERR_SUCCESS;
7955 }
7956
7957 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
7958 {
7959         int level;
7960         level = ndr_print_get_switch_value(ndr, r);
7961         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
7962         switch (level) {
7963                 case DRSUAPI_DC_INFO_CTR_1:
7964                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
7965                 break;
7966
7967                 case DRSUAPI_DC_INFO_CTR_2:
7968                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
7969                 break;
7970
7971                 case DRSUAPI_DC_INFO_CTR_3:
7972                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
7973                 break;
7974
7975                 case DRSUAPI_DC_CONNECTION_CTR_01:
7976                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
7977                 break;
7978
7979                 default:
7980                         ndr_print_bad_level(ndr, name, level);
7981         }
7982 }
7983
7984 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
7985 {
7986         if (ndr_flags & NDR_SCALARS) {
7987                 NDR_CHECK(ndr_push_align(ndr, 4));
7988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
7989                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
7990         }
7991         if (ndr_flags & NDR_BUFFERS) {
7992                 if (r->next_object) {
7993                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
7994                 }
7995                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
7996         }
7997         return NDR_ERR_SUCCESS;
7998 }
7999
8000 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8001 {
8002         uint32_t _ptr_next_object;
8003         TALLOC_CTX *_mem_save_next_object_0;
8004         if (ndr_flags & NDR_SCALARS) {
8005                 NDR_CHECK(ndr_pull_align(ndr, 4));
8006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8007                 if (_ptr_next_object) {
8008                         NDR_PULL_ALLOC(ndr, r->next_object);
8009                 } else {
8010                         r->next_object = NULL;
8011                 }
8012                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8013         }
8014         if (ndr_flags & NDR_BUFFERS) {
8015                 if (r->next_object) {
8016                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8017                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8018                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8020                 }
8021                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8022         }
8023         return NDR_ERR_SUCCESS;
8024 }
8025
8026 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8027 {
8028         if (ndr_flags & NDR_SCALARS) {
8029                 NDR_CHECK(ndr_push_align(ndr, 4));
8030                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8031         }
8032         if (ndr_flags & NDR_BUFFERS) {
8033                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8034         }
8035         return NDR_ERR_SUCCESS;
8036 }
8037
8038 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8039 {
8040         if (ndr_flags & NDR_SCALARS) {
8041                 NDR_CHECK(ndr_pull_align(ndr, 4));
8042                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8043         }
8044         if (ndr_flags & NDR_BUFFERS) {
8045                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8046         }
8047         return NDR_ERR_SUCCESS;
8048 }
8049
8050 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8051 {
8052         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8053         ndr->depth++;
8054         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8055         ndr->depth--;
8056 }
8057
8058 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8059 {
8060         if (ndr_flags & NDR_SCALARS) {
8061                 int level = ndr_push_get_switch_value(ndr, r);
8062                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8063                 switch (level) {
8064                         case 2: {
8065                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8066                         break; }
8067
8068                         default:
8069                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8070                 }
8071         }
8072         if (ndr_flags & NDR_BUFFERS) {
8073                 int level = ndr_push_get_switch_value(ndr, r);
8074                 switch (level) {
8075                         case 2:
8076                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8077                         break;
8078
8079                         default:
8080                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8081                 }
8082         }
8083         return NDR_ERR_SUCCESS;
8084 }
8085
8086 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8087 {
8088         int level;
8089         int32_t _level;
8090         level = ndr_pull_get_switch_value(ndr, r);
8091         if (ndr_flags & NDR_SCALARS) {
8092                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8093                 if (_level != level) {
8094                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8095                 }
8096                 switch (level) {
8097                         case 2: {
8098                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8099                         break; }
8100
8101                         default:
8102                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8103                 }
8104         }
8105         if (ndr_flags & NDR_BUFFERS) {
8106                 switch (level) {
8107                         case 2:
8108                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8109                         break;
8110
8111                         default:
8112                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8113                 }
8114         }
8115         return NDR_ERR_SUCCESS;
8116 }
8117
8118 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8119 {
8120         int level;
8121         level = ndr_print_get_switch_value(ndr, r);
8122         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8123         switch (level) {
8124                 case 2:
8125                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8126                 break;
8127
8128                 default:
8129                         ndr_print_bad_level(ndr, name, level);
8130         }
8131 }
8132
8133 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8134 {
8135         if (ndr_flags & NDR_SCALARS) {
8136                 NDR_CHECK(ndr_push_align(ndr, 4));
8137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8138                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8140                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8141         }
8142         if (ndr_flags & NDR_BUFFERS) {
8143         }
8144         return NDR_ERR_SUCCESS;
8145 }
8146
8147 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8148 {
8149         if (ndr_flags & NDR_SCALARS) {
8150                 NDR_CHECK(ndr_pull_align(ndr, 4));
8151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8154                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8155         }
8156         if (ndr_flags & NDR_BUFFERS) {
8157         }
8158         return NDR_ERR_SUCCESS;
8159 }
8160
8161 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8162 {
8163         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8164         ndr->depth++;
8165         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8166         ndr_print_WERROR(ndr, "status", r->status);
8167         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8168         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8169         ndr->depth--;
8170 }
8171
8172 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8173 {
8174         if (ndr_flags & NDR_SCALARS) {
8175                 NDR_CHECK(ndr_push_align(ndr, 4));
8176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8177                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8178         }
8179         if (ndr_flags & NDR_BUFFERS) {
8180                 if (r->data) {
8181                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8182                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8183                 }
8184         }
8185         return NDR_ERR_SUCCESS;
8186 }
8187
8188 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8189 {
8190         uint32_t _ptr_data;
8191         TALLOC_CTX *_mem_save_data_0;
8192         if (ndr_flags & NDR_SCALARS) {
8193                 NDR_CHECK(ndr_pull_align(ndr, 4));
8194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8195                 if (r->size > 10485760) {
8196                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8197                 }
8198                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8199                 if (_ptr_data) {
8200                         NDR_PULL_ALLOC(ndr, r->data);
8201                 } else {
8202                         r->data = NULL;
8203                 }
8204         }
8205         if (ndr_flags & NDR_BUFFERS) {
8206                 if (r->data) {
8207                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8208                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8210                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8211                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8213                 }
8214                 if (r->data) {
8215                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8216                 }
8217         }
8218         return NDR_ERR_SUCCESS;
8219 }
8220
8221 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8222 {
8223         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8224         ndr->depth++;
8225         ndr_print_uint32(ndr, "size", r->size);
8226         ndr_print_ptr(ndr, "data", r->data);
8227         ndr->depth++;
8228         if (r->data) {
8229                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8230         }
8231         ndr->depth--;
8232         ndr->depth--;
8233 }
8234
8235 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8236 {
8237         if (ndr_flags & NDR_SCALARS) {
8238                 NDR_CHECK(ndr_push_align(ndr, 4));
8239                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8240                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8242                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8243         }
8244         if (ndr_flags & NDR_BUFFERS) {
8245                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8246         }
8247         return NDR_ERR_SUCCESS;
8248 }
8249
8250 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8251 {
8252         if (ndr_flags & NDR_SCALARS) {
8253                 NDR_CHECK(ndr_pull_align(ndr, 4));
8254                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8255                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8257                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8258         }
8259         if (ndr_flags & NDR_BUFFERS) {
8260                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8261         }
8262         return NDR_ERR_SUCCESS;
8263 }
8264
8265 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8266 {
8267         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8268         ndr->depth++;
8269         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8270         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8271         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8272         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8273         ndr->depth--;
8274 }
8275
8276 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8277 {
8278         if (ndr_flags & NDR_SCALARS) {
8279                 NDR_CHECK(ndr_push_align(ndr, 4));
8280                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8281                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8282         }
8283         if (ndr_flags & NDR_BUFFERS) {
8284                 if (r->next) {
8285                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8286                 }
8287                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8288         }
8289         return NDR_ERR_SUCCESS;
8290 }
8291
8292 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8293 {
8294         uint32_t _ptr_next;
8295         TALLOC_CTX *_mem_save_next_0;
8296         if (ndr_flags & NDR_SCALARS) {
8297                 NDR_CHECK(ndr_pull_align(ndr, 4));
8298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8299                 if (_ptr_next) {
8300                         NDR_PULL_ALLOC(ndr, r->next);
8301                 } else {
8302                         r->next = NULL;
8303                 }
8304                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8305         }
8306         if (ndr_flags & NDR_BUFFERS) {
8307                 if (r->next) {
8308                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8309                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8310                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8312                 }
8313                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8314         }
8315         return NDR_ERR_SUCCESS;
8316 }
8317
8318 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8319 {
8320         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8321         ndr->depth++;
8322         ndr_print_ptr(ndr, "next", r->next);
8323         ndr->depth++;
8324         if (r->next) {
8325                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8326         }
8327         ndr->depth--;
8328         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8329         ndr->depth--;
8330 }
8331
8332 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8333 {
8334         if (ndr_flags & NDR_SCALARS) {
8335                 NDR_CHECK(ndr_push_align(ndr, 4));
8336                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8337                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8338                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8339         }
8340         if (ndr_flags & NDR_BUFFERS) {
8341                 if (r->id) {
8342                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8343                 }
8344                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8345         }
8346         return NDR_ERR_SUCCESS;
8347 }
8348
8349 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8350 {
8351         uint32_t _ptr_id;
8352         TALLOC_CTX *_mem_save_id_0;
8353         if (ndr_flags & NDR_SCALARS) {
8354                 NDR_CHECK(ndr_pull_align(ndr, 4));
8355                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8356                 if (_ptr_id) {
8357                         NDR_PULL_ALLOC(ndr, r->id);
8358                 } else {
8359                         r->id = NULL;
8360                 }
8361                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8362                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8363         }
8364         if (ndr_flags & NDR_BUFFERS) {
8365                 if (r->id) {
8366                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8367                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8368                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8370                 }
8371                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8372         }
8373         return NDR_ERR_SUCCESS;
8374 }
8375
8376 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8377 {
8378         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8379         ndr->depth++;
8380         ndr_print_ptr(ndr, "id", r->id);
8381         ndr->depth++;
8382         if (r->id) {
8383                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8384         }
8385         ndr->depth--;
8386         ndr_print_WERROR(ndr, "status", r->status);
8387         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8388         ndr->depth--;
8389 }
8390
8391 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8392 {
8393         if (ndr_flags & NDR_SCALARS) {
8394                 int level = ndr_push_get_switch_value(ndr, r);
8395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8396                 switch (level) {
8397                         case 1: {
8398                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8399                         break; }
8400
8401                         case 4: {
8402                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8403                         break; }
8404
8405                         case 5: {
8406                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8407                         break; }
8408
8409                         case 6: {
8410                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8411                         break; }
8412
8413                         case 7: {
8414                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
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 1:
8425                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8426                         break;
8427
8428                         case 4:
8429                         break;
8430
8431                         case 5:
8432                         break;
8433
8434                         case 6:
8435                         break;
8436
8437                         case 7:
8438                         break;
8439
8440                         default:
8441                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8442                 }
8443         }
8444         return NDR_ERR_SUCCESS;
8445 }
8446
8447 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8448 {
8449         int level;
8450         uint32_t _level;
8451         level = ndr_pull_get_switch_value(ndr, r);
8452         if (ndr_flags & NDR_SCALARS) {
8453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8454                 if (_level != level) {
8455                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8456                 }
8457                 switch (level) {
8458                         case 1: {
8459                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8460                         break; }
8461
8462                         case 4: {
8463                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8464                         break; }
8465
8466                         case 5: {
8467                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8468                         break; }
8469
8470                         case 6: {
8471                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8472                         break; }
8473
8474                         case 7: {
8475                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8476                         break; }
8477
8478                         default:
8479                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8480                 }
8481         }
8482         if (ndr_flags & NDR_BUFFERS) {
8483                 switch (level) {
8484                         case 1:
8485                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8486                         break;
8487
8488                         case 4:
8489                         break;
8490
8491                         case 5:
8492                         break;
8493
8494                         case 6:
8495                         break;
8496
8497                         case 7:
8498                         break;
8499
8500                         default:
8501                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8502                 }
8503         }
8504         return NDR_ERR_SUCCESS;
8505 }
8506
8507 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8508 {
8509         int level;
8510         level = ndr_print_get_switch_value(ndr, r);
8511         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8512         switch (level) {
8513                 case 1:
8514                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8515                 break;
8516
8517                 case 4:
8518                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8519                 break;
8520
8521                 case 5:
8522                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8523                 break;
8524
8525                 case 6:
8526                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8527                 break;
8528
8529                 case 7:
8530                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8531                 break;
8532
8533                 default:
8534                         ndr_print_bad_level(ndr, name, level);
8535         }
8536 }
8537
8538 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8539 {
8540         if (ndr_flags & NDR_SCALARS) {
8541                 NDR_CHECK(ndr_push_align(ndr, 4));
8542                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8545         }
8546         if (ndr_flags & NDR_BUFFERS) {
8547                 if (r->info) {
8548                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8549                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8550                 }
8551         }
8552         return NDR_ERR_SUCCESS;
8553 }
8554
8555 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8556 {
8557         uint32_t _ptr_info;
8558         TALLOC_CTX *_mem_save_info_0;
8559         if (ndr_flags & NDR_SCALARS) {
8560                 NDR_CHECK(ndr_pull_align(ndr, 4));
8561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8564                 if (_ptr_info) {
8565                         NDR_PULL_ALLOC(ndr, r->info);
8566                 } else {
8567                         r->info = NULL;
8568                 }
8569         }
8570         if (ndr_flags & NDR_BUFFERS) {
8571                 if (r->info) {
8572                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8573                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8574                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8575                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8576                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8577                 }
8578         }
8579         return NDR_ERR_SUCCESS;
8580 }
8581
8582 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8583 {
8584         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8585         ndr->depth++;
8586         ndr_print_WERROR(ndr, "status", r->status);
8587         ndr_print_uint32(ndr, "level", r->level);
8588         ndr_print_ptr(ndr, "info", r->info);
8589         ndr->depth++;
8590         if (r->info) {
8591                 ndr_print_set_switch_value(ndr, r->info, r->level);
8592                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8593         }
8594         ndr->depth--;
8595         ndr->depth--;
8596 }
8597
8598 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8599 {
8600         if (ndr_flags & NDR_SCALARS) {
8601                 int level = ndr_push_get_switch_value(ndr, r);
8602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8603                 switch (level) {
8604                         case 1: {
8605                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8606                         break; }
8607
8608                         default:
8609                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8610                 }
8611         }
8612         if (ndr_flags & NDR_BUFFERS) {
8613                 int level = ndr_push_get_switch_value(ndr, r);
8614                 switch (level) {
8615                         case 1:
8616                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8617                         break;
8618
8619                         default:
8620                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8621                 }
8622         }
8623         return NDR_ERR_SUCCESS;
8624 }
8625
8626 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8627 {
8628         int level;
8629         uint32_t _level;
8630         level = ndr_pull_get_switch_value(ndr, r);
8631         if (ndr_flags & NDR_SCALARS) {
8632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8633                 if (_level != level) {
8634                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8635                 }
8636                 switch (level) {
8637                         case 1: {
8638                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8639                         break; }
8640
8641                         default:
8642                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8643                 }
8644         }
8645         if (ndr_flags & NDR_BUFFERS) {
8646                 switch (level) {
8647                         case 1:
8648                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8649                         break;
8650
8651                         default:
8652                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8653                 }
8654         }
8655         return NDR_ERR_SUCCESS;
8656 }
8657
8658 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8659 {
8660         int level;
8661         level = ndr_print_get_switch_value(ndr, r);
8662         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8663         switch (level) {
8664                 case 1:
8665                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8666                 break;
8667
8668                 default:
8669                         ndr_print_bad_level(ndr, name, level);
8670         }
8671 }
8672
8673 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8674 {
8675         if (ndr_flags & NDR_SCALARS) {
8676                 NDR_CHECK(ndr_push_align(ndr, 4));
8677                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
8678                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8679         }
8680         if (ndr_flags & NDR_BUFFERS) {
8681                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8682         }
8683         return NDR_ERR_SUCCESS;
8684 }
8685
8686 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
8687 {
8688         if (ndr_flags & NDR_SCALARS) {
8689                 NDR_CHECK(ndr_pull_align(ndr, 4));
8690                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
8691                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8692         }
8693         if (ndr_flags & NDR_BUFFERS) {
8694                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8695         }
8696         return NDR_ERR_SUCCESS;
8697 }
8698
8699 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8700 {
8701         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
8702         ndr->depth++;
8703         ndr_print_GUID(ndr, "guid", &r->guid);
8704         ndr_print_dom_sid28(ndr, "sid", &r->sid);
8705         ndr->depth--;
8706 }
8707
8708 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
8709 {
8710         uint32_t cntr_objects_1;
8711         if (ndr_flags & NDR_SCALARS) {
8712                 NDR_CHECK(ndr_push_align(ndr, 4));
8713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8715                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
8718         }
8719         if (ndr_flags & NDR_BUFFERS) {
8720                 if (r->id) {
8721                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8722                 }
8723                 if (r->objects) {
8724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8725                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8726                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8727                         }
8728                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8729                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8730                         }
8731                 }
8732         }
8733         return NDR_ERR_SUCCESS;
8734 }
8735
8736 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
8737 {
8738         uint32_t _ptr_id;
8739         TALLOC_CTX *_mem_save_id_0;
8740         uint32_t _ptr_objects;
8741         uint32_t cntr_objects_1;
8742         TALLOC_CTX *_mem_save_objects_0;
8743         TALLOC_CTX *_mem_save_objects_1;
8744         if (ndr_flags & NDR_SCALARS) {
8745                 NDR_CHECK(ndr_pull_align(ndr, 4));
8746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8747                 if (_ptr_id) {
8748                         NDR_PULL_ALLOC(ndr, r->id);
8749                 } else {
8750                         r->id = NULL;
8751                 }
8752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8753                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8755                 if (r->count > 10000) {
8756                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8757                 }
8758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
8759                 if (_ptr_objects) {
8760                         NDR_PULL_ALLOC(ndr, r->objects);
8761                 } else {
8762                         r->objects = NULL;
8763                 }
8764         }
8765         if (ndr_flags & NDR_BUFFERS) {
8766                 if (r->id) {
8767                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8768                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8769                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8770                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8771                 }
8772                 if (r->objects) {
8773                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
8774                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8775                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
8776                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
8777                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
8778                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8779                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8780                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8781                         }
8782                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8783                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8784                         }
8785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
8786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
8787                 }
8788                 if (r->objects) {
8789                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
8790                 }
8791         }
8792         return NDR_ERR_SUCCESS;
8793 }
8794
8795 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
8796 {
8797         uint32_t cntr_objects_1;
8798         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
8799         ndr->depth++;
8800         ndr_print_ptr(ndr, "id", r->id);
8801         ndr->depth++;
8802         if (r->id) {
8803                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8804         }
8805         ndr->depth--;
8806         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8807         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8808         ndr_print_uint32(ndr, "count", r->count);
8809         ndr_print_ptr(ndr, "objects", r->objects);
8810         ndr->depth++;
8811         if (r->objects) {
8812                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
8813                 ndr->depth++;
8814                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
8815                         char *idx_1=NULL;
8816                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
8817                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
8818                                 free(idx_1);
8819                         }
8820                 }
8821                 ndr->depth--;
8822         }
8823         ndr->depth--;
8824         ndr->depth--;
8825 }
8826
8827 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
8828 {
8829         uint32_t cntr_objects_1;
8830         if (ndr_flags & NDR_SCALARS) {
8831                 NDR_CHECK(ndr_push_align(ndr, 4));
8832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
8835                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
8837         }
8838         if (ndr_flags & NDR_BUFFERS) {
8839                 if (r->id) {
8840                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8841                 }
8842                 if (r->error) {
8843                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
8844                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
8845                 }
8846                 if (r->objects) {
8847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8848                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8849                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8850                         }
8851                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8852                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8853                         }
8854                 }
8855         }
8856         return NDR_ERR_SUCCESS;
8857 }
8858
8859 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
8860 {
8861         uint32_t _ptr_id;
8862         TALLOC_CTX *_mem_save_id_0;
8863         uint32_t _ptr_error;
8864         TALLOC_CTX *_mem_save_error_0;
8865         uint32_t _ptr_objects;
8866         uint32_t cntr_objects_1;
8867         TALLOC_CTX *_mem_save_objects_0;
8868         TALLOC_CTX *_mem_save_objects_1;
8869         if (ndr_flags & NDR_SCALARS) {
8870                 NDR_CHECK(ndr_pull_align(ndr, 4));
8871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8872                 if (_ptr_id) {
8873                         NDR_PULL_ALLOC(ndr, r->id);
8874                 } else {
8875                         r->id = NULL;
8876                 }
8877                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
8879                 if (_ptr_error) {
8880                         NDR_PULL_ALLOC(ndr, r->error);
8881                 } else {
8882                         r->error = NULL;
8883                 }
8884                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8885                 if (r->count > 10000) {
8886                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8887                 }
8888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
8889                 if (_ptr_objects) {
8890                         NDR_PULL_ALLOC(ndr, r->objects);
8891                 } else {
8892                         r->objects = NULL;
8893                 }
8894         }
8895         if (ndr_flags & NDR_BUFFERS) {
8896                 if (r->id) {
8897                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8898                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8899                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8901                 }
8902                 if (r->error) {
8903                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
8904                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
8905                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
8906                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
8907                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
8908                 }
8909                 if (r->objects) {
8910                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
8911                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8912                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
8913                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
8914                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
8915                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8916                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8917                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8918                         }
8919                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8920                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8921                         }
8922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
8923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
8924                 }
8925                 if (r->objects) {
8926                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
8927                 }
8928         }
8929         return NDR_ERR_SUCCESS;
8930 }
8931
8932 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
8933 {
8934         uint32_t cntr_objects_1;
8935         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
8936         ndr->depth++;
8937         ndr_print_ptr(ndr, "id", r->id);
8938         ndr->depth++;
8939         if (r->id) {
8940                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8941         }
8942         ndr->depth--;
8943         ndr_print_uint32(ndr, "level", r->level);
8944         ndr_print_ptr(ndr, "error", r->error);
8945         ndr->depth++;
8946         if (r->error) {
8947                 ndr_print_set_switch_value(ndr, r->error, r->level);
8948                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
8949         }
8950         ndr->depth--;
8951         ndr_print_uint32(ndr, "count", r->count);
8952         ndr_print_ptr(ndr, "objects", r->objects);
8953         ndr->depth++;
8954         if (r->objects) {
8955                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
8956                 ndr->depth++;
8957                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
8958                         char *idx_1=NULL;
8959                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
8960                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
8961                                 free(idx_1);
8962                         }
8963                 }
8964                 ndr->depth--;
8965         }
8966         ndr->depth--;
8967         ndr->depth--;
8968 }
8969
8970 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
8971 {
8972         if (ndr_flags & NDR_SCALARS) {
8973                 int level = ndr_push_get_switch_value(ndr, r);
8974                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8975                 switch (level) {
8976                         case 2: {
8977                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
8978                         break; }
8979
8980                         case 3: {
8981                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
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         if (ndr_flags & NDR_BUFFERS) {
8989                 int level = ndr_push_get_switch_value(ndr, r);
8990                 switch (level) {
8991                         case 2:
8992                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8993                         break;
8994
8995                         case 3:
8996                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8997                         break;
8998
8999                         default:
9000                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9001                 }
9002         }
9003         return NDR_ERR_SUCCESS;
9004 }
9005
9006 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9007 {
9008         int level;
9009         int32_t _level;
9010         level = ndr_pull_get_switch_value(ndr, r);
9011         if (ndr_flags & NDR_SCALARS) {
9012                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9013                 if (_level != level) {
9014                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9015                 }
9016                 switch (level) {
9017                         case 2: {
9018                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9019                         break; }
9020
9021                         case 3: {
9022                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9023                         break; }
9024
9025                         default:
9026                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9027                 }
9028         }
9029         if (ndr_flags & NDR_BUFFERS) {
9030                 switch (level) {
9031                         case 2:
9032                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9033                         break;
9034
9035                         case 3:
9036                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9037                         break;
9038
9039                         default:
9040                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9041                 }
9042         }
9043         return NDR_ERR_SUCCESS;
9044 }
9045
9046 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9047 {
9048         int level;
9049         level = ndr_print_get_switch_value(ndr, r);
9050         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9051         switch (level) {
9052                 case 2:
9053                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9054                 break;
9055
9056                 case 3:
9057                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9058                 break;
9059
9060                 default:
9061                         ndr_print_bad_level(ndr, name, level);
9062         }
9063 }
9064
9065 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9066 {
9067         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9068         return NDR_ERR_SUCCESS;
9069 }
9070
9071 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9072 {
9073         uint32_t v;
9074         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9075         *r = v;
9076         return NDR_ERR_SUCCESS;
9077 }
9078
9079 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9080 {
9081         const char *val = NULL;
9082
9083         switch (r) {
9084                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9085                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9086         }
9087         ndr_print_enum(ndr, name, "ENUM", val, r);
9088 }
9089
9090 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9091 {
9092         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9093         return NDR_ERR_SUCCESS;
9094 }
9095
9096 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9097 {
9098         uint32_t v;
9099         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9100         *r = v;
9101         return NDR_ERR_SUCCESS;
9102 }
9103
9104 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9105 {
9106         const char *val = NULL;
9107
9108         switch (r) {
9109                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9110                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9111                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9112                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9113                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9114                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9115                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9116                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9117                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9118                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9119                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9120                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9121                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9122                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9123                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9124         }
9125         ndr_print_enum(ndr, name, "ENUM", val, r);
9126 }
9127
9128 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9129 {
9130         if (ndr_flags & NDR_SCALARS) {
9131                 NDR_CHECK(ndr_push_align(ndr, 4));
9132                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9133                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9134                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9135         }
9136         if (ndr_flags & NDR_BUFFERS) {
9137                 if (r->object_dn) {
9138                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9139                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9140                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9141                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9142                 }
9143         }
9144         return NDR_ERR_SUCCESS;
9145 }
9146
9147 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9148 {
9149         uint32_t _ptr_object_dn;
9150         TALLOC_CTX *_mem_save_object_dn_0;
9151         if (ndr_flags & NDR_SCALARS) {
9152                 NDR_CHECK(ndr_pull_align(ndr, 4));
9153                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9155                 if (_ptr_object_dn) {
9156                         NDR_PULL_ALLOC(ndr, r->object_dn);
9157                 } else {
9158                         r->object_dn = NULL;
9159                 }
9160                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9161         }
9162         if (ndr_flags & NDR_BUFFERS) {
9163                 if (r->object_dn) {
9164                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9165                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9166                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9167                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9168                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9169                                 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));
9170                         }
9171                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9172                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9174                 }
9175         }
9176         return NDR_ERR_SUCCESS;
9177 }
9178
9179 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9180 {
9181         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9182         ndr->depth++;
9183         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9184         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9185         ndr->depth++;
9186         if (r->object_dn) {
9187                 ndr_print_string(ndr, "object_dn", r->object_dn);
9188         }
9189         ndr->depth--;
9190         ndr_print_GUID(ndr, "guid1", &r->guid1);
9191         ndr->depth--;
9192 }
9193
9194 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9195 {
9196         if (ndr_flags & NDR_SCALARS) {
9197                 NDR_CHECK(ndr_push_align(ndr, 4));
9198                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9199                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9200                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
9205         }
9206         if (ndr_flags & NDR_BUFFERS) {
9207                 if (r->object_dn) {
9208                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9209                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9212                 }
9213                 if (r->string1) {
9214                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9215                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9216                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9217                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9218                 }
9219                 if (r->string2) {
9220                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9221                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9222                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9223                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9224                 }
9225         }
9226         return NDR_ERR_SUCCESS;
9227 }
9228
9229 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9230 {
9231         uint32_t _ptr_object_dn;
9232         TALLOC_CTX *_mem_save_object_dn_0;
9233         uint32_t _ptr_string1;
9234         TALLOC_CTX *_mem_save_string1_0;
9235         uint32_t _ptr_string2;
9236         TALLOC_CTX *_mem_save_string2_0;
9237         if (ndr_flags & NDR_SCALARS) {
9238                 NDR_CHECK(ndr_pull_align(ndr, 4));
9239                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9241                 if (_ptr_object_dn) {
9242                         NDR_PULL_ALLOC(ndr, r->object_dn);
9243                 } else {
9244                         r->object_dn = NULL;
9245                 }
9246                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9247                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9248                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9249                 if (_ptr_string1) {
9250                         NDR_PULL_ALLOC(ndr, r->string1);
9251                 } else {
9252                         r->string1 = NULL;
9253                 }
9254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9255                 if (_ptr_string2) {
9256                         NDR_PULL_ALLOC(ndr, r->string2);
9257                 } else {
9258                         r->string2 = NULL;
9259                 }
9260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
9261         }
9262         if (ndr_flags & NDR_BUFFERS) {
9263                 if (r->object_dn) {
9264                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9265                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9266                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9267                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9268                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9269                                 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));
9270                         }
9271                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9272                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9274                 }
9275                 if (r->string1) {
9276                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9277                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9278                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9279                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9280                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9281                                 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));
9282                         }
9283                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9284                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9286                 }
9287                 if (r->string2) {
9288                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9289                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9290                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9291                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9292                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9293                                 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));
9294                         }
9295                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9296                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9298                 }
9299         }
9300         return NDR_ERR_SUCCESS;
9301 }
9302
9303 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9304 {
9305         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9306         ndr->depth++;
9307         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9308         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9309         ndr->depth++;
9310         if (r->object_dn) {
9311                 ndr_print_string(ndr, "object_dn", r->object_dn);
9312         }
9313         ndr->depth--;
9314         ndr_print_GUID(ndr, "guid1", &r->guid1);
9315         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9316         ndr_print_ptr(ndr, "string1", r->string1);
9317         ndr->depth++;
9318         if (r->string1) {
9319                 ndr_print_string(ndr, "string1", r->string1);
9320         }
9321         ndr->depth--;
9322         ndr_print_ptr(ndr, "string2", r->string2);
9323         ndr->depth++;
9324         if (r->string2) {
9325                 ndr_print_string(ndr, "string2", r->string2);
9326         }
9327         ndr->depth--;
9328         ndr_print_uint32(ndr, "unknown2", r->unknown2);
9329         ndr->depth--;
9330 }
9331
9332 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9333 {
9334         if (ndr_flags & NDR_SCALARS) {
9335                 int level = ndr_push_get_switch_value(ndr, r);
9336                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9337                 switch (level) {
9338                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9339                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9340                         break; }
9341
9342                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9343                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9344                         break; }
9345
9346                         default:
9347                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9348                 }
9349         }
9350         if (ndr_flags & NDR_BUFFERS) {
9351                 int level = ndr_push_get_switch_value(ndr, r);
9352                 switch (level) {
9353                         case DRSUAPI_DS_REPLICA_GET_INFO:
9354                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9355                         break;
9356
9357                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9358                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9359                         break;
9360
9361                         default:
9362                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9363                 }
9364         }
9365         return NDR_ERR_SUCCESS;
9366 }
9367
9368 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9369 {
9370         int level;
9371         uint32_t _level;
9372         level = ndr_pull_get_switch_value(ndr, r);
9373         if (ndr_flags & NDR_SCALARS) {
9374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9375                 if (_level != level) {
9376                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9377                 }
9378                 switch (level) {
9379                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9380                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9381                         break; }
9382
9383                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9384                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9385                         break; }
9386
9387                         default:
9388                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9389                 }
9390         }
9391         if (ndr_flags & NDR_BUFFERS) {
9392                 switch (level) {
9393                         case DRSUAPI_DS_REPLICA_GET_INFO:
9394                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9395                         break;
9396
9397                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9398                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9399                         break;
9400
9401                         default:
9402                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9403                 }
9404         }
9405         return NDR_ERR_SUCCESS;
9406 }
9407
9408 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9409 {
9410         int level;
9411         level = ndr_print_get_switch_value(ndr, r);
9412         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9413         switch (level) {
9414                 case DRSUAPI_DS_REPLICA_GET_INFO:
9415                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9416                 break;
9417
9418                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9419                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9420                 break;
9421
9422                 default:
9423                         ndr_print_bad_level(ndr, name, level);
9424         }
9425 }
9426
9427 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9428 {
9429         if (ndr_flags & NDR_SCALARS) {
9430                 NDR_CHECK(ndr_push_align(ndr, 8));
9431                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9435                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
9436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9437                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9438                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9439                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9440                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9441                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9442                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9443                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9444                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9447         }
9448         if (ndr_flags & NDR_BUFFERS) {
9449                 if (r->naming_context_dn) {
9450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9453                         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));
9454                 }
9455                 if (r->source_dsa_obj_dn) {
9456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9459                         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));
9460                 }
9461                 if (r->source_dsa_address) {
9462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9465                         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));
9466                 }
9467                 if (r->transport_obj_dn) {
9468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9471                         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));
9472                 }
9473         }
9474         return NDR_ERR_SUCCESS;
9475 }
9476
9477 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9478 {
9479         uint32_t _ptr_naming_context_dn;
9480         TALLOC_CTX *_mem_save_naming_context_dn_0;
9481         uint32_t _ptr_source_dsa_obj_dn;
9482         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9483         uint32_t _ptr_source_dsa_address;
9484         TALLOC_CTX *_mem_save_source_dsa_address_0;
9485         uint32_t _ptr_transport_obj_dn;
9486         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9487         if (ndr_flags & NDR_SCALARS) {
9488                 NDR_CHECK(ndr_pull_align(ndr, 8));
9489                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9490                 if (_ptr_naming_context_dn) {
9491                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9492                 } else {
9493                         r->naming_context_dn = NULL;
9494                 }
9495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9496                 if (_ptr_source_dsa_obj_dn) {
9497                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9498                 } else {
9499                         r->source_dsa_obj_dn = NULL;
9500                 }
9501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9502                 if (_ptr_source_dsa_address) {
9503                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9504                 } else {
9505                         r->source_dsa_address = NULL;
9506                 }
9507                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9508                 if (_ptr_transport_obj_dn) {
9509                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9510                 } else {
9511                         r->transport_obj_dn = NULL;
9512                 }
9513                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
9514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9515                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9516                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9517                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9518                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9519                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9520                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9521                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
9522                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
9523                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
9524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
9525         }
9526         if (ndr_flags & NDR_BUFFERS) {
9527                 if (r->naming_context_dn) {
9528                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9529                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
9530                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
9531                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
9532                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
9533                                 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));
9534                         }
9535                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
9536                         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));
9537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
9538                 }
9539                 if (r->source_dsa_obj_dn) {
9540                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9541                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
9542                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
9543                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
9544                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
9545                                 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));
9546                         }
9547                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
9548                         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));
9549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
9550                 }
9551                 if (r->source_dsa_address) {
9552                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
9553                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
9554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
9555                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
9556                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
9557                                 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));
9558                         }
9559                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
9560                         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));
9561                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
9562                 }
9563                 if (r->transport_obj_dn) {
9564                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9565                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
9566                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
9567                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
9568                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
9569                                 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));
9570                         }
9571                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
9572                         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));
9573                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
9574                 }
9575         }
9576         return NDR_ERR_SUCCESS;
9577 }
9578
9579 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
9580 {
9581         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
9582         ndr->depth++;
9583         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
9584         ndr->depth++;
9585         if (r->naming_context_dn) {
9586                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
9587         }
9588         ndr->depth--;
9589         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
9590         ndr->depth++;
9591         if (r->source_dsa_obj_dn) {
9592                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
9593         }
9594         ndr->depth--;
9595         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
9596         ndr->depth++;
9597         if (r->source_dsa_address) {
9598                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
9599         }
9600         ndr->depth--;
9601         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
9602         ndr->depth++;
9603         if (r->transport_obj_dn) {
9604                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
9605         }
9606         ndr->depth--;
9607         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
9608         ndr_print_uint32(ndr, "reserved", r->reserved);
9609         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
9610         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
9611         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
9612         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
9613         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
9614         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
9615         ndr_print_NTTIME(ndr, "last_success", r->last_success);
9616         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
9617         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
9618         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
9619         ndr->depth--;
9620 }
9621
9622 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
9623 {
9624         uint32_t cntr_array_0;
9625         if (ndr_flags & NDR_SCALARS) {
9626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9627                 NDR_CHECK(ndr_push_align(ndr, 8));
9628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9630                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9631                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9632                 }
9633         }
9634         if (ndr_flags & NDR_BUFFERS) {
9635                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9636                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9637                 }
9638         }
9639         return NDR_ERR_SUCCESS;
9640 }
9641
9642 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
9643 {
9644         uint32_t cntr_array_0;
9645         TALLOC_CTX *_mem_save_array_0;
9646         if (ndr_flags & NDR_SCALARS) {
9647                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9648                 NDR_CHECK(ndr_pull_align(ndr, 8));
9649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9651                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9652                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9653                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9654                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9655                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9656                 }
9657                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9658                 if (r->array) {
9659                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9660                 }
9661         }
9662         if (ndr_flags & NDR_BUFFERS) {
9663                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9664                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9665                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9666                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9667                 }
9668                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9669         }
9670         return NDR_ERR_SUCCESS;
9671 }
9672
9673 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
9674 {
9675         uint32_t cntr_array_0;
9676         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
9677         ndr->depth++;
9678         ndr_print_uint32(ndr, "count", r->count);
9679         ndr_print_uint32(ndr, "reserved", r->reserved);
9680         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9681         ndr->depth++;
9682         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9683                 char *idx_0=NULL;
9684                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9685                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
9686                         free(idx_0);
9687                 }
9688         }
9689         ndr->depth--;
9690         ndr->depth--;
9691 }
9692
9693 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
9694 {
9695         uint32_t cntr_array_0;
9696         if (ndr_flags & NDR_SCALARS) {
9697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9698                 NDR_CHECK(ndr_push_align(ndr, 8));
9699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9701                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9702                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9703                 }
9704         }
9705         if (ndr_flags & NDR_BUFFERS) {
9706         }
9707         return NDR_ERR_SUCCESS;
9708 }
9709
9710 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
9711 {
9712         uint32_t cntr_array_0;
9713         TALLOC_CTX *_mem_save_array_0;
9714         if (ndr_flags & NDR_SCALARS) {
9715                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9716                 NDR_CHECK(ndr_pull_align(ndr, 8));
9717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9719                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9720                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9721                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9722                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9723                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9724                 }
9725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9726                 if (r->array) {
9727                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9728                 }
9729         }
9730         if (ndr_flags & NDR_BUFFERS) {
9731         }
9732         return NDR_ERR_SUCCESS;
9733 }
9734
9735 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
9736 {
9737         uint32_t cntr_array_0;
9738         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
9739         ndr->depth++;
9740         ndr_print_uint32(ndr, "count", r->count);
9741         ndr_print_uint32(ndr, "reserved", r->reserved);
9742         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9743         ndr->depth++;
9744         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9745                 char *idx_0=NULL;
9746                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9747                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
9748                         free(idx_0);
9749                 }
9750         }
9751         ndr->depth--;
9752         ndr->depth--;
9753 }
9754
9755 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
9756 {
9757         if (ndr_flags & NDR_SCALARS) {
9758                 NDR_CHECK(ndr_push_align(ndr, 8));
9759                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
9760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
9761                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
9762                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9763                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
9764                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
9765         }
9766         if (ndr_flags & NDR_BUFFERS) {
9767                 if (r->attribute_name) {
9768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9769                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9771                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9772                 }
9773         }
9774         return NDR_ERR_SUCCESS;
9775 }
9776
9777 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
9778 {
9779         uint32_t _ptr_attribute_name;
9780         TALLOC_CTX *_mem_save_attribute_name_0;
9781         if (ndr_flags & NDR_SCALARS) {
9782                 NDR_CHECK(ndr_pull_align(ndr, 8));
9783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
9784                 if (_ptr_attribute_name) {
9785                         NDR_PULL_ALLOC(ndr, r->attribute_name);
9786                 } else {
9787                         r->attribute_name = NULL;
9788                 }
9789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
9790                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
9791                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9792                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
9793                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
9794         }
9795         if (ndr_flags & NDR_BUFFERS) {
9796                 if (r->attribute_name) {
9797                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9798                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
9799                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
9800                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
9801                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
9802                                 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));
9803                         }
9804                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
9805                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
9806                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
9807                 }
9808         }
9809         return NDR_ERR_SUCCESS;
9810 }
9811
9812 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
9813 {
9814         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
9815         ndr->depth++;
9816         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
9817         ndr->depth++;
9818         if (r->attribute_name) {
9819                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
9820         }
9821         ndr->depth--;
9822         ndr_print_uint32(ndr, "version", r->version);
9823         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
9824         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
9825         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
9826         ndr_print_hyper(ndr, "local_usn", r->local_usn);
9827         ndr->depth--;
9828 }
9829
9830 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
9831 {
9832         uint32_t cntr_array_0;
9833         if (ndr_flags & NDR_SCALARS) {
9834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9835                 NDR_CHECK(ndr_push_align(ndr, 8));
9836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9838                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9839                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9840                 }
9841         }
9842         if (ndr_flags & NDR_BUFFERS) {
9843                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9844                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9845                 }
9846         }
9847         return NDR_ERR_SUCCESS;
9848 }
9849
9850 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
9851 {
9852         uint32_t cntr_array_0;
9853         TALLOC_CTX *_mem_save_array_0;
9854         if (ndr_flags & NDR_SCALARS) {
9855                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9856                 NDR_CHECK(ndr_pull_align(ndr, 8));
9857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9859                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9860                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9861                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9862                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9863                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9864                 }
9865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9866                 if (r->array) {
9867                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9868                 }
9869         }
9870         if (ndr_flags & NDR_BUFFERS) {
9871                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9872                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9873                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9874                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9875                 }
9876                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9877         }
9878         return NDR_ERR_SUCCESS;
9879 }
9880
9881 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
9882 {
9883         uint32_t cntr_array_0;
9884         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
9885         ndr->depth++;
9886         ndr_print_uint32(ndr, "count", r->count);
9887         ndr_print_uint32(ndr, "reserved", r->reserved);
9888         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9889         ndr->depth++;
9890         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9891                 char *idx_0=NULL;
9892                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9893                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
9894                         free(idx_0);
9895                 }
9896         }
9897         ndr->depth--;
9898         ndr->depth--;
9899 }
9900
9901 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
9902 {
9903         if (ndr_flags & NDR_SCALARS) {
9904                 NDR_CHECK(ndr_push_align(ndr, 4));
9905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
9906                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
9907                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
9908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
9909                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
9910         }
9911         if (ndr_flags & NDR_BUFFERS) {
9912                 if (r->dsa_obj_dn) {
9913                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
9914                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
9916                         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));
9917                 }
9918         }
9919         return NDR_ERR_SUCCESS;
9920 }
9921
9922 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
9923 {
9924         uint32_t _ptr_dsa_obj_dn;
9925         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
9926         if (ndr_flags & NDR_SCALARS) {
9927                 NDR_CHECK(ndr_pull_align(ndr, 4));
9928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
9929                 if (_ptr_dsa_obj_dn) {
9930                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
9931                 } else {
9932                         r->dsa_obj_dn = NULL;
9933                 }
9934                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
9935                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
9936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
9937                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
9938         }
9939         if (ndr_flags & NDR_BUFFERS) {
9940                 if (r->dsa_obj_dn) {
9941                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9942                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
9943                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
9944                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
9945                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
9946                                 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));
9947                         }
9948                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
9949                         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));
9950                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
9951                 }
9952         }
9953         return NDR_ERR_SUCCESS;
9954 }
9955
9956 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
9957 {
9958         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
9959         ndr->depth++;
9960         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
9961         ndr->depth++;
9962         if (r->dsa_obj_dn) {
9963                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
9964         }
9965         ndr->depth--;
9966         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
9967         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
9968         ndr_print_uint32(ndr, "num_failures", r->num_failures);
9969         ndr_print_WERROR(ndr, "last_result", r->last_result);
9970         ndr->depth--;
9971 }
9972
9973 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
9974 {
9975         uint32_t cntr_array_0;
9976         if (ndr_flags & NDR_SCALARS) {
9977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9978                 NDR_CHECK(ndr_push_align(ndr, 4));
9979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9981                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9982                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9983                 }
9984         }
9985         if (ndr_flags & NDR_BUFFERS) {
9986                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9987                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9988                 }
9989         }
9990         return NDR_ERR_SUCCESS;
9991 }
9992
9993 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
9994 {
9995         uint32_t cntr_array_0;
9996         TALLOC_CTX *_mem_save_array_0;
9997         if (ndr_flags & NDR_SCALARS) {
9998                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9999                 NDR_CHECK(ndr_pull_align(ndr, 4));
10000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10002                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10003                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10004                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10005                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10006                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10007                 }
10008                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10009                 if (r->array) {
10010                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10011                 }
10012         }
10013         if (ndr_flags & NDR_BUFFERS) {
10014                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10015                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10016                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10017                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10018                 }
10019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10020         }
10021         return NDR_ERR_SUCCESS;
10022 }
10023
10024 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10025 {
10026         uint32_t cntr_array_0;
10027         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10028         ndr->depth++;
10029         ndr_print_uint32(ndr, "count", r->count);
10030         ndr_print_uint32(ndr, "reserved", r->reserved);
10031         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10032         ndr->depth++;
10033         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10034                 char *idx_0=NULL;
10035                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10036                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10037                         free(idx_0);
10038                 }
10039         }
10040         ndr->depth--;
10041         ndr->depth--;
10042 }
10043
10044 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10045 {
10046         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
10047         return NDR_ERR_SUCCESS;
10048 }
10049
10050 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10051 {
10052         uint16_t v;
10053         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
10054         *r = v;
10055         return NDR_ERR_SUCCESS;
10056 }
10057
10058 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10059 {
10060         const char *val = NULL;
10061
10062         switch (r) {
10063                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10064                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10065                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10066                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10067                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10068         }
10069         ndr_print_enum(ndr, name, "ENUM", val, r);
10070 }
10071
10072 static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
10073 {
10074         if (ndr_flags & NDR_SCALARS) {
10075                 int level = ndr_push_get_switch_value(ndr, r);
10076                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
10077                 switch (level) {
10078                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10079                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
10080                         break; }
10081
10082                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10083                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
10084                         break; }
10085
10086                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10087                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
10088                         break; }
10089
10090                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10091                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
10092                         break; }
10093
10094                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10095                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
10096                         break; }
10097
10098                         default: {
10099                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
10100                         break; }
10101
10102                 }
10103         }
10104         if (ndr_flags & NDR_BUFFERS) {
10105                 int level = ndr_push_get_switch_value(ndr, r);
10106                 switch (level) {
10107                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10108                         break;
10109
10110                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10111                         break;
10112
10113                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10114                         break;
10115
10116                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10117                         break;
10118
10119                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10120                         break;
10121
10122                         default:
10123                         break;
10124
10125                 }
10126         }
10127         return NDR_ERR_SUCCESS;
10128 }
10129
10130 static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
10131 {
10132         int level;
10133         uint16_t _level;
10134         level = ndr_pull_get_switch_value(ndr, r);
10135         if (ndr_flags & NDR_SCALARS) {
10136                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
10137                 if (_level != level) {
10138                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10139                 }
10140                 switch (level) {
10141                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10142                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
10143                         break; }
10144
10145                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10146                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
10147                         break; }
10148
10149                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10150                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
10151                         break; }
10152
10153                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10154                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
10155                         break; }
10156
10157                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10158                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
10159                         break; }
10160
10161                         default: {
10162                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
10163                         break; }
10164
10165                 }
10166         }
10167         if (ndr_flags & NDR_BUFFERS) {
10168                 switch (level) {
10169                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10170                         break;
10171
10172                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10173                         break;
10174
10175                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10176                         break;
10177
10178                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10179                         break;
10180
10181                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10182                         break;
10183
10184                         default:
10185                         break;
10186
10187                 }
10188         }
10189         return NDR_ERR_SUCCESS;
10190 }
10191
10192 _PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
10193 {
10194         int level;
10195         level = ndr_print_get_switch_value(ndr, r);
10196         ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
10197         switch (level) {
10198                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10199                         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
10200                 break;
10201
10202                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10203                         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
10204                 break;
10205
10206                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10207                         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
10208                 break;
10209
10210                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10211                         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
10212                 break;
10213
10214                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10215                         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
10216                 break;
10217
10218                 default:
10219                         ndr_print_uint32(ndr, "unknown", r->unknown);
10220                 break;
10221
10222         }
10223 }
10224
10225 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10226 {
10227         if (ndr_flags & NDR_SCALARS) {
10228                 NDR_CHECK(ndr_push_align(ndr, 4));
10229                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10232                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10233                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
10234                 NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10235                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10237                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10238                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10239                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10240         }
10241         if (ndr_flags & NDR_BUFFERS) {
10242                 if (r->nc_dn) {
10243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10244                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10246                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10247                 }
10248                 if (r->remote_dsa_obj_dn) {
10249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10252                         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));
10253                 }
10254                 if (r->remote_dsa_address) {
10255                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10256                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10257                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10258                         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));
10259                 }
10260         }
10261         return NDR_ERR_SUCCESS;
10262 }
10263
10264 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10265 {
10266         uint32_t _ptr_nc_dn;
10267         TALLOC_CTX *_mem_save_nc_dn_0;
10268         uint32_t _ptr_remote_dsa_obj_dn;
10269         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10270         uint32_t _ptr_remote_dsa_address;
10271         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10272         if (ndr_flags & NDR_SCALARS) {
10273                 NDR_CHECK(ndr_pull_align(ndr, 4));
10274                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10277                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10278                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
10279                 NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10281                 if (_ptr_nc_dn) {
10282                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10283                 } else {
10284                         r->nc_dn = NULL;
10285                 }
10286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10287                 if (_ptr_remote_dsa_obj_dn) {
10288                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10289                 } else {
10290                         r->remote_dsa_obj_dn = NULL;
10291                 }
10292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10293                 if (_ptr_remote_dsa_address) {
10294                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10295                 } else {
10296                         r->remote_dsa_address = NULL;
10297                 }
10298                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10299                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10300         }
10301         if (ndr_flags & NDR_BUFFERS) {
10302                 if (r->nc_dn) {
10303                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10304                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10307                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10308                                 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));
10309                         }
10310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10313                 }
10314                 if (r->remote_dsa_obj_dn) {
10315                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10316                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10319                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10320                                 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));
10321                         }
10322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10323                         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));
10324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10325                 }
10326                 if (r->remote_dsa_address) {
10327                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10328                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10331                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10332                                 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));
10333                         }
10334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10335                         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));
10336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10337                 }
10338         }
10339         return NDR_ERR_SUCCESS;
10340 }
10341
10342 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10343 {
10344         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10345         ndr->depth++;
10346         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10347         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10348         ndr_print_uint32(ndr, "priority", r->priority);
10349         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10350         ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
10351         ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
10352         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10353         ndr->depth++;
10354         if (r->nc_dn) {
10355                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10356         }
10357         ndr->depth--;
10358         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10359         ndr->depth++;
10360         if (r->remote_dsa_obj_dn) {
10361                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10362         }
10363         ndr->depth--;
10364         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10365         ndr->depth++;
10366         if (r->remote_dsa_address) {
10367                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10368         }
10369         ndr->depth--;
10370         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10371         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10372         ndr->depth--;
10373 }
10374
10375 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10376 {
10377         uint32_t cntr_array_0;
10378         if (ndr_flags & NDR_SCALARS) {
10379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10380                 NDR_CHECK(ndr_push_align(ndr, 4));
10381                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10383                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10384                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10385                 }
10386         }
10387         if (ndr_flags & NDR_BUFFERS) {
10388                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10389                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10390                 }
10391         }
10392         return NDR_ERR_SUCCESS;
10393 }
10394
10395 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10396 {
10397         uint32_t cntr_array_0;
10398         TALLOC_CTX *_mem_save_array_0;
10399         if (ndr_flags & NDR_SCALARS) {
10400                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10401                 NDR_CHECK(ndr_pull_align(ndr, 4));
10402                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10404                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10405                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10406                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10407                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10408                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10409                 }
10410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10411                 if (r->array) {
10412                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10413                 }
10414         }
10415         if (ndr_flags & NDR_BUFFERS) {
10416                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10417                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10418                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10419                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10420                 }
10421                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10422         }
10423         return NDR_ERR_SUCCESS;
10424 }
10425
10426 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10427 {
10428         uint32_t cntr_array_0;
10429         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10430         ndr->depth++;
10431         ndr_print_NTTIME(ndr, "time", r->time);
10432         ndr_print_uint32(ndr, "count", r->count);
10433         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10434         ndr->depth++;
10435         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10436                 char *idx_0=NULL;
10437                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10438                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10439                         free(idx_0);
10440                 }
10441         }
10442         ndr->depth--;
10443         ndr->depth--;
10444 }
10445
10446 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10447 {
10448         if (ndr_flags & NDR_SCALARS) {
10449                 NDR_CHECK(ndr_push_align(ndr, 8));
10450                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10451                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10454                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10455                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10457                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10458                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10459                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10460                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10461         }
10462         if (ndr_flags & NDR_BUFFERS) {
10463                 if (r->attribute_name) {
10464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10467                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10468                 }
10469                 if (r->object_dn) {
10470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10473                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10474                 }
10475                 if (r->binary) {
10476                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10477                 }
10478         }
10479         return NDR_ERR_SUCCESS;
10480 }
10481
10482 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10483 {
10484         uint32_t _ptr_attribute_name;
10485         TALLOC_CTX *_mem_save_attribute_name_0;
10486         uint32_t _ptr_object_dn;
10487         TALLOC_CTX *_mem_save_object_dn_0;
10488         uint32_t _ptr_binary;
10489         TALLOC_CTX *_mem_save_binary_0;
10490         if (ndr_flags & NDR_SCALARS) {
10491                 NDR_CHECK(ndr_pull_align(ndr, 8));
10492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10493                 if (_ptr_attribute_name) {
10494                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10495                 } else {
10496                         r->attribute_name = NULL;
10497                 }
10498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10499                 if (_ptr_object_dn) {
10500                         NDR_PULL_ALLOC(ndr, r->object_dn);
10501                 } else {
10502                         r->object_dn = NULL;
10503                 }
10504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10506                 if (_ptr_binary) {
10507                         NDR_PULL_ALLOC(ndr, r->binary);
10508                 } else {
10509                         r->binary = NULL;
10510                 }
10511                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10512                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10514                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10515                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10516                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10517                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10518         }
10519         if (ndr_flags & NDR_BUFFERS) {
10520                 if (r->attribute_name) {
10521                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10522                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10523                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10524                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10525                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10526                                 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));
10527                         }
10528                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10529                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10531                 }
10532                 if (r->object_dn) {
10533                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10534                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10535                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10536                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10537                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10538                                 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));
10539                         }
10540                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10541                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10543                 }
10544                 if (r->binary) {
10545                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10546                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10547                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10549                 }
10550         }
10551         return NDR_ERR_SUCCESS;
10552 }
10553
10554 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10555 {
10556         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10557         ndr->depth++;
10558         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10559         ndr->depth++;
10560         if (r->attribute_name) {
10561                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10562         }
10563         ndr->depth--;
10564         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10565         ndr->depth++;
10566         if (r->object_dn) {
10567                 ndr_print_string(ndr, "object_dn", r->object_dn);
10568         }
10569         ndr->depth--;
10570         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);
10571         ndr_print_ptr(ndr, "binary", r->binary);
10572         ndr->depth++;
10573         if (r->binary) {
10574                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10575         }
10576         ndr->depth--;
10577         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10578         ndr_print_NTTIME(ndr, "created", r->created);
10579         ndr_print_uint32(ndr, "version", r->version);
10580         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10581         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10582         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10583         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10584         ndr->depth--;
10585 }
10586
10587 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10588 {
10589         uint32_t cntr_array_0;
10590         if (ndr_flags & NDR_SCALARS) {
10591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10592                 NDR_CHECK(ndr_push_align(ndr, 8));
10593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10594                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10595                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10596                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10597                 }
10598         }
10599         if (ndr_flags & NDR_BUFFERS) {
10600                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10601                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10602                 }
10603         }
10604         return NDR_ERR_SUCCESS;
10605 }
10606
10607 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10608 {
10609         uint32_t cntr_array_0;
10610         TALLOC_CTX *_mem_save_array_0;
10611         if (ndr_flags & NDR_SCALARS) {
10612                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10613                 NDR_CHECK(ndr_pull_align(ndr, 8));
10614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10615                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10616                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10617                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10618                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10619                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10620                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10621                 }
10622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10623                 if (r->array) {
10624                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10625                 }
10626         }
10627         if (ndr_flags & NDR_BUFFERS) {
10628                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10629                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10630                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10631                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10632                 }
10633                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10634         }
10635         return NDR_ERR_SUCCESS;
10636 }
10637
10638 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10639 {
10640         uint32_t cntr_array_0;
10641         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10642         ndr->depth++;
10643         ndr_print_uint32(ndr, "count", r->count);
10644         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10645         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10646         ndr->depth++;
10647         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10648                 char *idx_0=NULL;
10649                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10650                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10651                         free(idx_0);
10652                 }
10653         }
10654         ndr->depth--;
10655         ndr->depth--;
10656 }
10657
10658 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
10659 {
10660         uint32_t cntr_array_0;
10661         if (ndr_flags & NDR_SCALARS) {
10662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10663                 NDR_CHECK(ndr_push_align(ndr, 8));
10664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10665                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10666                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10667                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10668                 }
10669         }
10670         if (ndr_flags & NDR_BUFFERS) {
10671         }
10672         return NDR_ERR_SUCCESS;
10673 }
10674
10675 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
10676 {
10677         uint32_t cntr_array_0;
10678         TALLOC_CTX *_mem_save_array_0;
10679         if (ndr_flags & NDR_SCALARS) {
10680                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10681                 NDR_CHECK(ndr_pull_align(ndr, 8));
10682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10683                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10684                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10685                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10686                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10687                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10688                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10689                 }
10690                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10691                 if (r->array) {
10692                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10693                 }
10694         }
10695         if (ndr_flags & NDR_BUFFERS) {
10696         }
10697         return NDR_ERR_SUCCESS;
10698 }
10699
10700 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
10701 {
10702         uint32_t cntr_array_0;
10703         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
10704         ndr->depth++;
10705         ndr_print_uint32(ndr, "count", r->count);
10706         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10707         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10708         ndr->depth++;
10709         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10710                 char *idx_0=NULL;
10711                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10712                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
10713                         free(idx_0);
10714                 }
10715         }
10716         ndr->depth--;
10717         ndr->depth--;
10718 }
10719
10720 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
10721 {
10722         if (ndr_flags & NDR_SCALARS) {
10723                 NDR_CHECK(ndr_push_align(ndr, 8));
10724                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10725                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
10726                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
10727                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
10728         }
10729         if (ndr_flags & NDR_BUFFERS) {
10730                 if (r->source_dsa_obj_dn) {
10731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10734                         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));
10735                 }
10736         }
10737         return NDR_ERR_SUCCESS;
10738 }
10739
10740 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
10741 {
10742         uint32_t _ptr_source_dsa_obj_dn;
10743         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
10744         if (ndr_flags & NDR_SCALARS) {
10745                 NDR_CHECK(ndr_pull_align(ndr, 8));
10746                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10747                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
10748                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
10749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
10750                 if (_ptr_source_dsa_obj_dn) {
10751                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
10752                 } else {
10753                         r->source_dsa_obj_dn = NULL;
10754                 }
10755         }
10756         if (ndr_flags & NDR_BUFFERS) {
10757                 if (r->source_dsa_obj_dn) {
10758                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10759                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10760                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10761                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10762                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10763                                 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));
10764                         }
10765                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10766                         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));
10767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10768                 }
10769         }
10770         return NDR_ERR_SUCCESS;
10771 }
10772
10773 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
10774 {
10775         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
10776         ndr->depth++;
10777         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10778         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10779         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
10780         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10781         ndr->depth++;
10782         if (r->source_dsa_obj_dn) {
10783                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10784         }
10785         ndr->depth--;
10786         ndr->depth--;
10787 }
10788
10789 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
10790 {
10791         uint32_t cntr_array_0;
10792         if (ndr_flags & NDR_SCALARS) {
10793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10794                 NDR_CHECK(ndr_push_align(ndr, 8));
10795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10796                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10797                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10798                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10799                 }
10800         }
10801         if (ndr_flags & NDR_BUFFERS) {
10802                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10803                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10804                 }
10805         }
10806         return NDR_ERR_SUCCESS;
10807 }
10808
10809 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
10810 {
10811         uint32_t cntr_array_0;
10812         TALLOC_CTX *_mem_save_array_0;
10813         if (ndr_flags & NDR_SCALARS) {
10814                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10815                 NDR_CHECK(ndr_pull_align(ndr, 8));
10816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10817                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10818                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10819                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10820                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10821                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10822                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10823                 }
10824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10825                 if (r->array) {
10826                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10827                 }
10828         }
10829         if (ndr_flags & NDR_BUFFERS) {
10830                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10831                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10832                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10833                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10834                 }
10835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10836         }
10837         return NDR_ERR_SUCCESS;
10838 }
10839
10840 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
10841 {
10842         uint32_t cntr_array_0;
10843         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
10844         ndr->depth++;
10845         ndr_print_uint32(ndr, "count", r->count);
10846         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10847         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10848         ndr->depth++;
10849         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10850                 char *idx_0=NULL;
10851                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10852                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
10853                         free(idx_0);
10854                 }
10855         }
10856         ndr->depth--;
10857         ndr->depth--;
10858 }
10859
10860 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
10861 {
10862         if (ndr_flags & NDR_SCALARS) {
10863                 NDR_CHECK(ndr_push_align(ndr, 8));
10864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10866                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10867                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10868                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10869                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
10871         }
10872         if (ndr_flags & NDR_BUFFERS) {
10873                 if (r->attribute_name) {
10874                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10875                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10876                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10877                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10878                 }
10879                 if (r->originating_dsa_dn) {
10880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10882                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10883                         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));
10884                 }
10885         }
10886         return NDR_ERR_SUCCESS;
10887 }
10888
10889 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
10890 {
10891         uint32_t _ptr_attribute_name;
10892         TALLOC_CTX *_mem_save_attribute_name_0;
10893         uint32_t _ptr_originating_dsa_dn;
10894         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
10895         if (ndr_flags & NDR_SCALARS) {
10896                 NDR_CHECK(ndr_pull_align(ndr, 8));
10897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10898                 if (_ptr_attribute_name) {
10899                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10900                 } else {
10901                         r->attribute_name = NULL;
10902                 }
10903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10904                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10905                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10906                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10907                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
10909                 if (_ptr_originating_dsa_dn) {
10910                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
10911                 } else {
10912                         r->originating_dsa_dn = NULL;
10913                 }
10914         }
10915         if (ndr_flags & NDR_BUFFERS) {
10916                 if (r->attribute_name) {
10917                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10918                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10919                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10920                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10921                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10922                                 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));
10923                         }
10924                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10925                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10927                 }
10928                 if (r->originating_dsa_dn) {
10929                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10930                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
10931                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
10932                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
10933                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
10934                                 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));
10935                         }
10936                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
10937                         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));
10938                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
10939                 }
10940         }
10941         return NDR_ERR_SUCCESS;
10942 }
10943
10944 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
10945 {
10946         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
10947         ndr->depth++;
10948         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10949         ndr->depth++;
10950         if (r->attribute_name) {
10951                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10952         }
10953         ndr->depth--;
10954         ndr_print_uint32(ndr, "version", r->version);
10955         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10956         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10957         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10958         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10959         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10960         ndr->depth++;
10961         if (r->originating_dsa_dn) {
10962                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10963         }
10964         ndr->depth--;
10965         ndr->depth--;
10966 }
10967
10968 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
10969 {
10970         uint32_t cntr_array_0;
10971         if (ndr_flags & NDR_SCALARS) {
10972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10973                 NDR_CHECK(ndr_push_align(ndr, 8));
10974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10975                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10976                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10977                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10978                 }
10979         }
10980         if (ndr_flags & NDR_BUFFERS) {
10981                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10982                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10983                 }
10984         }
10985         return NDR_ERR_SUCCESS;
10986 }
10987
10988 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
10989 {
10990         uint32_t cntr_array_0;
10991         TALLOC_CTX *_mem_save_array_0;
10992         if (ndr_flags & NDR_SCALARS) {
10993                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10994                 NDR_CHECK(ndr_pull_align(ndr, 8));
10995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10996                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10997                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10998                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10999                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11000                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11001                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11002                 }
11003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11004                 if (r->array) {
11005                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11006                 }
11007         }
11008         if (ndr_flags & NDR_BUFFERS) {
11009                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11010                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11011                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11012                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11013                 }
11014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11015         }
11016         return NDR_ERR_SUCCESS;
11017 }
11018
11019 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11020 {
11021         uint32_t cntr_array_0;
11022         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11023         ndr->depth++;
11024         ndr_print_uint32(ndr, "count", r->count);
11025         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11026         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11027         ndr->depth++;
11028         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11029                 char *idx_0=NULL;
11030                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11031                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11032                         free(idx_0);
11033                 }
11034         }
11035         ndr->depth--;
11036         ndr->depth--;
11037 }
11038
11039 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11040 {
11041         if (ndr_flags & NDR_SCALARS) {
11042                 NDR_CHECK(ndr_push_align(ndr, 8));
11043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11046                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11047                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11048                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11050                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11051                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11052                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11053                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11054                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11055         }
11056         if (ndr_flags & NDR_BUFFERS) {
11057                 if (r->attribute_name) {
11058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11061                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11062                 }
11063                 if (r->object_dn) {
11064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11067                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11068                 }
11069                 if (r->binary) {
11070                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11071                 }
11072                 if (r->originating_dsa_dn) {
11073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11076                         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));
11077                 }
11078         }
11079         return NDR_ERR_SUCCESS;
11080 }
11081
11082 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11083 {
11084         uint32_t _ptr_attribute_name;
11085         TALLOC_CTX *_mem_save_attribute_name_0;
11086         uint32_t _ptr_object_dn;
11087         TALLOC_CTX *_mem_save_object_dn_0;
11088         uint32_t _ptr_binary;
11089         TALLOC_CTX *_mem_save_binary_0;
11090         uint32_t _ptr_originating_dsa_dn;
11091         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11092         if (ndr_flags & NDR_SCALARS) {
11093                 NDR_CHECK(ndr_pull_align(ndr, 8));
11094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11095                 if (_ptr_attribute_name) {
11096                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11097                 } else {
11098                         r->attribute_name = NULL;
11099                 }
11100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11101                 if (_ptr_object_dn) {
11102                         NDR_PULL_ALLOC(ndr, r->object_dn);
11103                 } else {
11104                         r->object_dn = NULL;
11105                 }
11106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11108                 if (_ptr_binary) {
11109                         NDR_PULL_ALLOC(ndr, r->binary);
11110                 } else {
11111                         r->binary = NULL;
11112                 }
11113                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11114                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11116                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11117                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11118                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11119                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11121                 if (_ptr_originating_dsa_dn) {
11122                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11123                 } else {
11124                         r->originating_dsa_dn = NULL;
11125                 }
11126         }
11127         if (ndr_flags & NDR_BUFFERS) {
11128                 if (r->attribute_name) {
11129                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11130                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11133                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11134                                 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));
11135                         }
11136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11139                 }
11140                 if (r->object_dn) {
11141                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11142                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11145                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11146                                 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));
11147                         }
11148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11151                 }
11152                 if (r->binary) {
11153                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11154                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11155                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11157                 }
11158                 if (r->originating_dsa_dn) {
11159                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11160                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11161                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11162                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11163                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11164                                 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));
11165                         }
11166                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11167                         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));
11168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11169                 }
11170         }
11171         return NDR_ERR_SUCCESS;
11172 }
11173
11174 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11175 {
11176         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11177         ndr->depth++;
11178         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11179         ndr->depth++;
11180         if (r->attribute_name) {
11181                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11182         }
11183         ndr->depth--;
11184         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11185         ndr->depth++;
11186         if (r->object_dn) {
11187                 ndr_print_string(ndr, "object_dn", r->object_dn);
11188         }
11189         ndr->depth--;
11190         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);
11191         ndr_print_ptr(ndr, "binary", r->binary);
11192         ndr->depth++;
11193         if (r->binary) {
11194                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11195         }
11196         ndr->depth--;
11197         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11198         ndr_print_NTTIME(ndr, "created", r->created);
11199         ndr_print_uint32(ndr, "version", r->version);
11200         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11201         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11202         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11203         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11204         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11205         ndr->depth++;
11206         if (r->originating_dsa_dn) {
11207                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11208         }
11209         ndr->depth--;
11210         ndr->depth--;
11211 }
11212
11213 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11214 {
11215         uint32_t cntr_array_0;
11216         if (ndr_flags & NDR_SCALARS) {
11217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11218                 NDR_CHECK(ndr_push_align(ndr, 8));
11219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11220                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11221                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11222                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11223                 }
11224         }
11225         if (ndr_flags & NDR_BUFFERS) {
11226                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11227                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11228                 }
11229         }
11230         return NDR_ERR_SUCCESS;
11231 }
11232
11233 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11234 {
11235         uint32_t cntr_array_0;
11236         TALLOC_CTX *_mem_save_array_0;
11237         if (ndr_flags & NDR_SCALARS) {
11238                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11239                 NDR_CHECK(ndr_pull_align(ndr, 8));
11240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11241                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11242                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11243                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11244                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11245                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11246                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11247                 }
11248                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11249                 if (r->array) {
11250                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11251                 }
11252         }
11253         if (ndr_flags & NDR_BUFFERS) {
11254                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11255                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11256                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11257                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11258                 }
11259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11260         }
11261         return NDR_ERR_SUCCESS;
11262 }
11263
11264 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11265 {
11266         uint32_t cntr_array_0;
11267         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11268         ndr->depth++;
11269         ndr_print_uint32(ndr, "count", r->count);
11270         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11271         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11272         ndr->depth++;
11273         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11274                 char *idx_0=NULL;
11275                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11276                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11277                         free(idx_0);
11278                 }
11279         }
11280         ndr->depth--;
11281         ndr->depth--;
11282 }
11283
11284 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11285 {
11286         if (ndr_flags & NDR_SCALARS) {
11287                 NDR_CHECK(ndr_push_align(ndr, 8));
11288                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11291                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11292                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11293                 {
11294                         uint32_t _flags_save_ipv4address = ndr->flags;
11295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11296                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11297                         ndr->flags = _flags_save_ipv4address;
11298                 }
11299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11300         }
11301         if (ndr_flags & NDR_BUFFERS) {
11302         }
11303         return NDR_ERR_SUCCESS;
11304 }
11305
11306 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11307 {
11308         if (ndr_flags & NDR_SCALARS) {
11309                 NDR_CHECK(ndr_pull_align(ndr, 8));
11310                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11313                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11314                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11315                 {
11316                         uint32_t _flags_save_ipv4address = ndr->flags;
11317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11318                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11319                         ndr->flags = _flags_save_ipv4address;
11320                 }
11321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11322         }
11323         if (ndr_flags & NDR_BUFFERS) {
11324         }
11325         return NDR_ERR_SUCCESS;
11326 }
11327
11328 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11329 {
11330         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11331         ndr->depth++;
11332         ndr_print_hyper(ndr, "u1", r->u1);
11333         ndr_print_uint32(ndr, "u2", r->u2);
11334         ndr_print_uint32(ndr, "u3", r->u3);
11335         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11336         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11337         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11338         ndr_print_uint32(ndr, "u5", r->u5);
11339         ndr->depth--;
11340 }
11341
11342 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11343 {
11344         uint32_t cntr_array_0;
11345         if (ndr_flags & NDR_SCALARS) {
11346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11347                 NDR_CHECK(ndr_push_align(ndr, 8));
11348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11350                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11351                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11352                 }
11353         }
11354         if (ndr_flags & NDR_BUFFERS) {
11355         }
11356         return NDR_ERR_SUCCESS;
11357 }
11358
11359 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11360 {
11361         uint32_t cntr_array_0;
11362         TALLOC_CTX *_mem_save_array_0;
11363         if (ndr_flags & NDR_SCALARS) {
11364                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11365                 NDR_CHECK(ndr_pull_align(ndr, 8));
11366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11367                 if (r->count > 10000) {
11368                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11369                 }
11370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11371                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11372                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11373                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11374                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11375                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11376                 }
11377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11378                 if (r->array) {
11379                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11380                 }
11381         }
11382         if (ndr_flags & NDR_BUFFERS) {
11383         }
11384         return NDR_ERR_SUCCESS;
11385 }
11386
11387 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11388 {
11389         uint32_t cntr_array_0;
11390         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11391         ndr->depth++;
11392         ndr_print_uint32(ndr, "count", r->count);
11393         ndr_print_uint32(ndr, "reserved", r->reserved);
11394         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11395         ndr->depth++;
11396         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11397                 char *idx_0=NULL;
11398                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11399                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11400                         free(idx_0);
11401                 }
11402         }
11403         ndr->depth--;
11404         ndr->depth--;
11405 }
11406
11407 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11408 {
11409         if (ndr_flags & NDR_SCALARS) {
11410                 NDR_CHECK(ndr_push_align(ndr, 8));
11411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11417                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11419         }
11420         if (ndr_flags & NDR_BUFFERS) {
11421                 if (r->str1) {
11422                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11423                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11425                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11426                 }
11427         }
11428         return NDR_ERR_SUCCESS;
11429 }
11430
11431 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11432 {
11433         uint32_t _ptr_str1;
11434         TALLOC_CTX *_mem_save_str1_0;
11435         if (ndr_flags & NDR_SCALARS) {
11436                 NDR_CHECK(ndr_pull_align(ndr, 8));
11437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11438                 if (_ptr_str1) {
11439                         NDR_PULL_ALLOC(ndr, r->str1);
11440                 } else {
11441                         r->str1 = NULL;
11442                 }
11443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11448                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11450         }
11451         if (ndr_flags & NDR_BUFFERS) {
11452                 if (r->str1) {
11453                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11454                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11455                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11456                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11457                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11458                                 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));
11459                         }
11460                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11461                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11463                 }
11464         }
11465         return NDR_ERR_SUCCESS;
11466 }
11467
11468 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11469 {
11470         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11471         ndr->depth++;
11472         ndr_print_ptr(ndr, "str1", r->str1);
11473         ndr->depth++;
11474         if (r->str1) {
11475                 ndr_print_string(ndr, "str1", r->str1);
11476         }
11477         ndr->depth--;
11478         ndr_print_uint32(ndr, "u1", r->u1);
11479         ndr_print_uint32(ndr, "u2", r->u2);
11480         ndr_print_uint32(ndr, "u3", r->u3);
11481         ndr_print_uint32(ndr, "u4", r->u4);
11482         ndr_print_uint32(ndr, "u5", r->u5);
11483         ndr_print_hyper(ndr, "u6", r->u6);
11484         ndr_print_uint32(ndr, "u7", r->u7);
11485         ndr->depth--;
11486 }
11487
11488 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11489 {
11490         uint32_t cntr_array_0;
11491         if (ndr_flags & NDR_SCALARS) {
11492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11493                 NDR_CHECK(ndr_push_align(ndr, 8));
11494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11496                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11497                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11498                 }
11499         }
11500         if (ndr_flags & NDR_BUFFERS) {
11501                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11502                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11503                 }
11504         }
11505         return NDR_ERR_SUCCESS;
11506 }
11507
11508 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11509 {
11510         uint32_t cntr_array_0;
11511         TALLOC_CTX *_mem_save_array_0;
11512         if (ndr_flags & NDR_SCALARS) {
11513                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11514                 NDR_CHECK(ndr_pull_align(ndr, 8));
11515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11516                 if (r->count > 256) {
11517                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11518                 }
11519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11520                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11521                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11522                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11523                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11524                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11525                 }
11526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11527                 if (r->array) {
11528                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11529                 }
11530         }
11531         if (ndr_flags & NDR_BUFFERS) {
11532                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11533                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11534                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11535                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11536                 }
11537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11538         }
11539         return NDR_ERR_SUCCESS;
11540 }
11541
11542 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11543 {
11544         uint32_t cntr_array_0;
11545         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11546         ndr->depth++;
11547         ndr_print_uint32(ndr, "count", r->count);
11548         ndr_print_uint32(ndr, "reserved", r->reserved);
11549         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11550         ndr->depth++;
11551         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11552                 char *idx_0=NULL;
11553                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11554                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11555                         free(idx_0);
11556                 }
11557         }
11558         ndr->depth--;
11559         ndr->depth--;
11560 }
11561
11562 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11563 {
11564         if (ndr_flags & NDR_SCALARS) {
11565                 int level = ndr_push_get_switch_value(ndr, r);
11566                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11567                 switch (level) {
11568                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11569                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11570                         break; }
11571
11572                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11573                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11574                         break; }
11575
11576                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11577                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11578                         break; }
11579
11580                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11581                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11582                         break; }
11583
11584                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11585                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11586                         break; }
11587
11588                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11589                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11590                         break; }
11591
11592                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11593                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11594                         break; }
11595
11596                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11597                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11598                         break; }
11599
11600                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11601                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11602                         break; }
11603
11604                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11605                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11606                         break; }
11607
11608                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11609                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11610                         break; }
11611
11612                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11613                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
11614                         break; }
11615
11616                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
11617                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
11618                         break; }
11619
11620                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
11621                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
11622                         break; }
11623
11624                         case DRSUAPI_DS_REPLICA_INFO_06: {
11625                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
11626                         break; }
11627
11628                         default:
11629                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11630                 }
11631         }
11632         if (ndr_flags & NDR_BUFFERS) {
11633                 int level = ndr_push_get_switch_value(ndr, r);
11634                 switch (level) {
11635                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11636                                 if (r->neighbours) {
11637                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11638                                 }
11639                         break;
11640
11641                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11642                                 if (r->cursors) {
11643                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11644                                 }
11645                         break;
11646
11647                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11648                                 if (r->objmetadata) {
11649                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11650                                 }
11651                         break;
11652
11653                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11654                                 if (r->connectfailures) {
11655                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11656                                 }
11657                         break;
11658
11659                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11660                                 if (r->linkfailures) {
11661                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
11662                                 }
11663                         break;
11664
11665                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11666                                 if (r->pendingops) {
11667                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
11668                                 }
11669                         break;
11670
11671                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11672                                 if (r->attrvalmetadata) {
11673                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
11674                                 }
11675                         break;
11676
11677                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11678                                 if (r->cursors2) {
11679                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
11680                                 }
11681                         break;
11682
11683                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11684                                 if (r->cursors3) {
11685                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
11686                                 }
11687                         break;
11688
11689                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11690                                 if (r->objmetadata2) {
11691                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
11692                                 }
11693                         break;
11694
11695                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
11696                                 if (r->attrvalmetadata2) {
11697                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
11698                                 }
11699                         break;
11700
11701                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
11702                                 if (r->neighbours02) {
11703                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
11704                                 }
11705                         break;
11706
11707                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
11708                                 if (r->connections04) {
11709                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
11710                                 }
11711                         break;
11712
11713                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
11714                                 if (r->cursors05) {
11715                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
11716                                 }
11717                         break;
11718
11719                         case DRSUAPI_DS_REPLICA_INFO_06:
11720                                 if (r->i06) {
11721                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
11722                                 }
11723                         break;
11724
11725                         default:
11726                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11727                 }
11728         }
11729         return NDR_ERR_SUCCESS;
11730 }
11731
11732 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
11733 {
11734         int level;
11735         uint32_t _level;
11736         TALLOC_CTX *_mem_save_neighbours_0;
11737         TALLOC_CTX *_mem_save_cursors_0;
11738         TALLOC_CTX *_mem_save_objmetadata_0;
11739         TALLOC_CTX *_mem_save_connectfailures_0;
11740         TALLOC_CTX *_mem_save_linkfailures_0;
11741         TALLOC_CTX *_mem_save_pendingops_0;
11742         TALLOC_CTX *_mem_save_attrvalmetadata_0;
11743         TALLOC_CTX *_mem_save_cursors2_0;
11744         TALLOC_CTX *_mem_save_cursors3_0;
11745         TALLOC_CTX *_mem_save_objmetadata2_0;
11746         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
11747         TALLOC_CTX *_mem_save_neighbours02_0;
11748         TALLOC_CTX *_mem_save_connections04_0;
11749         TALLOC_CTX *_mem_save_cursors05_0;
11750         TALLOC_CTX *_mem_save_i06_0;
11751         level = ndr_pull_get_switch_value(ndr, r);
11752         if (ndr_flags & NDR_SCALARS) {
11753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11754                 if (_level != level) {
11755                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
11756                 }
11757                 switch (level) {
11758                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11759                                 uint32_t _ptr_neighbours;
11760                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
11761                                 if (_ptr_neighbours) {
11762                                         NDR_PULL_ALLOC(ndr, r->neighbours);
11763                                 } else {
11764                                         r->neighbours = NULL;
11765                                 }
11766                         break; }
11767
11768                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11769                                 uint32_t _ptr_cursors;
11770                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
11771                                 if (_ptr_cursors) {
11772                                         NDR_PULL_ALLOC(ndr, r->cursors);
11773                                 } else {
11774                                         r->cursors = NULL;
11775                                 }
11776                         break; }
11777
11778                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11779                                 uint32_t _ptr_objmetadata;
11780                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
11781                                 if (_ptr_objmetadata) {
11782                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
11783                                 } else {
11784                                         r->objmetadata = NULL;
11785                                 }
11786                         break; }
11787
11788                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11789                                 uint32_t _ptr_connectfailures;
11790                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
11791                                 if (_ptr_connectfailures) {
11792                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
11793                                 } else {
11794                                         r->connectfailures = NULL;
11795                                 }
11796                         break; }
11797
11798                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11799                                 uint32_t _ptr_linkfailures;
11800                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
11801                                 if (_ptr_linkfailures) {
11802                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
11803                                 } else {
11804                                         r->linkfailures = NULL;
11805                                 }
11806                         break; }
11807
11808                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11809                                 uint32_t _ptr_pendingops;
11810                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
11811                                 if (_ptr_pendingops) {
11812                                         NDR_PULL_ALLOC(ndr, r->pendingops);
11813                                 } else {
11814                                         r->pendingops = NULL;
11815                                 }
11816                         break; }
11817
11818                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11819                                 uint32_t _ptr_attrvalmetadata;
11820                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
11821                                 if (_ptr_attrvalmetadata) {
11822                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
11823                                 } else {
11824                                         r->attrvalmetadata = NULL;
11825                                 }
11826                         break; }
11827
11828                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11829                                 uint32_t _ptr_cursors2;
11830                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
11831                                 if (_ptr_cursors2) {
11832                                         NDR_PULL_ALLOC(ndr, r->cursors2);
11833                                 } else {
11834                                         r->cursors2 = NULL;
11835                                 }
11836                         break; }
11837
11838                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11839                                 uint32_t _ptr_cursors3;
11840                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
11841                                 if (_ptr_cursors3) {
11842                                         NDR_PULL_ALLOC(ndr, r->cursors3);
11843                                 } else {
11844                                         r->cursors3 = NULL;
11845                                 }
11846                         break; }
11847
11848                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11849                                 uint32_t _ptr_objmetadata2;
11850                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
11851                                 if (_ptr_objmetadata2) {
11852                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
11853                                 } else {
11854                                         r->objmetadata2 = NULL;
11855                                 }
11856                         break; }
11857
11858                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11859                                 uint32_t _ptr_attrvalmetadata2;
11860                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
11861                                 if (_ptr_attrvalmetadata2) {
11862                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
11863                                 } else {
11864                                         r->attrvalmetadata2 = NULL;
11865                                 }
11866                         break; }
11867
11868                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11869                                 uint32_t _ptr_neighbours02;
11870                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
11871                                 if (_ptr_neighbours02) {
11872                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
11873                                 } else {
11874                                         r->neighbours02 = NULL;
11875                                 }
11876                         break; }
11877
11878                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
11879                                 uint32_t _ptr_connections04;
11880                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
11881                                 if (_ptr_connections04) {
11882                                         NDR_PULL_ALLOC(ndr, r->connections04);
11883                                 } else {
11884                                         r->connections04 = NULL;
11885                                 }
11886                         break; }
11887
11888                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
11889                                 uint32_t _ptr_cursors05;
11890                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
11891                                 if (_ptr_cursors05) {
11892                                         NDR_PULL_ALLOC(ndr, r->cursors05);
11893                                 } else {
11894                                         r->cursors05 = NULL;
11895                                 }
11896                         break; }
11897
11898                         case DRSUAPI_DS_REPLICA_INFO_06: {
11899                                 uint32_t _ptr_i06;
11900                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
11901                                 if (_ptr_i06) {
11902                                         NDR_PULL_ALLOC(ndr, r->i06);
11903                                 } else {
11904                                         r->i06 = NULL;
11905                                 }
11906                         break; }
11907
11908                         default:
11909                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11910                 }
11911         }
11912         if (ndr_flags & NDR_BUFFERS) {
11913                 switch (level) {
11914                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11915                                 if (r->neighbours) {
11916                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
11917                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
11918                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11919                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
11920                                 }
11921                         break;
11922
11923                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11924                                 if (r->cursors) {
11925                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
11926                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
11927                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11928                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
11929                                 }
11930                         break;
11931
11932                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11933                                 if (r->objmetadata) {
11934                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
11935                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
11936                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11937                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
11938                                 }
11939                         break;
11940
11941                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11942                                 if (r->connectfailures) {
11943                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
11944                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
11945                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11946                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
11947                                 }
11948                         break;
11949
11950                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11951                                 if (r->linkfailures) {
11952                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
11953                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
11954                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
11955                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
11956                                 }
11957                         break;
11958
11959                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11960                                 if (r->pendingops) {
11961                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
11962                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
11963                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
11964                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
11965                                 }
11966                         break;
11967
11968                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11969                                 if (r->attrvalmetadata) {
11970                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
11971                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
11972                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
11973                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
11974                                 }
11975                         break;
11976
11977                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11978                                 if (r->cursors2) {
11979                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
11980                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
11981                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
11982                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
11983                                 }
11984                         break;
11985
11986                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11987                                 if (r->cursors3) {
11988                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
11989                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
11990                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
11991                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
11992                                 }
11993                         break;
11994
11995                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11996                                 if (r->objmetadata2) {
11997                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
11998                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
11999                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12000                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12001                                 }
12002                         break;
12003
12004                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12005                                 if (r->attrvalmetadata2) {
12006                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12007                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12008                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12009                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12010                                 }
12011                         break;
12012
12013                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12014                                 if (r->neighbours02) {
12015                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12016                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12017                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12018                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12019                                 }
12020                         break;
12021
12022                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12023                                 if (r->connections04) {
12024                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12025                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12026                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12027                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12028                                 }
12029                         break;
12030
12031                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12032                                 if (r->cursors05) {
12033                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12034                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12035                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12036                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12037                                 }
12038                         break;
12039
12040                         case DRSUAPI_DS_REPLICA_INFO_06:
12041                                 if (r->i06) {
12042                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12043                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12044                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12045                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12046                                 }
12047                         break;
12048
12049                         default:
12050                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12051                 }
12052         }
12053         return NDR_ERR_SUCCESS;
12054 }
12055
12056 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12057 {
12058         int level;
12059         level = ndr_print_get_switch_value(ndr, r);
12060         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12061         switch (level) {
12062                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12063                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12064                         ndr->depth++;
12065                         if (r->neighbours) {
12066                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12067                         }
12068                         ndr->depth--;
12069                 break;
12070
12071                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12072                         ndr_print_ptr(ndr, "cursors", r->cursors);
12073                         ndr->depth++;
12074                         if (r->cursors) {
12075                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12076                         }
12077                         ndr->depth--;
12078                 break;
12079
12080                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12081                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12082                         ndr->depth++;
12083                         if (r->objmetadata) {
12084                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12085                         }
12086                         ndr->depth--;
12087                 break;
12088
12089                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12090                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12091                         ndr->depth++;
12092                         if (r->connectfailures) {
12093                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12094                         }
12095                         ndr->depth--;
12096                 break;
12097
12098                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12099                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12100                         ndr->depth++;
12101                         if (r->linkfailures) {
12102                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12103                         }
12104                         ndr->depth--;
12105                 break;
12106
12107                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12108                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12109                         ndr->depth++;
12110                         if (r->pendingops) {
12111                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12112                         }
12113                         ndr->depth--;
12114                 break;
12115
12116                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12117                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12118                         ndr->depth++;
12119                         if (r->attrvalmetadata) {
12120                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12121                         }
12122                         ndr->depth--;
12123                 break;
12124
12125                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12126                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12127                         ndr->depth++;
12128                         if (r->cursors2) {
12129                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12130                         }
12131                         ndr->depth--;
12132                 break;
12133
12134                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12135                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12136                         ndr->depth++;
12137                         if (r->cursors3) {
12138                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12139                         }
12140                         ndr->depth--;
12141                 break;
12142
12143                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12144                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12145                         ndr->depth++;
12146                         if (r->objmetadata2) {
12147                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12148                         }
12149                         ndr->depth--;
12150                 break;
12151
12152                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12153                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12154                         ndr->depth++;
12155                         if (r->attrvalmetadata2) {
12156                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12157                         }
12158                         ndr->depth--;
12159                 break;
12160
12161                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12162                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12163                         ndr->depth++;
12164                         if (r->neighbours02) {
12165                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12166                         }
12167                         ndr->depth--;
12168                 break;
12169
12170                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12171                         ndr_print_ptr(ndr, "connections04", r->connections04);
12172                         ndr->depth++;
12173                         if (r->connections04) {
12174                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12175                         }
12176                         ndr->depth--;
12177                 break;
12178
12179                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12180                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12181                         ndr->depth++;
12182                         if (r->cursors05) {
12183                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12184                         }
12185                         ndr->depth--;
12186                 break;
12187
12188                 case DRSUAPI_DS_REPLICA_INFO_06:
12189                         ndr_print_ptr(ndr, "i06", r->i06);
12190                         ndr->depth++;
12191                         if (r->i06) {
12192                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12193                         }
12194                         ndr->depth--;
12195                 break;
12196
12197                 default:
12198                         ndr_print_bad_level(ndr, name, level);
12199         }
12200 }
12201
12202 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12203 {
12204         if (ndr_flags & NDR_SCALARS) {
12205                 int level = ndr_push_get_switch_value(ndr, r);
12206                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12207                 switch (level) {
12208                         case 1: {
12209                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12210                         break; }
12211
12212                         default:
12213                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12214                 }
12215         }
12216         if (ndr_flags & NDR_BUFFERS) {
12217                 int level = ndr_push_get_switch_value(ndr, r);
12218                 switch (level) {
12219                         case 1:
12220                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12221                         break;
12222
12223                         default:
12224                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12225                 }
12226         }
12227         return NDR_ERR_SUCCESS;
12228 }
12229
12230 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12231 {
12232         int level;
12233         int32_t _level;
12234         level = ndr_pull_get_switch_value(ndr, r);
12235         if (ndr_flags & NDR_SCALARS) {
12236                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12237                 if (_level != level) {
12238                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12239                 }
12240                 switch (level) {
12241                         case 1: {
12242                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12243                         break; }
12244
12245                         default:
12246                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12247                 }
12248         }
12249         if (ndr_flags & NDR_BUFFERS) {
12250                 switch (level) {
12251                         case 1:
12252                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12253                         break;
12254
12255                         default:
12256                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12257                 }
12258         }
12259         return NDR_ERR_SUCCESS;
12260 }
12261
12262 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12263 {
12264         int level;
12265         level = ndr_print_get_switch_value(ndr, r);
12266         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12267         switch (level) {
12268                 case 1:
12269                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12270                 break;
12271
12272                 default:
12273                         ndr_print_bad_level(ndr, name, level);
12274         }
12275 }
12276
12277 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12278 {
12279         uint32_t cntr_req_array_1;
12280         if (ndr_flags & NDR_SCALARS) {
12281                 NDR_CHECK(ndr_push_align(ndr, 4));
12282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12283                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12284         }
12285         if (ndr_flags & NDR_BUFFERS) {
12286                 if (r->req_array) {
12287                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12288                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12289                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12290                         }
12291                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12292                                 if (r->req_array[cntr_req_array_1]) {
12293                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12294                                 }
12295                         }
12296                 }
12297         }
12298         return NDR_ERR_SUCCESS;
12299 }
12300
12301 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12302 {
12303         uint32_t _ptr_req_array;
12304         uint32_t cntr_req_array_1;
12305         TALLOC_CTX *_mem_save_req_array_0;
12306         TALLOC_CTX *_mem_save_req_array_1;
12307         TALLOC_CTX *_mem_save_req_array_2;
12308         if (ndr_flags & NDR_SCALARS) {
12309                 NDR_CHECK(ndr_pull_align(ndr, 4));
12310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12311                 if (r->num_req < 1 || r->num_req > 10000) {
12312                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12313                 }
12314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12315                 if (_ptr_req_array) {
12316                         NDR_PULL_ALLOC(ndr, r->req_array);
12317                 } else {
12318                         r->req_array = NULL;
12319                 }
12320         }
12321         if (ndr_flags & NDR_BUFFERS) {
12322                 if (r->req_array) {
12323                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12324                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12325                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12326                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12327                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12328                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12329                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12330                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12331                                 if (_ptr_req_array) {
12332                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12333                                 } else {
12334                                         r->req_array[cntr_req_array_1] = NULL;
12335                                 }
12336                         }
12337                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12338                                 if (r->req_array[cntr_req_array_1]) {
12339                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12340                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12341                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12342                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12343                                 }
12344                         }
12345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12347                 }
12348                 if (r->req_array) {
12349                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12350                 }
12351         }
12352         return NDR_ERR_SUCCESS;
12353 }
12354
12355 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12356 {
12357         uint32_t cntr_req_array_1;
12358         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12359         ndr->depth++;
12360         ndr_print_uint32(ndr, "num_req", r->num_req);
12361         ndr_print_ptr(ndr, "req_array", r->req_array);
12362         ndr->depth++;
12363         if (r->req_array) {
12364                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12365                 ndr->depth++;
12366                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12367                         char *idx_1=NULL;
12368                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12369                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12370                                 ndr->depth++;
12371                                 if (r->req_array[cntr_req_array_1]) {
12372                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12373                                 }
12374                                 ndr->depth--;
12375                                 free(idx_1);
12376                         }
12377                 }
12378                 ndr->depth--;
12379         }
12380         ndr->depth--;
12381         ndr->depth--;
12382 }
12383
12384 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12385 {
12386         if (ndr_flags & NDR_SCALARS) {
12387                 int level = ndr_push_get_switch_value(ndr, r);
12388                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12389                 switch (level) {
12390                         case 1: {
12391                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12392                         break; }
12393
12394                         default:
12395                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12396                 }
12397         }
12398         if (ndr_flags & NDR_BUFFERS) {
12399                 int level = ndr_push_get_switch_value(ndr, r);
12400                 switch (level) {
12401                         case 1:
12402                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12403                         break;
12404
12405                         default:
12406                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12407                 }
12408         }
12409         return NDR_ERR_SUCCESS;
12410 }
12411
12412 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12413 {
12414         int level;
12415         int32_t _level;
12416         level = ndr_pull_get_switch_value(ndr, r);
12417         if (ndr_flags & NDR_SCALARS) {
12418                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12419                 if (_level != level) {
12420                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12421                 }
12422                 switch (level) {
12423                         case 1: {
12424                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12425                         break; }
12426
12427                         default:
12428                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12429                 }
12430         }
12431         if (ndr_flags & NDR_BUFFERS) {
12432                 switch (level) {
12433                         case 1:
12434                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12435                         break;
12436
12437                         default:
12438                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12439                 }
12440         }
12441         return NDR_ERR_SUCCESS;
12442 }
12443
12444 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12445 {
12446         int level;
12447         level = ndr_print_get_switch_value(ndr, r);
12448         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12449         switch (level) {
12450                 case 1:
12451                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12452                 break;
12453
12454                 default:
12455                         ndr_print_bad_level(ndr, name, level);
12456         }
12457 }
12458
12459 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12460 {
12461         if (ndr_flags & NDR_SCALARS) {
12462                 NDR_CHECK(ndr_push_align(ndr, 4));
12463                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12465         }
12466         if (ndr_flags & NDR_BUFFERS) {
12467         }
12468         return NDR_ERR_SUCCESS;
12469 }
12470
12471 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12472 {
12473         if (ndr_flags & NDR_SCALARS) {
12474                 NDR_CHECK(ndr_pull_align(ndr, 4));
12475                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12477         }
12478         if (ndr_flags & NDR_BUFFERS) {
12479         }
12480         return NDR_ERR_SUCCESS;
12481 }
12482
12483 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12484 {
12485         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12486         ndr->depth++;
12487         ndr_print_WERROR(ndr, "error_code", r->error_code);
12488         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12489         ndr->depth--;
12490 }
12491
12492 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12493 {
12494         uint32_t cntr_info_1;
12495         if (ndr_flags & NDR_SCALARS) {
12496                 NDR_CHECK(ndr_push_align(ndr, 4));
12497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12498                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12500         }
12501         if (ndr_flags & NDR_BUFFERS) {
12502                 if (r->info) {
12503                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12504                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12505                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12506                         }
12507                 }
12508         }
12509         return NDR_ERR_SUCCESS;
12510 }
12511
12512 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12513 {
12514         uint32_t _ptr_info;
12515         uint32_t cntr_info_1;
12516         TALLOC_CTX *_mem_save_info_0;
12517         TALLOC_CTX *_mem_save_info_1;
12518         if (ndr_flags & NDR_SCALARS) {
12519                 NDR_CHECK(ndr_pull_align(ndr, 4));
12520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12521                 if (r->num_info > 10000) {
12522                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12523                 }
12524                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12525                 if (_ptr_info) {
12526                         NDR_PULL_ALLOC(ndr, r->info);
12527                 } else {
12528                         r->info = NULL;
12529                 }
12530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12531         }
12532         if (ndr_flags & NDR_BUFFERS) {
12533                 if (r->info) {
12534                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12535                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12536                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12537                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12538                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12539                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12540                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12541                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12542                         }
12543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12545                 }
12546                 if (r->info) {
12547                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12548                 }
12549         }
12550         return NDR_ERR_SUCCESS;
12551 }
12552
12553 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12554 {
12555         uint32_t cntr_info_1;
12556         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12557         ndr->depth++;
12558         ndr_print_uint32(ndr, "num_info", r->num_info);
12559         ndr_print_ptr(ndr, "info", r->info);
12560         ndr->depth++;
12561         if (r->info) {
12562                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12563                 ndr->depth++;
12564                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12565                         char *idx_1=NULL;
12566                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12567                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12568                                 free(idx_1);
12569                         }
12570                 }
12571                 ndr->depth--;
12572         }
12573         ndr->depth--;
12574         ndr_print_uint32(ndr, "unknown", r->unknown);
12575         ndr->depth--;
12576 }
12577
12578 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12579 {
12580         if (ndr_flags & NDR_SCALARS) {
12581                 int level = ndr_push_get_switch_value(ndr, r);
12582                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12583                 switch (level) {
12584                         case 1: {
12585                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12586                         break; }
12587
12588                         default:
12589                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12590                 }
12591         }
12592         if (ndr_flags & NDR_BUFFERS) {
12593                 int level = ndr_push_get_switch_value(ndr, r);
12594                 switch (level) {
12595                         case 1:
12596                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12597                         break;
12598
12599                         default:
12600                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12601                 }
12602         }
12603         return NDR_ERR_SUCCESS;
12604 }
12605
12606 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12607 {
12608         int level;
12609         int32_t _level;
12610         level = ndr_pull_get_switch_value(ndr, r);
12611         if (ndr_flags & NDR_SCALARS) {
12612                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12613                 if (_level != level) {
12614                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12615                 }
12616                 switch (level) {
12617                         case 1: {
12618                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12619                         break; }
12620
12621                         default:
12622                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12623                 }
12624         }
12625         if (ndr_flags & NDR_BUFFERS) {
12626                 switch (level) {
12627                         case 1:
12628                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12629                         break;
12630
12631                         default:
12632                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12633                 }
12634         }
12635         return NDR_ERR_SUCCESS;
12636 }
12637
12638 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
12639 {
12640         int level;
12641         level = ndr_print_get_switch_value(ndr, r);
12642         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
12643         switch (level) {
12644                 case 1:
12645                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
12646                 break;
12647
12648                 default:
12649                         ndr_print_bad_level(ndr, name, level);
12650         }
12651 }
12652
12653 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
12654 {
12655         uint32_t cntr_site_to_1;
12656         if (ndr_flags & NDR_SCALARS) {
12657                 NDR_CHECK(ndr_push_align(ndr, 4));
12658                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
12659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12660                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
12661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
12662         }
12663         if (ndr_flags & NDR_BUFFERS) {
12664                 if (r->site_from) {
12665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12668                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12669                 }
12670                 if (r->site_to) {
12671                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12672                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12673                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
12674                         }
12675                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12676                                 if (r->site_to[cntr_site_to_1]) {
12677                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12678                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12679                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12680                                         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));
12681                                 }
12682                         }
12683                 }
12684         }
12685         return NDR_ERR_SUCCESS;
12686 }
12687
12688 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
12689 {
12690         uint32_t _ptr_site_from;
12691         TALLOC_CTX *_mem_save_site_from_0;
12692         uint32_t _ptr_site_to;
12693         uint32_t cntr_site_to_1;
12694         TALLOC_CTX *_mem_save_site_to_0;
12695         TALLOC_CTX *_mem_save_site_to_1;
12696         TALLOC_CTX *_mem_save_site_to_2;
12697         if (ndr_flags & NDR_SCALARS) {
12698                 NDR_CHECK(ndr_pull_align(ndr, 4));
12699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
12700                 if (_ptr_site_from) {
12701                         NDR_PULL_ALLOC(ndr, r->site_from);
12702                 } else {
12703                         r->site_from = NULL;
12704                 }
12705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12706                 if (r->num_req < 1 || r->num_req > 10000) {
12707                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12708                 }
12709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
12710                 if (_ptr_site_to) {
12711                         NDR_PULL_ALLOC(ndr, r->site_to);
12712                 } else {
12713                         r->site_to = NULL;
12714                 }
12715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
12716         }
12717         if (ndr_flags & NDR_BUFFERS) {
12718                 if (r->site_from) {
12719                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
12720                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
12721                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
12722                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
12723                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
12724                                 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));
12725                         }
12726                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
12727                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
12728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
12729                 }
12730                 if (r->site_to) {
12731                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
12732                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
12733                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
12734                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
12735                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
12736                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
12737                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12738                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
12739                                 if (_ptr_site_to) {
12740                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
12741                                 } else {
12742                                         r->site_to[cntr_site_to_1] = NULL;
12743                                 }
12744                         }
12745                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12746                                 if (r->site_to[cntr_site_to_1]) {
12747                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
12748                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
12749                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
12750                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
12751                                         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])) {
12752                                                 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]));
12753                                         }
12754                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
12755                                         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));
12756                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
12757                                 }
12758                         }
12759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
12760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
12761                 }
12762                 if (r->site_to) {
12763                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
12764                 }
12765         }
12766         return NDR_ERR_SUCCESS;
12767 }
12768
12769 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
12770 {
12771         uint32_t cntr_site_to_1;
12772         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
12773         ndr->depth++;
12774         ndr_print_ptr(ndr, "site_from", r->site_from);
12775         ndr->depth++;
12776         if (r->site_from) {
12777                 ndr_print_string(ndr, "site_from", r->site_from);
12778         }
12779         ndr->depth--;
12780         ndr_print_uint32(ndr, "num_req", r->num_req);
12781         ndr_print_ptr(ndr, "site_to", r->site_to);
12782         ndr->depth++;
12783         if (r->site_to) {
12784                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
12785                 ndr->depth++;
12786                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
12787                         char *idx_1=NULL;
12788                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
12789                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
12790                                 ndr->depth++;
12791                                 if (r->site_to[cntr_site_to_1]) {
12792                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
12793                                 }
12794                                 ndr->depth--;
12795                                 free(idx_1);
12796                         }
12797                 }
12798                 ndr->depth--;
12799         }
12800         ndr->depth--;
12801         ndr_print_uint32(ndr, "flags", r->flags);
12802         ndr->depth--;
12803 }
12804
12805 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
12806 {
12807         if (ndr_flags & NDR_SCALARS) {
12808                 int level = ndr_push_get_switch_value(ndr, r);
12809                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12810                 switch (level) {
12811                         case 1: {
12812                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
12813                         break; }
12814
12815                         default:
12816                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12817                 }
12818         }
12819         if (ndr_flags & NDR_BUFFERS) {
12820                 int level = ndr_push_get_switch_value(ndr, r);
12821                 switch (level) {
12822                         case 1:
12823                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
12824                         break;
12825
12826                         default:
12827                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12828                 }
12829         }
12830         return NDR_ERR_SUCCESS;
12831 }
12832
12833 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
12834 {
12835         int level;
12836         int32_t _level;
12837         level = ndr_pull_get_switch_value(ndr, r);
12838         if (ndr_flags & NDR_SCALARS) {
12839                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12840                 if (_level != level) {
12841                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12842                 }
12843                 switch (level) {
12844                         case 1: {
12845                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
12846                         break; }
12847
12848                         default:
12849                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12850                 }
12851         }
12852         if (ndr_flags & NDR_BUFFERS) {
12853                 switch (level) {
12854                         case 1:
12855                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
12856                         break;
12857
12858                         default:
12859                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12860                 }
12861         }
12862         return NDR_ERR_SUCCESS;
12863 }
12864
12865 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
12866 {
12867         int level;
12868         level = ndr_print_get_switch_value(ndr, r);
12869         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
12870         switch (level) {
12871                 case 1:
12872                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
12873                 break;
12874
12875                 default:
12876                         ndr_print_bad_level(ndr, name, level);
12877         }
12878 }
12879
12880 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
12881 {
12882         if (flags & NDR_IN) {
12883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
12884                 if (r->in.bind_guid) {
12885                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
12886                 }
12887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
12888                 if (r->in.bind_info) {
12889                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
12890                 }
12891         }
12892         if (flags & NDR_OUT) {
12893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
12894                 if (r->out.bind_info) {
12895                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
12896                 }
12897                 if (r->out.bind_handle == NULL) {
12898                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12899                 }
12900                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12901                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12902         }
12903         return NDR_ERR_SUCCESS;
12904 }
12905
12906 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
12907 {
12908         uint32_t _ptr_bind_guid;
12909         uint32_t _ptr_bind_info;
12910         TALLOC_CTX *_mem_save_bind_guid_0;
12911         TALLOC_CTX *_mem_save_bind_info_0;
12912         TALLOC_CTX *_mem_save_bind_handle_0;
12913         if (flags & NDR_IN) {
12914                 ZERO_STRUCT(r->out);
12915
12916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
12917                 if (_ptr_bind_guid) {
12918                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
12919                 } else {
12920                         r->in.bind_guid = NULL;
12921                 }
12922                 if (r->in.bind_guid) {
12923                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
12924                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
12925                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
12926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
12927                 }
12928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
12929                 if (_ptr_bind_info) {
12930                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
12931                 } else {
12932                         r->in.bind_info = NULL;
12933                 }
12934                 if (r->in.bind_info) {
12935                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12936                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
12937                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
12938                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
12939                 }
12940                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12941                 ZERO_STRUCTP(r->out.bind_handle);
12942         }
12943         if (flags & NDR_OUT) {
12944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
12945                 if (_ptr_bind_info) {
12946                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
12947                 } else {
12948                         r->out.bind_info = NULL;
12949                 }
12950                 if (r->out.bind_info) {
12951                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12952                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
12953                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
12954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
12955                 }
12956                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12957                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12958                 }
12959                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12960                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12961                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12962                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12963                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12964         }
12965         return NDR_ERR_SUCCESS;
12966 }
12967
12968 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
12969 {
12970         ndr_print_struct(ndr, name, "drsuapi_DsBind");
12971         ndr->depth++;
12972         if (flags & NDR_SET_VALUES) {
12973                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12974         }
12975         if (flags & NDR_IN) {
12976                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
12977                 ndr->depth++;
12978                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
12979                 ndr->depth++;
12980                 if (r->in.bind_guid) {
12981                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
12982                 }
12983                 ndr->depth--;
12984                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
12985                 ndr->depth++;
12986                 if (r->in.bind_info) {
12987                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
12988                 }
12989                 ndr->depth--;
12990                 ndr->depth--;
12991         }
12992         if (flags & NDR_OUT) {
12993                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
12994                 ndr->depth++;
12995                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
12996                 ndr->depth++;
12997                 if (r->out.bind_info) {
12998                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
12999                 }
13000                 ndr->depth--;
13001                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13002                 ndr->depth++;
13003                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13004                 ndr->depth--;
13005                 ndr_print_WERROR(ndr, "result", r->out.result);
13006                 ndr->depth--;
13007         }
13008         ndr->depth--;
13009 }
13010
13011 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13012 {
13013         if (flags & NDR_IN) {
13014                 if (r->in.bind_handle == NULL) {
13015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13016                 }
13017                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13018         }
13019         if (flags & NDR_OUT) {
13020                 if (r->out.bind_handle == NULL) {
13021                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13022                 }
13023                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13024                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13025         }
13026         return NDR_ERR_SUCCESS;
13027 }
13028
13029 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13030 {
13031         TALLOC_CTX *_mem_save_bind_handle_0;
13032         if (flags & NDR_IN) {
13033                 ZERO_STRUCT(r->out);
13034
13035                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13036                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13037                 }
13038                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13039                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13040                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13041                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13042                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13043                 *r->out.bind_handle = *r->in.bind_handle;
13044         }
13045         if (flags & NDR_OUT) {
13046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13047                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13048                 }
13049                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13050                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13051                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13053                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13054         }
13055         return NDR_ERR_SUCCESS;
13056 }
13057
13058 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13059 {
13060         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13061         ndr->depth++;
13062         if (flags & NDR_SET_VALUES) {
13063                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13064         }
13065         if (flags & NDR_IN) {
13066                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13067                 ndr->depth++;
13068                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13069                 ndr->depth++;
13070                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13071                 ndr->depth--;
13072                 ndr->depth--;
13073         }
13074         if (flags & NDR_OUT) {
13075                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13076                 ndr->depth++;
13077                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13078                 ndr->depth++;
13079                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13080                 ndr->depth--;
13081                 ndr_print_WERROR(ndr, "result", r->out.result);
13082                 ndr->depth--;
13083         }
13084         ndr->depth--;
13085 }
13086
13087 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13088 {
13089         if (flags & NDR_IN) {
13090                 if (r->in.bind_handle == NULL) {
13091                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13092                 }
13093                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13094                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13095                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13096                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13097         }
13098         if (flags & NDR_OUT) {
13099                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13100         }
13101         return NDR_ERR_SUCCESS;
13102 }
13103
13104 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13105 {
13106         TALLOC_CTX *_mem_save_bind_handle_0;
13107         if (flags & NDR_IN) {
13108                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13109                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13110                 }
13111                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13112                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13113                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13114                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13115                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13116                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13117                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13118         }
13119         if (flags & NDR_OUT) {
13120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13121         }
13122         return NDR_ERR_SUCCESS;
13123 }
13124
13125 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13126 {
13127         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13128         ndr->depth++;
13129         if (flags & NDR_SET_VALUES) {
13130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13131         }
13132         if (flags & NDR_IN) {
13133                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13134                 ndr->depth++;
13135                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13136                 ndr->depth++;
13137                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13138                 ndr->depth--;
13139                 ndr_print_int32(ndr, "level", r->in.level);
13140                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13141                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13142                 ndr->depth--;
13143         }
13144         if (flags & NDR_OUT) {
13145                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13146                 ndr->depth++;
13147                 ndr_print_WERROR(ndr, "result", r->out.result);
13148                 ndr->depth--;
13149         }
13150         ndr->depth--;
13151 }
13152
13153 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13154 {
13155         if (flags & NDR_IN) {
13156                 if (r->in.bind_handle == NULL) {
13157                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13158                 }
13159                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13160                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13161                 if (r->in.req == NULL) {
13162                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13163                 }
13164                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13165                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13166         }
13167         if (flags & NDR_OUT) {
13168                 if (r->out.level_out == NULL) {
13169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13170                 }
13171                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13172                 if (r->out.ctr == NULL) {
13173                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13174                 }
13175                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13176                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13177                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13178         }
13179         return NDR_ERR_SUCCESS;
13180 }
13181
13182 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13183 {
13184         TALLOC_CTX *_mem_save_bind_handle_0;
13185         TALLOC_CTX *_mem_save_req_0;
13186         TALLOC_CTX *_mem_save_level_out_0;
13187         TALLOC_CTX *_mem_save_ctr_0;
13188         if (flags & NDR_IN) {
13189                 ZERO_STRUCT(r->out);
13190
13191                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13192                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13193                 }
13194                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13195                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13196                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13197                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13198                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13199                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13200                         NDR_PULL_ALLOC(ndr, r->in.req);
13201                 }
13202                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13203                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13204                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13205                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13206                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13207                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13208                 ZERO_STRUCTP(r->out.level_out);
13209                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13210                 ZERO_STRUCTP(r->out.ctr);
13211         }
13212         if (flags & NDR_OUT) {
13213                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13214                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13215                 }
13216                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13217                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13218                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13219                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13221                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13222                 }
13223                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13224                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13225                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13226                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13227                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13228                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13229         }
13230         return NDR_ERR_SUCCESS;
13231 }
13232
13233 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13234 {
13235         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13236         ndr->depth++;
13237         if (flags & NDR_SET_VALUES) {
13238                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13239         }
13240         if (flags & NDR_IN) {
13241                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13242                 ndr->depth++;
13243                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13244                 ndr->depth++;
13245                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13246                 ndr->depth--;
13247                 ndr_print_int32(ndr, "level", r->in.level);
13248                 ndr_print_ptr(ndr, "req", r->in.req);
13249                 ndr->depth++;
13250                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13251                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13252                 ndr->depth--;
13253                 ndr->depth--;
13254         }
13255         if (flags & NDR_OUT) {
13256                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13257                 ndr->depth++;
13258                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13259                 ndr->depth++;
13260                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13261                 ndr->depth--;
13262                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13263                 ndr->depth++;
13264                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13265                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13266                 ndr->depth--;
13267                 ndr_print_WERROR(ndr, "result", r->out.result);
13268                 ndr->depth--;
13269         }
13270         ndr->depth--;
13271 }
13272
13273 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13274 {
13275         if (flags & NDR_IN) {
13276                 if (r->in.bind_handle == NULL) {
13277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13278                 }
13279                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13280                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13281                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13282                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13283         }
13284         if (flags & NDR_OUT) {
13285                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13286         }
13287         return NDR_ERR_SUCCESS;
13288 }
13289
13290 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13291 {
13292         TALLOC_CTX *_mem_save_bind_handle_0;
13293         if (flags & NDR_IN) {
13294                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13295                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13296                 }
13297                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13298                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13299                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13300                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13301                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13302                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13303                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13304         }
13305         if (flags & NDR_OUT) {
13306                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13307         }
13308         return NDR_ERR_SUCCESS;
13309 }
13310
13311 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13312 {
13313         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13314         ndr->depth++;
13315         if (flags & NDR_SET_VALUES) {
13316                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13317         }
13318         if (flags & NDR_IN) {
13319                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13320                 ndr->depth++;
13321                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13322                 ndr->depth++;
13323                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13324                 ndr->depth--;
13325                 ndr_print_int32(ndr, "level", r->in.level);
13326                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13327                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13328                 ndr->depth--;
13329         }
13330         if (flags & NDR_OUT) {
13331                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13332                 ndr->depth++;
13333                 ndr_print_WERROR(ndr, "result", r->out.result);
13334                 ndr->depth--;
13335         }
13336         ndr->depth--;
13337 }
13338
13339 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13340 {
13341         if (flags & NDR_IN) {
13342                 if (r->in.bind_handle == NULL) {
13343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13344                 }
13345                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13346                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13347                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13348                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13349         }
13350         if (flags & NDR_OUT) {
13351                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13352         }
13353         return NDR_ERR_SUCCESS;
13354 }
13355
13356 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13357 {
13358         TALLOC_CTX *_mem_save_bind_handle_0;
13359         if (flags & NDR_IN) {
13360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13361                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13362                 }
13363                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13364                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13365                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13367                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13368                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13369                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13370         }
13371         if (flags & NDR_OUT) {
13372                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13373         }
13374         return NDR_ERR_SUCCESS;
13375 }
13376
13377 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13378 {
13379         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13380         ndr->depth++;
13381         if (flags & NDR_SET_VALUES) {
13382                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13383         }
13384         if (flags & NDR_IN) {
13385                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13386                 ndr->depth++;
13387                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13388                 ndr->depth++;
13389                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13390                 ndr->depth--;
13391                 ndr_print_int32(ndr, "level", r->in.level);
13392                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13393                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13394                 ndr->depth--;
13395         }
13396         if (flags & NDR_OUT) {
13397                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13398                 ndr->depth++;
13399                 ndr_print_WERROR(ndr, "result", r->out.result);
13400                 ndr->depth--;
13401         }
13402         ndr->depth--;
13403 }
13404
13405 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13406 {
13407         if (flags & NDR_IN) {
13408                 if (r->in.bind_handle == NULL) {
13409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13410                 }
13411                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13412                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13413                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13414                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13415         }
13416         if (flags & NDR_OUT) {
13417                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13418         }
13419         return NDR_ERR_SUCCESS;
13420 }
13421
13422 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13423 {
13424         TALLOC_CTX *_mem_save_bind_handle_0;
13425         if (flags & NDR_IN) {
13426                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13427                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13428                 }
13429                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13430                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13431                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13432                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13433                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13434                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13435                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13436         }
13437         if (flags & NDR_OUT) {
13438                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13439         }
13440         return NDR_ERR_SUCCESS;
13441 }
13442
13443 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13444 {
13445         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13446         ndr->depth++;
13447         if (flags & NDR_SET_VALUES) {
13448                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13449         }
13450         if (flags & NDR_IN) {
13451                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13452                 ndr->depth++;
13453                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13454                 ndr->depth++;
13455                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13456                 ndr->depth--;
13457                 ndr_print_int32(ndr, "level", r->in.level);
13458                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13459                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13460                 ndr->depth--;
13461         }
13462         if (flags & NDR_OUT) {
13463                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13464                 ndr->depth++;
13465                 ndr_print_WERROR(ndr, "result", r->out.result);
13466                 ndr->depth--;
13467         }
13468         ndr->depth--;
13469 }
13470
13471 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13472 {
13473         if (flags & NDR_IN) {
13474                 if (r->in.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->in.bind_handle));
13478                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13479                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13480                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13481         }
13482         if (flags & NDR_OUT) {
13483                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13484         }
13485         return NDR_ERR_SUCCESS;
13486 }
13487
13488 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13489 {
13490         TALLOC_CTX *_mem_save_bind_handle_0;
13491         if (flags & NDR_IN) {
13492                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13493                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13494                 }
13495                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13496                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13497                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13498                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13499                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13500                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13501                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13502         }
13503         if (flags & NDR_OUT) {
13504                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13505         }
13506         return NDR_ERR_SUCCESS;
13507 }
13508
13509 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13510 {
13511         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13512         ndr->depth++;
13513         if (flags & NDR_SET_VALUES) {
13514                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13515         }
13516         if (flags & NDR_IN) {
13517                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13518                 ndr->depth++;
13519                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13520                 ndr->depth++;
13521                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13522                 ndr->depth--;
13523                 ndr_print_int32(ndr, "level", r->in.level);
13524                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13525                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13526                 ndr->depth--;
13527         }
13528         if (flags & NDR_OUT) {
13529                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13530                 ndr->depth++;
13531                 ndr_print_WERROR(ndr, "result", r->out.result);
13532                 ndr->depth--;
13533         }
13534         ndr->depth--;
13535 }
13536
13537 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13538 {
13539         if (flags & NDR_IN) {
13540         }
13541         if (flags & NDR_OUT) {
13542                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13543         }
13544         return NDR_ERR_SUCCESS;
13545 }
13546
13547 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13548 {
13549         if (flags & NDR_IN) {
13550         }
13551         if (flags & NDR_OUT) {
13552                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13553         }
13554         return NDR_ERR_SUCCESS;
13555 }
13556
13557 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13558 {
13559         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13560         ndr->depth++;
13561         if (flags & NDR_SET_VALUES) {
13562                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13563         }
13564         if (flags & NDR_IN) {
13565                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13566                 ndr->depth++;
13567                 ndr->depth--;
13568         }
13569         if (flags & NDR_OUT) {
13570                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13571                 ndr->depth++;
13572                 ndr_print_WERROR(ndr, "result", r->out.result);
13573                 ndr->depth--;
13574         }
13575         ndr->depth--;
13576 }
13577
13578 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13579 {
13580         if (flags & NDR_IN) {
13581                 if (r->in.bind_handle == NULL) {
13582                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13583                 }
13584                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13585                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13586                 if (r->in.req == NULL) {
13587                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13588                 }
13589                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13590                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13591         }
13592         if (flags & NDR_OUT) {
13593                 if (r->out.level_out == NULL) {
13594                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13595                 }
13596                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13597                 if (r->out.ctr == NULL) {
13598                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13599                 }
13600                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13601                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13602                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13603         }
13604         return NDR_ERR_SUCCESS;
13605 }
13606
13607 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13608 {
13609         TALLOC_CTX *_mem_save_bind_handle_0;
13610         TALLOC_CTX *_mem_save_req_0;
13611         TALLOC_CTX *_mem_save_level_out_0;
13612         TALLOC_CTX *_mem_save_ctr_0;
13613         if (flags & NDR_IN) {
13614                 ZERO_STRUCT(r->out);
13615
13616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13617                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13618                 }
13619                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13620                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13621                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13623                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13624                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13625                         NDR_PULL_ALLOC(ndr, r->in.req);
13626                 }
13627                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13628                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13629                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13630                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13631                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13632                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13633                 ZERO_STRUCTP(r->out.level_out);
13634                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13635                 ZERO_STRUCTP(r->out.ctr);
13636         }
13637         if (flags & NDR_OUT) {
13638                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13639                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13640                 }
13641                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13642                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13643                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13644                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13645                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13646                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13647                 }
13648                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13649                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13650                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13651                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13653                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13654         }
13655         return NDR_ERR_SUCCESS;
13656 }
13657
13658 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
13659 {
13660         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
13661         ndr->depth++;
13662         if (flags & NDR_SET_VALUES) {
13663                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13664         }
13665         if (flags & NDR_IN) {
13666                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
13667                 ndr->depth++;
13668                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13669                 ndr->depth++;
13670                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13671                 ndr->depth--;
13672                 ndr_print_int32(ndr, "level", r->in.level);
13673                 ndr_print_ptr(ndr, "req", r->in.req);
13674                 ndr->depth++;
13675                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13676                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
13677                 ndr->depth--;
13678                 ndr->depth--;
13679         }
13680         if (flags & NDR_OUT) {
13681                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
13682                 ndr->depth++;
13683                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13684                 ndr->depth++;
13685                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13686                 ndr->depth--;
13687                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13688                 ndr->depth++;
13689                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13690                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
13691                 ndr->depth--;
13692                 ndr_print_WERROR(ndr, "result", r->out.result);
13693                 ndr->depth--;
13694         }
13695         ndr->depth--;
13696 }
13697
13698 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13699 {
13700         if (flags & NDR_IN) {
13701         }
13702         if (flags & NDR_OUT) {
13703                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13704         }
13705         return NDR_ERR_SUCCESS;
13706 }
13707
13708 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13709 {
13710         if (flags & NDR_IN) {
13711         }
13712         if (flags & NDR_OUT) {
13713                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13714         }
13715         return NDR_ERR_SUCCESS;
13716 }
13717
13718 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13719 {
13720         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
13721         ndr->depth++;
13722         if (flags & NDR_SET_VALUES) {
13723                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13724         }
13725         if (flags & NDR_IN) {
13726                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
13727                 ndr->depth++;
13728                 ndr->depth--;
13729         }
13730         if (flags & NDR_OUT) {
13731                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
13732                 ndr->depth++;
13733                 ndr_print_WERROR(ndr, "result", r->out.result);
13734                 ndr->depth--;
13735         }
13736         ndr->depth--;
13737 }
13738
13739 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
13740 {
13741         if (flags & NDR_IN) {
13742                 if (r->in.bind_handle == NULL) {
13743                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13744                 }
13745                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13747                 if (r->in.req == NULL) {
13748                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13749                 }
13750                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13751                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13752         }
13753         if (flags & NDR_OUT) {
13754                 if (r->out.level_out == NULL) {
13755                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13756                 }
13757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
13758                 if (r->out.info == NULL) {
13759                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13760                 }
13761                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
13762                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13763                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13764         }
13765         return NDR_ERR_SUCCESS;
13766 }
13767
13768 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
13769 {
13770         TALLOC_CTX *_mem_save_bind_handle_0;
13771         TALLOC_CTX *_mem_save_req_0;
13772         TALLOC_CTX *_mem_save_level_out_0;
13773         TALLOC_CTX *_mem_save_info_0;
13774         if (flags & NDR_IN) {
13775                 ZERO_STRUCT(r->out);
13776
13777                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13778                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13779                 }
13780                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13781                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13782                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13783                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13785                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13786                         NDR_PULL_ALLOC(ndr, r->in.req);
13787                 }
13788                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13789                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13790                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13791                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13793                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13794                 ZERO_STRUCTP(r->out.level_out);
13795                 NDR_PULL_ALLOC(ndr, r->out.info);
13796                 ZERO_STRUCTP(r->out.info);
13797         }
13798         if (flags & NDR_OUT) {
13799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13800                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13801                 }
13802                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13803                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
13805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13807                         NDR_PULL_ALLOC(ndr, r->out.info);
13808                 }
13809                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13810                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
13811                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
13812                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
13814                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13815         }
13816         return NDR_ERR_SUCCESS;
13817 }
13818
13819 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
13820 {
13821         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
13822         ndr->depth++;
13823         if (flags & NDR_SET_VALUES) {
13824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13825         }
13826         if (flags & NDR_IN) {
13827                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
13828                 ndr->depth++;
13829                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13830                 ndr->depth++;
13831                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13832                 ndr->depth--;
13833                 ndr_print_uint32(ndr, "level", r->in.level);
13834                 ndr_print_ptr(ndr, "req", r->in.req);
13835                 ndr->depth++;
13836                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13837                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
13838                 ndr->depth--;
13839                 ndr->depth--;
13840         }
13841         if (flags & NDR_OUT) {
13842                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
13843                 ndr->depth++;
13844                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13845                 ndr->depth++;
13846                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
13847                 ndr->depth--;
13848                 ndr_print_ptr(ndr, "info", r->out.info);
13849                 ndr->depth++;
13850                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
13851                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
13852                 ndr->depth--;
13853                 ndr_print_WERROR(ndr, "result", r->out.result);
13854                 ndr->depth--;
13855         }
13856         ndr->depth--;
13857 }
13858
13859 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
13860 {
13861         if (flags & NDR_IN) {
13862                 if (r->in.bind_handle == NULL) {
13863                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13864                 }
13865                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13866                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13867                 if (r->in.req == NULL) {
13868                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13869                 }
13870                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13871                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13872         }
13873         if (flags & NDR_OUT) {
13874                 if (r->out.level_out == NULL) {
13875                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13876                 }
13877                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13878                 if (r->out.ctr == NULL) {
13879                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13880                 }
13881                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13882                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13883                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13884         }
13885         return NDR_ERR_SUCCESS;
13886 }
13887
13888 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
13889 {
13890         TALLOC_CTX *_mem_save_bind_handle_0;
13891         TALLOC_CTX *_mem_save_req_0;
13892         TALLOC_CTX *_mem_save_level_out_0;
13893         TALLOC_CTX *_mem_save_ctr_0;
13894         if (flags & NDR_IN) {
13895                 ZERO_STRUCT(r->out);
13896
13897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13898                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13899                 }
13900                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13901                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13902                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13904                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13905                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13906                         NDR_PULL_ALLOC(ndr, r->in.req);
13907                 }
13908                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13909                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13910                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13911                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13913                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13914                 ZERO_STRUCTP(r->out.level_out);
13915                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13916                 ZERO_STRUCTP(r->out.ctr);
13917         }
13918         if (flags & NDR_OUT) {
13919                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13920                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13921                 }
13922                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13923                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13924                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13925                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13926                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13927                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13928                 }
13929                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13930                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13931                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13932                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13934                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13935         }
13936         return NDR_ERR_SUCCESS;
13937 }
13938
13939 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
13940 {
13941         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
13942         ndr->depth++;
13943         if (flags & NDR_SET_VALUES) {
13944                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13945         }
13946         if (flags & NDR_IN) {
13947                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
13948                 ndr->depth++;
13949                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13950                 ndr->depth++;
13951                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13952                 ndr->depth--;
13953                 ndr_print_int32(ndr, "level", r->in.level);
13954                 ndr_print_ptr(ndr, "req", r->in.req);
13955                 ndr->depth++;
13956                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13957                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
13958                 ndr->depth--;
13959                 ndr->depth--;
13960         }
13961         if (flags & NDR_OUT) {
13962                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
13963                 ndr->depth++;
13964                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13965                 ndr->depth++;
13966                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13967                 ndr->depth--;
13968                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13969                 ndr->depth++;
13970                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13971                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
13972                 ndr->depth--;
13973                 ndr_print_WERROR(ndr, "result", r->out.result);
13974                 ndr->depth--;
13975         }
13976         ndr->depth--;
13977 }
13978
13979 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
13980 {
13981         if (flags & NDR_IN) {
13982                 if (r->in.bind_handle == NULL) {
13983                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13984                 }
13985                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13986                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13987                 if (r->in.req == NULL) {
13988                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13989                 }
13990                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13991                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13992         }
13993         if (flags & NDR_OUT) {
13994                 if (r->out.level_out == NULL) {
13995                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13996                 }
13997                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13998                 if (r->out.res == NULL) {
13999                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14000                 }
14001                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14002                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14003                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14004         }
14005         return NDR_ERR_SUCCESS;
14006 }
14007
14008 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14009 {
14010         TALLOC_CTX *_mem_save_bind_handle_0;
14011         TALLOC_CTX *_mem_save_req_0;
14012         TALLOC_CTX *_mem_save_level_out_0;
14013         TALLOC_CTX *_mem_save_res_0;
14014         if (flags & NDR_IN) {
14015                 ZERO_STRUCT(r->out);
14016
14017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14018                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14019                 }
14020                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14021                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14022                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14024                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14026                         NDR_PULL_ALLOC(ndr, r->in.req);
14027                 }
14028                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14029                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14030                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14031                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14033                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14034                 ZERO_STRUCTP(r->out.level_out);
14035                 NDR_PULL_ALLOC(ndr, r->out.res);
14036                 ZERO_STRUCTP(r->out.res);
14037         }
14038         if (flags & NDR_OUT) {
14039                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14040                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14041                 }
14042                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14043                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14044                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14045                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14047                         NDR_PULL_ALLOC(ndr, r->out.res);
14048                 }
14049                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14050                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14051                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14052                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14053                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14054                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14055         }
14056         return NDR_ERR_SUCCESS;
14057 }
14058
14059 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14060 {
14061         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14062         ndr->depth++;
14063         if (flags & NDR_SET_VALUES) {
14064                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14065         }
14066         if (flags & NDR_IN) {
14067                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14068                 ndr->depth++;
14069                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14070                 ndr->depth++;
14071                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14072                 ndr->depth--;
14073                 ndr_print_int32(ndr, "level", r->in.level);
14074                 ndr_print_ptr(ndr, "req", r->in.req);
14075                 ndr->depth++;
14076                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14077                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14078                 ndr->depth--;
14079                 ndr->depth--;
14080         }
14081         if (flags & NDR_OUT) {
14082                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14083                 ndr->depth++;
14084                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14085                 ndr->depth++;
14086                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14087                 ndr->depth--;
14088                 ndr_print_ptr(ndr, "res", r->out.res);
14089                 ndr->depth++;
14090                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14091                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14092                 ndr->depth--;
14093                 ndr_print_WERROR(ndr, "result", r->out.result);
14094                 ndr->depth--;
14095         }
14096         ndr->depth--;
14097 }
14098
14099 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14100 {
14101         if (flags & NDR_IN) {
14102                 if (r->in.bind_handle == NULL) {
14103                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14104                 }
14105                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14106                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14107                 if (r->in.req == NULL) {
14108                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14109                 }
14110                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14111                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14112         }
14113         if (flags & NDR_OUT) {
14114                 if (r->out.level_out == NULL) {
14115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14116                 }
14117                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14118                 if (r->out.res == NULL) {
14119                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14120                 }
14121                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14122                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14123                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14124         }
14125         return NDR_ERR_SUCCESS;
14126 }
14127
14128 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14129 {
14130         TALLOC_CTX *_mem_save_bind_handle_0;
14131         TALLOC_CTX *_mem_save_req_0;
14132         TALLOC_CTX *_mem_save_level_out_0;
14133         TALLOC_CTX *_mem_save_res_0;
14134         if (flags & NDR_IN) {
14135                 ZERO_STRUCT(r->out);
14136
14137                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14138                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14139                 }
14140                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14141                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14142                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14143                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14144                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14146                         NDR_PULL_ALLOC(ndr, r->in.req);
14147                 }
14148                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14149                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14150                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14151                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14152                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14153                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14154                 ZERO_STRUCTP(r->out.level_out);
14155                 NDR_PULL_ALLOC(ndr, r->out.res);
14156                 ZERO_STRUCTP(r->out.res);
14157         }
14158         if (flags & NDR_OUT) {
14159                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14160                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14161                 }
14162                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14163                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14164                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14167                         NDR_PULL_ALLOC(ndr, r->out.res);
14168                 }
14169                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14170                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14171                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14172                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14174                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14175         }
14176         return NDR_ERR_SUCCESS;
14177 }
14178
14179 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14180 {
14181         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14182         ndr->depth++;
14183         if (flags & NDR_SET_VALUES) {
14184                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14185         }
14186         if (flags & NDR_IN) {
14187                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14188                 ndr->depth++;
14189                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14190                 ndr->depth++;
14191                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14192                 ndr->depth--;
14193                 ndr_print_int32(ndr, "level", r->in.level);
14194                 ndr_print_ptr(ndr, "req", r->in.req);
14195                 ndr->depth++;
14196                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14197                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14198                 ndr->depth--;
14199                 ndr->depth--;
14200         }
14201         if (flags & NDR_OUT) {
14202                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14203                 ndr->depth++;
14204                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14205                 ndr->depth++;
14206                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14207                 ndr->depth--;
14208                 ndr_print_ptr(ndr, "res", r->out.res);
14209                 ndr->depth++;
14210                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14211                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14212                 ndr->depth--;
14213                 ndr_print_WERROR(ndr, "result", r->out.result);
14214                 ndr->depth--;
14215         }
14216         ndr->depth--;
14217 }
14218
14219 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14220 {
14221         if (flags & NDR_IN) {
14222         }
14223         if (flags & NDR_OUT) {
14224                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14225         }
14226         return NDR_ERR_SUCCESS;
14227 }
14228
14229 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14230 {
14231         if (flags & NDR_IN) {
14232         }
14233         if (flags & NDR_OUT) {
14234                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14235         }
14236         return NDR_ERR_SUCCESS;
14237 }
14238
14239 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14240 {
14241         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14242         ndr->depth++;
14243         if (flags & NDR_SET_VALUES) {
14244                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14245         }
14246         if (flags & NDR_IN) {
14247                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14248                 ndr->depth++;
14249                 ndr->depth--;
14250         }
14251         if (flags & NDR_OUT) {
14252                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14253                 ndr->depth++;
14254                 ndr_print_WERROR(ndr, "result", r->out.result);
14255                 ndr->depth--;
14256         }
14257         ndr->depth--;
14258 }
14259
14260 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14261 {
14262         if (flags & NDR_IN) {
14263                 if (r->in.bind_handle == NULL) {
14264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14265                 }
14266                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14267                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14268                 if (r->in.req == NULL) {
14269                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14270                 }
14271                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14272                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14273         }
14274         if (flags & NDR_OUT) {
14275                 if (r->out.level_out == NULL) {
14276                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14277                 }
14278                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14279                 if (r->out.ctr == NULL) {
14280                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14281                 }
14282                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14283                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14284                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14285         }
14286         return NDR_ERR_SUCCESS;
14287 }
14288
14289 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14290 {
14291         TALLOC_CTX *_mem_save_bind_handle_0;
14292         TALLOC_CTX *_mem_save_req_0;
14293         TALLOC_CTX *_mem_save_level_out_0;
14294         TALLOC_CTX *_mem_save_ctr_0;
14295         if (flags & NDR_IN) {
14296                 ZERO_STRUCT(r->out);
14297
14298                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14299                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14300                 }
14301                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14302                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14303                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14305                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14306                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14307                         NDR_PULL_ALLOC(ndr, r->in.req);
14308                 }
14309                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14310                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14311                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14312                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14314                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14315                 ZERO_STRUCTP(r->out.level_out);
14316                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14317                 ZERO_STRUCTP(r->out.ctr);
14318         }
14319         if (flags & NDR_OUT) {
14320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14321                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14322                 }
14323                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14324                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14325                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14327                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14328                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14329                 }
14330                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14331                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14332                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14333                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14335                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14336         }
14337         return NDR_ERR_SUCCESS;
14338 }
14339
14340 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14341 {
14342         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14343         ndr->depth++;
14344         if (flags & NDR_SET_VALUES) {
14345                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14346         }
14347         if (flags & NDR_IN) {
14348                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14349                 ndr->depth++;
14350                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14351                 ndr->depth++;
14352                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14353                 ndr->depth--;
14354                 ndr_print_int32(ndr, "level", r->in.level);
14355                 ndr_print_ptr(ndr, "req", r->in.req);
14356                 ndr->depth++;
14357                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14358                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14359                 ndr->depth--;
14360                 ndr->depth--;
14361         }
14362         if (flags & NDR_OUT) {
14363                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14364                 ndr->depth++;
14365                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14366                 ndr->depth++;
14367                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14368                 ndr->depth--;
14369                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14370                 ndr->depth++;
14371                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14372                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14373                 ndr->depth--;
14374                 ndr_print_WERROR(ndr, "result", r->out.result);
14375                 ndr->depth--;
14376         }
14377         ndr->depth--;
14378 }
14379
14380 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14381 {
14382         if (flags & NDR_IN) {
14383                 if (r->in.bind_handle == NULL) {
14384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14385                 }
14386                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14387                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14388                 if (r->in.req == NULL) {
14389                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14390                 }
14391                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14392                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14393         }
14394         if (flags & NDR_OUT) {
14395                 if (r->out.level_out == NULL) {
14396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14397                 }
14398                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14399                 if (r->out.ctr == NULL) {
14400                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14401                 }
14402                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14403                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14404                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14405         }
14406         return NDR_ERR_SUCCESS;
14407 }
14408
14409 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14410 {
14411         TALLOC_CTX *_mem_save_bind_handle_0;
14412         TALLOC_CTX *_mem_save_req_0;
14413         TALLOC_CTX *_mem_save_level_out_0;
14414         TALLOC_CTX *_mem_save_ctr_0;
14415         if (flags & NDR_IN) {
14416                 ZERO_STRUCT(r->out);
14417
14418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14419                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14420                 }
14421                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14422                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14423                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14425                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14426                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14427                         NDR_PULL_ALLOC(ndr, r->in.req);
14428                 }
14429                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14430                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14431                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14432                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14433                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14434                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14435                 ZERO_STRUCTP(r->out.level_out);
14436                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14437                 ZERO_STRUCTP(r->out.ctr);
14438         }
14439         if (flags & NDR_OUT) {
14440                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14441                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14442                 }
14443                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14444                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14445                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14446                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14447                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14448                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14449                 }
14450                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14451                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14452                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14453                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14454                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14455                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14456         }
14457         return NDR_ERR_SUCCESS;
14458 }
14459
14460 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14461 {
14462         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14463         ndr->depth++;
14464         if (flags & NDR_SET_VALUES) {
14465                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14466         }
14467         if (flags & NDR_IN) {
14468                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14469                 ndr->depth++;
14470                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14471                 ndr->depth++;
14472                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14473                 ndr->depth--;
14474                 ndr_print_int32(ndr, "level", r->in.level);
14475                 ndr_print_ptr(ndr, "req", r->in.req);
14476                 ndr->depth++;
14477                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14478                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14479                 ndr->depth--;
14480                 ndr->depth--;
14481         }
14482         if (flags & NDR_OUT) {
14483                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14484                 ndr->depth++;
14485                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14486                 ndr->depth++;
14487                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14488                 ndr->depth--;
14489                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14490                 ndr->depth++;
14491                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14492                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14493                 ndr->depth--;
14494                 ndr_print_WERROR(ndr, "result", r->out.result);
14495                 ndr->depth--;
14496         }
14497         ndr->depth--;
14498 }
14499
14500 static enum ndr_err_code ndr_push_DRSUAPI_EXECUTE_KCC(struct ndr_push *ndr, int flags, const struct DRSUAPI_EXECUTE_KCC *r)
14501 {
14502         if (flags & NDR_IN) {
14503         }
14504         if (flags & NDR_OUT) {
14505                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14506         }
14507         return NDR_ERR_SUCCESS;
14508 }
14509
14510 static enum ndr_err_code ndr_pull_DRSUAPI_EXECUTE_KCC(struct ndr_pull *ndr, int flags, struct DRSUAPI_EXECUTE_KCC *r)
14511 {
14512         if (flags & NDR_IN) {
14513         }
14514         if (flags & NDR_OUT) {
14515                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14516         }
14517         return NDR_ERR_SUCCESS;
14518 }
14519
14520 _PUBLIC_ void ndr_print_DRSUAPI_EXECUTE_KCC(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_EXECUTE_KCC *r)
14521 {
14522         ndr_print_struct(ndr, name, "DRSUAPI_EXECUTE_KCC");
14523         ndr->depth++;
14524         if (flags & NDR_SET_VALUES) {
14525                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14526         }
14527         if (flags & NDR_IN) {
14528                 ndr_print_struct(ndr, "in", "DRSUAPI_EXECUTE_KCC");
14529                 ndr->depth++;
14530                 ndr->depth--;
14531         }
14532         if (flags & NDR_OUT) {
14533                 ndr_print_struct(ndr, "out", "DRSUAPI_EXECUTE_KCC");
14534                 ndr->depth++;
14535                 ndr_print_WERROR(ndr, "result", r->out.result);
14536                 ndr->depth--;
14537         }
14538         ndr->depth--;
14539 }
14540
14541 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14542 {
14543         if (flags & NDR_IN) {
14544                 if (r->in.bind_handle == NULL) {
14545                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14546                 }
14547                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14548                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14549                 if (r->in.req == NULL) {
14550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14551                 }
14552                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14553                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14554         }
14555         if (flags & NDR_OUT) {
14556                 if (r->out.info_type == NULL) {
14557                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14558                 }
14559                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14560                 if (r->out.info == NULL) {
14561                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14562                 }
14563                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
14564                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14565                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14566         }
14567         return NDR_ERR_SUCCESS;
14568 }
14569
14570 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14571 {
14572         TALLOC_CTX *_mem_save_bind_handle_0;
14573         TALLOC_CTX *_mem_save_req_0;
14574         TALLOC_CTX *_mem_save_info_type_0;
14575         TALLOC_CTX *_mem_save_info_0;
14576         if (flags & NDR_IN) {
14577                 ZERO_STRUCT(r->out);
14578
14579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14580                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14581                 }
14582                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14583                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14584                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14586                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
14587                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14588                         NDR_PULL_ALLOC(ndr, r->in.req);
14589                 }
14590                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14591                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14592                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14593                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14594                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14595                 NDR_PULL_ALLOC(ndr, r->out.info_type);
14596                 ZERO_STRUCTP(r->out.info_type);
14597                 NDR_PULL_ALLOC(ndr, r->out.info);
14598                 ZERO_STRUCTP(r->out.info);
14599         }
14600         if (flags & NDR_OUT) {
14601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14602                         NDR_PULL_ALLOC(ndr, r->out.info_type);
14603                 }
14604                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
14605                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
14606                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
14607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
14608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14609                         NDR_PULL_ALLOC(ndr, r->out.info);
14610                 }
14611                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14612                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14613                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
14614                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14616                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14617         }
14618         return NDR_ERR_SUCCESS;
14619 }
14620
14621 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14622 {
14623         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
14624         ndr->depth++;
14625         if (flags & NDR_SET_VALUES) {
14626                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14627         }
14628         if (flags & NDR_IN) {
14629                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
14630                 ndr->depth++;
14631                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14632                 ndr->depth++;
14633                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14634                 ndr->depth--;
14635                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
14636                 ndr_print_ptr(ndr, "req", r->in.req);
14637                 ndr->depth++;
14638                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14639                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
14640                 ndr->depth--;
14641                 ndr->depth--;
14642         }
14643         if (flags & NDR_OUT) {
14644                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
14645                 ndr->depth++;
14646                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
14647                 ndr->depth++;
14648                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
14649                 ndr->depth--;
14650                 ndr_print_ptr(ndr, "info", r->out.info);
14651                 ndr->depth++;
14652                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
14653                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
14654                 ndr->depth--;
14655                 ndr_print_WERROR(ndr, "result", r->out.result);
14656                 ndr->depth--;
14657         }
14658         ndr->depth--;
14659 }
14660
14661 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
14662 {
14663         if (flags & NDR_IN) {
14664         }
14665         if (flags & NDR_OUT) {
14666                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14667         }
14668         return NDR_ERR_SUCCESS;
14669 }
14670
14671 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
14672 {
14673         if (flags & NDR_IN) {
14674         }
14675         if (flags & NDR_OUT) {
14676                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14677         }
14678         return NDR_ERR_SUCCESS;
14679 }
14680
14681 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
14682 {
14683         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
14684         ndr->depth++;
14685         if (flags & NDR_SET_VALUES) {
14686                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14687         }
14688         if (flags & NDR_IN) {
14689                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
14690                 ndr->depth++;
14691                 ndr->depth--;
14692         }
14693         if (flags & NDR_OUT) {
14694                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
14695                 ndr->depth++;
14696                 ndr_print_WERROR(ndr, "result", r->out.result);
14697                 ndr->depth--;
14698         }
14699         ndr->depth--;
14700 }
14701
14702 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
14703 {
14704         if (flags & NDR_IN) {
14705                 if (r->in.bind_handle == NULL) {
14706                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14707                 }
14708                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14709                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14710                 if (r->in.req == NULL) {
14711                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14712                 }
14713                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14714                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14715         }
14716         if (flags & NDR_OUT) {
14717                 if (r->out.level_out == NULL) {
14718                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14719                 }
14720                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14721                 if (r->out.ctr == NULL) {
14722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14723                 }
14724                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14725                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14726                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14727         }
14728         return NDR_ERR_SUCCESS;
14729 }
14730
14731 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
14732 {
14733         TALLOC_CTX *_mem_save_bind_handle_0;
14734         TALLOC_CTX *_mem_save_req_0;
14735         TALLOC_CTX *_mem_save_level_out_0;
14736         TALLOC_CTX *_mem_save_ctr_0;
14737         if (flags & NDR_IN) {
14738                 ZERO_STRUCT(r->out);
14739
14740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14741                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14742                 }
14743                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14744                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14745                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14747                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14748                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14749                         NDR_PULL_ALLOC(ndr, r->in.req);
14750                 }
14751                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14752                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14753                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14754                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14756                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14757                 ZERO_STRUCTP(r->out.level_out);
14758                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14759                 ZERO_STRUCTP(r->out.ctr);
14760         }
14761         if (flags & NDR_OUT) {
14762                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14763                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14764                 }
14765                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14766                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14767                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14769                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14770                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14771                 }
14772                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14773                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14774                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14775                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14776                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14777                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14778         }
14779         return NDR_ERR_SUCCESS;
14780 }
14781
14782 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
14783 {
14784         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
14785         ndr->depth++;
14786         if (flags & NDR_SET_VALUES) {
14787                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14788         }
14789         if (flags & NDR_IN) {
14790                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
14791                 ndr->depth++;
14792                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14793                 ndr->depth++;
14794                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14795                 ndr->depth--;
14796                 ndr_print_int32(ndr, "level", r->in.level);
14797                 ndr_print_ptr(ndr, "req", r->in.req);
14798                 ndr->depth++;
14799                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14800                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
14801                 ndr->depth--;
14802                 ndr->depth--;
14803         }
14804         if (flags & NDR_OUT) {
14805                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
14806                 ndr->depth++;
14807                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14808                 ndr->depth++;
14809                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14810                 ndr->depth--;
14811                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14812                 ndr->depth++;
14813                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14814                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
14815                 ndr->depth--;
14816                 ndr_print_WERROR(ndr, "result", r->out.result);
14817                 ndr->depth--;
14818         }
14819         ndr->depth--;
14820 }
14821
14822 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14823 {
14824         if (flags & NDR_IN) {
14825         }
14826         if (flags & NDR_OUT) {
14827                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14828         }
14829         return NDR_ERR_SUCCESS;
14830 }
14831
14832 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14833 {
14834         if (flags & NDR_IN) {
14835         }
14836         if (flags & NDR_OUT) {
14837                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14838         }
14839         return NDR_ERR_SUCCESS;
14840 }
14841
14842 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14843 {
14844         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
14845         ndr->depth++;
14846         if (flags & NDR_SET_VALUES) {
14847                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14848         }
14849         if (flags & NDR_IN) {
14850                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
14851                 ndr->depth++;
14852                 ndr->depth--;
14853         }
14854         if (flags & NDR_OUT) {
14855                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
14856                 ndr->depth++;
14857                 ndr_print_WERROR(ndr, "result", r->out.result);
14858                 ndr->depth--;
14859         }
14860         ndr->depth--;
14861 }
14862
14863 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
14864 {
14865         if (flags & NDR_IN) {
14866         }
14867         if (flags & NDR_OUT) {
14868                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14869         }
14870         return NDR_ERR_SUCCESS;
14871 }
14872
14873 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
14874 {
14875         if (flags & NDR_IN) {
14876         }
14877         if (flags & NDR_OUT) {
14878                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14879         }
14880         return NDR_ERR_SUCCESS;
14881 }
14882
14883 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
14884 {
14885         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
14886         ndr->depth++;
14887         if (flags & NDR_SET_VALUES) {
14888                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14889         }
14890         if (flags & NDR_IN) {
14891                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
14892                 ndr->depth++;
14893                 ndr->depth--;
14894         }
14895         if (flags & NDR_OUT) {
14896                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
14897                 ndr->depth++;
14898                 ndr_print_WERROR(ndr, "result", r->out.result);
14899                 ndr->depth--;
14900         }
14901         ndr->depth--;
14902 }
14903
14904 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
14905 {
14906         if (flags & NDR_IN) {
14907                 if (r->in.bind_handle == NULL) {
14908                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14909                 }
14910                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14911                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14912                 if (r->in.req == NULL) {
14913                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14914                 }
14915                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14916                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14917         }
14918         if (flags & NDR_OUT) {
14919                 if (r->out.level_out == NULL) {
14920                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14921                 }
14922                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14923                 if (r->out.ctr == NULL) {
14924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14925                 }
14926                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14927                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14929         }
14930         return NDR_ERR_SUCCESS;
14931 }
14932
14933 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
14934 {
14935         TALLOC_CTX *_mem_save_bind_handle_0;
14936         TALLOC_CTX *_mem_save_req_0;
14937         TALLOC_CTX *_mem_save_level_out_0;
14938         TALLOC_CTX *_mem_save_ctr_0;
14939         if (flags & NDR_IN) {
14940                 ZERO_STRUCT(r->out);
14941
14942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14943                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14944                 }
14945                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14946                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14947                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14949                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14950                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14951                         NDR_PULL_ALLOC(ndr, r->in.req);
14952                 }
14953                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14954                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14955                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14956                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14957                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14958                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14959                 ZERO_STRUCTP(r->out.level_out);
14960                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14961                 ZERO_STRUCTP(r->out.ctr);
14962         }
14963         if (flags & NDR_OUT) {
14964                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14965                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14966                 }
14967                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14968                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14969                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14970                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14972                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14973                 }
14974                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14975                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14976                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14977                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14979                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14980         }
14981         return NDR_ERR_SUCCESS;
14982 }
14983
14984 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
14985 {
14986         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
14987         ndr->depth++;
14988         if (flags & NDR_SET_VALUES) {
14989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14990         }
14991         if (flags & NDR_IN) {
14992                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
14993                 ndr->depth++;
14994                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14995                 ndr->depth++;
14996                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14997                 ndr->depth--;
14998                 ndr_print_int32(ndr, "level", r->in.level);
14999                 ndr_print_ptr(ndr, "req", r->in.req);
15000                 ndr->depth++;
15001                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15002                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15003                 ndr->depth--;
15004                 ndr->depth--;
15005         }
15006         if (flags & NDR_OUT) {
15007                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15008                 ndr->depth++;
15009                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15010                 ndr->depth++;
15011                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15012                 ndr->depth--;
15013                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15014                 ndr->depth++;
15015                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15016                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15017                 ndr->depth--;
15018                 ndr_print_WERROR(ndr, "result", r->out.result);
15019                 ndr->depth--;
15020         }
15021         ndr->depth--;
15022 }
15023
15024 static const struct ndr_interface_call drsuapi_calls[] = {
15025         {
15026                 "drsuapi_DsBind",
15027                 sizeof(struct drsuapi_DsBind),
15028                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15029                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15030                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15031                 false,
15032         },
15033         {
15034                 "drsuapi_DsUnbind",
15035                 sizeof(struct drsuapi_DsUnbind),
15036                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15037                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15038                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15039                 false,
15040         },
15041         {
15042                 "drsuapi_DsReplicaSync",
15043                 sizeof(struct drsuapi_DsReplicaSync),
15044                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15045                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15046                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15047                 false,
15048         },
15049         {
15050                 "drsuapi_DsGetNCChanges",
15051                 sizeof(struct drsuapi_DsGetNCChanges),
15052                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15053                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15054                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15055                 false,
15056         },
15057         {
15058                 "drsuapi_DsReplicaUpdateRefs",
15059                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15060                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15061                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15062                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15063                 false,
15064         },
15065         {
15066                 "drsuapi_DsReplicaAdd",
15067                 sizeof(struct drsuapi_DsReplicaAdd),
15068                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15069                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15070                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15071                 false,
15072         },
15073         {
15074                 "drsuapi_DsReplicaDel",
15075                 sizeof(struct drsuapi_DsReplicaDel),
15076                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15077                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15078                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15079                 false,
15080         },
15081         {
15082                 "drsuapi_DsReplicaMod",
15083                 sizeof(struct drsuapi_DsReplicaMod),
15084                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15085                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15086                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15087                 false,
15088         },
15089         {
15090                 "DRSUAPI_VERIFY_NAMES",
15091                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15092                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15093                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15094                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15095                 false,
15096         },
15097         {
15098                 "drsuapi_DsGetMemberships",
15099                 sizeof(struct drsuapi_DsGetMemberships),
15100                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15101                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15102                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15103                 false,
15104         },
15105         {
15106                 "DRSUAPI_INTER_DOMAIN_MOVE",
15107                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15108                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15109                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15110                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15111                 false,
15112         },
15113         {
15114                 "drsuapi_DsGetNT4ChangeLog",
15115                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15116                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15117                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15118                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15119                 false,
15120         },
15121         {
15122                 "drsuapi_DsCrackNames",
15123                 sizeof(struct drsuapi_DsCrackNames),
15124                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15125                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15126                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15127                 false,
15128         },
15129         {
15130                 "drsuapi_DsWriteAccountSpn",
15131                 sizeof(struct drsuapi_DsWriteAccountSpn),
15132                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15133                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15134                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15135                 false,
15136         },
15137         {
15138                 "drsuapi_DsRemoveDSServer",
15139                 sizeof(struct drsuapi_DsRemoveDSServer),
15140                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15141                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15142                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15143                 false,
15144         },
15145         {
15146                 "DRSUAPI_REMOVE_DS_DOMAIN",
15147                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15148                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15149                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15150                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15151                 false,
15152         },
15153         {
15154                 "drsuapi_DsGetDomainControllerInfo",
15155                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15156                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15157                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15158                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15159                 false,
15160         },
15161         {
15162                 "drsuapi_DsAddEntry",
15163                 sizeof(struct drsuapi_DsAddEntry),
15164                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15165                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15166                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15167                 false,
15168         },
15169         {
15170                 "DRSUAPI_EXECUTE_KCC",
15171                 sizeof(struct DRSUAPI_EXECUTE_KCC),
15172                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_EXECUTE_KCC,
15173                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_EXECUTE_KCC,
15174                 (ndr_print_function_t) ndr_print_DRSUAPI_EXECUTE_KCC,
15175                 false,
15176         },
15177         {
15178                 "drsuapi_DsReplicaGetInfo",
15179                 sizeof(struct drsuapi_DsReplicaGetInfo),
15180                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15181                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15182                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15183                 false,
15184         },
15185         {
15186                 "DRSUAPI_ADD_SID_HISTORY",
15187                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15188                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15189                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15190                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15191                 false,
15192         },
15193         {
15194                 "drsuapi_DsGetMemberships2",
15195                 sizeof(struct drsuapi_DsGetMemberships2),
15196                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15197                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15198                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15199                 false,
15200         },
15201         {
15202                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15203                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15204                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15205                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15206                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15207                 false,
15208         },
15209         {
15210                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15211                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15212                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15213                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15214                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15215                 false,
15216         },
15217         {
15218                 "drsuapi_QuerySitesByCost",
15219                 sizeof(struct drsuapi_QuerySitesByCost),
15220                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15221                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15222                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15223                 false,
15224         },
15225         { NULL, 0, NULL, NULL, NULL, false }
15226 };
15227
15228 static const char * const drsuapi_endpoint_strings[] = {
15229         "ncacn_np:[\\pipe\\lsass]",
15230         "ncacn_np:[\\pipe\\protected_storage]",
15231         "ncacn_ip_tcp:",
15232         "ncalrpc:",
15233 };
15234
15235 static const struct ndr_interface_string_array drsuapi_endpoints = {
15236         .count  = 4,
15237         .names  = drsuapi_endpoint_strings
15238 };
15239
15240 static const char * const drsuapi_authservice_strings[] = {
15241         "ldap",
15242 };
15243
15244 static const struct ndr_interface_string_array drsuapi_authservices = {
15245         .count  = 1,
15246         .names  = drsuapi_authservice_strings
15247 };
15248
15249
15250 const struct ndr_interface_table ndr_table_drsuapi = {
15251         .name           = "drsuapi",
15252         .syntax_id      = {
15253                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15254                 NDR_DRSUAPI_VERSION
15255         },
15256         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15257         .num_calls      = 25,
15258         .calls          = drsuapi_calls,
15259         .endpoints      = &drsuapi_endpoints,
15260         .authservices   = &drsuapi_authservices
15261 };
15262