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_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t 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_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *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_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9080 {
9081         ndr_print_uint32(ndr, name, r);
9082         ndr->depth++;
9083         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9084         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9085         ndr->depth--;
9086 }
9087
9088 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9089 {
9090         if (ndr_flags & NDR_SCALARS) {
9091                 NDR_CHECK(ndr_push_align(ndr, 4));
9092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9093                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9094         }
9095         if (ndr_flags & NDR_BUFFERS) {
9096         }
9097         return NDR_ERR_SUCCESS;
9098 }
9099
9100 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9101 {
9102         if (ndr_flags & NDR_SCALARS) {
9103                 NDR_CHECK(ndr_pull_align(ndr, 4));
9104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9105                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9106         }
9107         if (ndr_flags & NDR_BUFFERS) {
9108         }
9109         return NDR_ERR_SUCCESS;
9110 }
9111
9112 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9113 {
9114         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9115         ndr->depth++;
9116         ndr_print_uint32(ndr, "taskID", r->taskID);
9117         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9118         ndr->depth--;
9119 }
9120
9121 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9122 {
9123         if (ndr_flags & NDR_SCALARS) {
9124                 int level = ndr_push_get_switch_value(ndr, r);
9125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9126                 switch (level) {
9127                         case 1: {
9128                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9129                         break; }
9130
9131                         default:
9132                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9133                 }
9134         }
9135         if (ndr_flags & NDR_BUFFERS) {
9136                 int level = ndr_push_get_switch_value(ndr, r);
9137                 switch (level) {
9138                         case 1:
9139                         break;
9140
9141                         default:
9142                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9143                 }
9144         }
9145         return NDR_ERR_SUCCESS;
9146 }
9147
9148 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9149 {
9150         int level;
9151         uint32_t _level;
9152         level = ndr_pull_get_switch_value(ndr, r);
9153         if (ndr_flags & NDR_SCALARS) {
9154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9155                 if (_level != level) {
9156                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9157                 }
9158                 switch (level) {
9159                         case 1: {
9160                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9161                         break; }
9162
9163                         default:
9164                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9165                 }
9166         }
9167         if (ndr_flags & NDR_BUFFERS) {
9168                 switch (level) {
9169                         case 1:
9170                         break;
9171
9172                         default:
9173                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9174                 }
9175         }
9176         return NDR_ERR_SUCCESS;
9177 }
9178
9179 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9180 {
9181         int level;
9182         level = ndr_print_get_switch_value(ndr, r);
9183         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9184         switch (level) {
9185                 case 1:
9186                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9187                 break;
9188
9189                 default:
9190                         ndr_print_bad_level(ndr, name, level);
9191         }
9192 }
9193
9194 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9195 {
9196         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9197         return NDR_ERR_SUCCESS;
9198 }
9199
9200 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9201 {
9202         uint32_t v;
9203         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9204         *r = v;
9205         return NDR_ERR_SUCCESS;
9206 }
9207
9208 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9209 {
9210         const char *val = NULL;
9211
9212         switch (r) {
9213                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9214                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9215         }
9216         ndr_print_enum(ndr, name, "ENUM", val, r);
9217 }
9218
9219 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9220 {
9221         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9222         return NDR_ERR_SUCCESS;
9223 }
9224
9225 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9226 {
9227         uint32_t v;
9228         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9229         *r = v;
9230         return NDR_ERR_SUCCESS;
9231 }
9232
9233 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9234 {
9235         const char *val = NULL;
9236
9237         switch (r) {
9238                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9239                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9240                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9241                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9242                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9243                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9244                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9245                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9246                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9247                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9248                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9249                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9250                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9251                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9252                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9253         }
9254         ndr_print_enum(ndr, name, "ENUM", val, r);
9255 }
9256
9257 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9258 {
9259         if (ndr_flags & NDR_SCALARS) {
9260                 NDR_CHECK(ndr_push_align(ndr, 4));
9261                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9263                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9264         }
9265         if (ndr_flags & NDR_BUFFERS) {
9266                 if (r->object_dn) {
9267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9269                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9270                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9271                 }
9272         }
9273         return NDR_ERR_SUCCESS;
9274 }
9275
9276 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9277 {
9278         uint32_t _ptr_object_dn;
9279         TALLOC_CTX *_mem_save_object_dn_0;
9280         if (ndr_flags & NDR_SCALARS) {
9281                 NDR_CHECK(ndr_pull_align(ndr, 4));
9282                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9283                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9284                 if (_ptr_object_dn) {
9285                         NDR_PULL_ALLOC(ndr, r->object_dn);
9286                 } else {
9287                         r->object_dn = NULL;
9288                 }
9289                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9290         }
9291         if (ndr_flags & NDR_BUFFERS) {
9292                 if (r->object_dn) {
9293                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9294                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9295                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9296                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9297                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9298                                 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));
9299                         }
9300                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9301                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9303                 }
9304         }
9305         return NDR_ERR_SUCCESS;
9306 }
9307
9308 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9309 {
9310         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9311         ndr->depth++;
9312         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9313         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9314         ndr->depth++;
9315         if (r->object_dn) {
9316                 ndr_print_string(ndr, "object_dn", r->object_dn);
9317         }
9318         ndr->depth--;
9319         ndr_print_GUID(ndr, "guid1", &r->guid1);
9320         ndr->depth--;
9321 }
9322
9323 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9324 {
9325         if (ndr_flags & NDR_SCALARS) {
9326                 NDR_CHECK(ndr_push_align(ndr, 4));
9327                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9329                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9332                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
9334         }
9335         if (ndr_flags & NDR_BUFFERS) {
9336                 if (r->object_dn) {
9337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9341                 }
9342                 if (r->string1) {
9343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9346                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9347                 }
9348                 if (r->string2) {
9349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9352                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9353                 }
9354         }
9355         return NDR_ERR_SUCCESS;
9356 }
9357
9358 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9359 {
9360         uint32_t _ptr_object_dn;
9361         TALLOC_CTX *_mem_save_object_dn_0;
9362         uint32_t _ptr_string1;
9363         TALLOC_CTX *_mem_save_string1_0;
9364         uint32_t _ptr_string2;
9365         TALLOC_CTX *_mem_save_string2_0;
9366         if (ndr_flags & NDR_SCALARS) {
9367                 NDR_CHECK(ndr_pull_align(ndr, 4));
9368                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9370                 if (_ptr_object_dn) {
9371                         NDR_PULL_ALLOC(ndr, r->object_dn);
9372                 } else {
9373                         r->object_dn = NULL;
9374                 }
9375                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9378                 if (_ptr_string1) {
9379                         NDR_PULL_ALLOC(ndr, r->string1);
9380                 } else {
9381                         r->string1 = NULL;
9382                 }
9383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9384                 if (_ptr_string2) {
9385                         NDR_PULL_ALLOC(ndr, r->string2);
9386                 } else {
9387                         r->string2 = NULL;
9388                 }
9389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
9390         }
9391         if (ndr_flags & NDR_BUFFERS) {
9392                 if (r->object_dn) {
9393                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9394                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9395                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9396                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9397                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9398                                 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));
9399                         }
9400                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9401                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9402                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9403                 }
9404                 if (r->string1) {
9405                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9406                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9407                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9408                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9409                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9410                                 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));
9411                         }
9412                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9413                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9415                 }
9416                 if (r->string2) {
9417                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9418                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9419                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9420                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9421                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9422                                 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));
9423                         }
9424                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9425                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9427                 }
9428         }
9429         return NDR_ERR_SUCCESS;
9430 }
9431
9432 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9433 {
9434         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9435         ndr->depth++;
9436         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9437         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9438         ndr->depth++;
9439         if (r->object_dn) {
9440                 ndr_print_string(ndr, "object_dn", r->object_dn);
9441         }
9442         ndr->depth--;
9443         ndr_print_GUID(ndr, "guid1", &r->guid1);
9444         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9445         ndr_print_ptr(ndr, "string1", r->string1);
9446         ndr->depth++;
9447         if (r->string1) {
9448                 ndr_print_string(ndr, "string1", r->string1);
9449         }
9450         ndr->depth--;
9451         ndr_print_ptr(ndr, "string2", r->string2);
9452         ndr->depth++;
9453         if (r->string2) {
9454                 ndr_print_string(ndr, "string2", r->string2);
9455         }
9456         ndr->depth--;
9457         ndr_print_uint32(ndr, "unknown2", r->unknown2);
9458         ndr->depth--;
9459 }
9460
9461 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9462 {
9463         if (ndr_flags & NDR_SCALARS) {
9464                 int level = ndr_push_get_switch_value(ndr, r);
9465                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9466                 switch (level) {
9467                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9468                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9469                         break; }
9470
9471                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9472                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9473                         break; }
9474
9475                         default:
9476                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9477                 }
9478         }
9479         if (ndr_flags & NDR_BUFFERS) {
9480                 int level = ndr_push_get_switch_value(ndr, r);
9481                 switch (level) {
9482                         case DRSUAPI_DS_REPLICA_GET_INFO:
9483                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9484                         break;
9485
9486                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9487                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9488                         break;
9489
9490                         default:
9491                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9492                 }
9493         }
9494         return NDR_ERR_SUCCESS;
9495 }
9496
9497 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9498 {
9499         int level;
9500         uint32_t _level;
9501         level = ndr_pull_get_switch_value(ndr, r);
9502         if (ndr_flags & NDR_SCALARS) {
9503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9504                 if (_level != level) {
9505                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9506                 }
9507                 switch (level) {
9508                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9509                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9510                         break; }
9511
9512                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9513                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9514                         break; }
9515
9516                         default:
9517                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9518                 }
9519         }
9520         if (ndr_flags & NDR_BUFFERS) {
9521                 switch (level) {
9522                         case DRSUAPI_DS_REPLICA_GET_INFO:
9523                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9524                         break;
9525
9526                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9527                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9528                         break;
9529
9530                         default:
9531                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9532                 }
9533         }
9534         return NDR_ERR_SUCCESS;
9535 }
9536
9537 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9538 {
9539         int level;
9540         level = ndr_print_get_switch_value(ndr, r);
9541         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9542         switch (level) {
9543                 case DRSUAPI_DS_REPLICA_GET_INFO:
9544                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9545                 break;
9546
9547                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9548                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9549                 break;
9550
9551                 default:
9552                         ndr_print_bad_level(ndr, name, level);
9553         }
9554 }
9555
9556 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9557 {
9558         if (ndr_flags & NDR_SCALARS) {
9559                 NDR_CHECK(ndr_push_align(ndr, 8));
9560                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9561                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9562                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9563                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9564                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
9565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9566                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9567                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9568                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9569                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9570                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9571                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9572                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9573                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9574                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9576         }
9577         if (ndr_flags & NDR_BUFFERS) {
9578                 if (r->naming_context_dn) {
9579                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9580                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9581                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9582                         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));
9583                 }
9584                 if (r->source_dsa_obj_dn) {
9585                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9586                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9587                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9588                         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));
9589                 }
9590                 if (r->source_dsa_address) {
9591                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9592                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9593                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9594                         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));
9595                 }
9596                 if (r->transport_obj_dn) {
9597                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9598                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9599                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9600                         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));
9601                 }
9602         }
9603         return NDR_ERR_SUCCESS;
9604 }
9605
9606 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9607 {
9608         uint32_t _ptr_naming_context_dn;
9609         TALLOC_CTX *_mem_save_naming_context_dn_0;
9610         uint32_t _ptr_source_dsa_obj_dn;
9611         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9612         uint32_t _ptr_source_dsa_address;
9613         TALLOC_CTX *_mem_save_source_dsa_address_0;
9614         uint32_t _ptr_transport_obj_dn;
9615         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9616         if (ndr_flags & NDR_SCALARS) {
9617                 NDR_CHECK(ndr_pull_align(ndr, 8));
9618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9619                 if (_ptr_naming_context_dn) {
9620                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9621                 } else {
9622                         r->naming_context_dn = NULL;
9623                 }
9624                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9625                 if (_ptr_source_dsa_obj_dn) {
9626                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9627                 } else {
9628                         r->source_dsa_obj_dn = NULL;
9629                 }
9630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9631                 if (_ptr_source_dsa_address) {
9632                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9633                 } else {
9634                         r->source_dsa_address = NULL;
9635                 }
9636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9637                 if (_ptr_transport_obj_dn) {
9638                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9639                 } else {
9640                         r->transport_obj_dn = NULL;
9641                 }
9642                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
9643                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9644                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9645                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9646                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9647                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9648                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9649                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9650                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
9651                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
9652                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
9653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
9654         }
9655         if (ndr_flags & NDR_BUFFERS) {
9656                 if (r->naming_context_dn) {
9657                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9658                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
9659                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
9660                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
9661                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
9662                                 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));
9663                         }
9664                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
9665                         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));
9666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
9667                 }
9668                 if (r->source_dsa_obj_dn) {
9669                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9670                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
9671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
9672                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
9673                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
9674                                 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));
9675                         }
9676                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
9677                         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));
9678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
9679                 }
9680                 if (r->source_dsa_address) {
9681                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
9682                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
9683                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
9684                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
9685                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
9686                                 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));
9687                         }
9688                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
9689                         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));
9690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
9691                 }
9692                 if (r->transport_obj_dn) {
9693                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9694                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
9695                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
9696                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
9697                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
9698                                 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));
9699                         }
9700                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
9701                         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));
9702                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
9703                 }
9704         }
9705         return NDR_ERR_SUCCESS;
9706 }
9707
9708 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
9709 {
9710         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
9711         ndr->depth++;
9712         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
9713         ndr->depth++;
9714         if (r->naming_context_dn) {
9715                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
9716         }
9717         ndr->depth--;
9718         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
9719         ndr->depth++;
9720         if (r->source_dsa_obj_dn) {
9721                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
9722         }
9723         ndr->depth--;
9724         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
9725         ndr->depth++;
9726         if (r->source_dsa_address) {
9727                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
9728         }
9729         ndr->depth--;
9730         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
9731         ndr->depth++;
9732         if (r->transport_obj_dn) {
9733                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
9734         }
9735         ndr->depth--;
9736         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
9737         ndr_print_uint32(ndr, "reserved", r->reserved);
9738         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
9739         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
9740         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
9741         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
9742         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
9743         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
9744         ndr_print_NTTIME(ndr, "last_success", r->last_success);
9745         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
9746         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
9747         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
9748         ndr->depth--;
9749 }
9750
9751 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
9752 {
9753         uint32_t cntr_array_0;
9754         if (ndr_flags & NDR_SCALARS) {
9755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9756                 NDR_CHECK(ndr_push_align(ndr, 8));
9757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9759                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9760                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9761                 }
9762         }
9763         if (ndr_flags & NDR_BUFFERS) {
9764                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9765                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9766                 }
9767         }
9768         return NDR_ERR_SUCCESS;
9769 }
9770
9771 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
9772 {
9773         uint32_t cntr_array_0;
9774         TALLOC_CTX *_mem_save_array_0;
9775         if (ndr_flags & NDR_SCALARS) {
9776                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9777                 NDR_CHECK(ndr_pull_align(ndr, 8));
9778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9780                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9781                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9782                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9783                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9784                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9785                 }
9786                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9787                 if (r->array) {
9788                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9789                 }
9790         }
9791         if (ndr_flags & NDR_BUFFERS) {
9792                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9793                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9794                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9795                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9796                 }
9797                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9798         }
9799         return NDR_ERR_SUCCESS;
9800 }
9801
9802 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
9803 {
9804         uint32_t cntr_array_0;
9805         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
9806         ndr->depth++;
9807         ndr_print_uint32(ndr, "count", r->count);
9808         ndr_print_uint32(ndr, "reserved", r->reserved);
9809         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9810         ndr->depth++;
9811         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9812                 char *idx_0=NULL;
9813                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9814                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
9815                         free(idx_0);
9816                 }
9817         }
9818         ndr->depth--;
9819         ndr->depth--;
9820 }
9821
9822 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
9823 {
9824         uint32_t cntr_array_0;
9825         if (ndr_flags & NDR_SCALARS) {
9826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9827                 NDR_CHECK(ndr_push_align(ndr, 8));
9828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9830                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9831                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9832                 }
9833         }
9834         if (ndr_flags & NDR_BUFFERS) {
9835         }
9836         return NDR_ERR_SUCCESS;
9837 }
9838
9839 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
9840 {
9841         uint32_t cntr_array_0;
9842         TALLOC_CTX *_mem_save_array_0;
9843         if (ndr_flags & NDR_SCALARS) {
9844                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9845                 NDR_CHECK(ndr_pull_align(ndr, 8));
9846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9848                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9849                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9850                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9851                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9852                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9853                 }
9854                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9855                 if (r->array) {
9856                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9857                 }
9858         }
9859         if (ndr_flags & NDR_BUFFERS) {
9860         }
9861         return NDR_ERR_SUCCESS;
9862 }
9863
9864 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
9865 {
9866         uint32_t cntr_array_0;
9867         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
9868         ndr->depth++;
9869         ndr_print_uint32(ndr, "count", r->count);
9870         ndr_print_uint32(ndr, "reserved", r->reserved);
9871         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9872         ndr->depth++;
9873         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9874                 char *idx_0=NULL;
9875                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9876                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
9877                         free(idx_0);
9878                 }
9879         }
9880         ndr->depth--;
9881         ndr->depth--;
9882 }
9883
9884 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
9885 {
9886         if (ndr_flags & NDR_SCALARS) {
9887                 NDR_CHECK(ndr_push_align(ndr, 8));
9888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
9889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
9890                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
9891                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9892                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
9893                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
9894         }
9895         if (ndr_flags & NDR_BUFFERS) {
9896                 if (r->attribute_name) {
9897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9901                 }
9902         }
9903         return NDR_ERR_SUCCESS;
9904 }
9905
9906 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
9907 {
9908         uint32_t _ptr_attribute_name;
9909         TALLOC_CTX *_mem_save_attribute_name_0;
9910         if (ndr_flags & NDR_SCALARS) {
9911                 NDR_CHECK(ndr_pull_align(ndr, 8));
9912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
9913                 if (_ptr_attribute_name) {
9914                         NDR_PULL_ALLOC(ndr, r->attribute_name);
9915                 } else {
9916                         r->attribute_name = NULL;
9917                 }
9918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
9919                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
9920                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9921                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
9922                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
9923         }
9924         if (ndr_flags & NDR_BUFFERS) {
9925                 if (r->attribute_name) {
9926                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9927                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
9928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
9929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
9930                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
9931                                 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));
9932                         }
9933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
9934                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
9935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
9936                 }
9937         }
9938         return NDR_ERR_SUCCESS;
9939 }
9940
9941 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
9942 {
9943         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
9944         ndr->depth++;
9945         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
9946         ndr->depth++;
9947         if (r->attribute_name) {
9948                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
9949         }
9950         ndr->depth--;
9951         ndr_print_uint32(ndr, "version", r->version);
9952         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
9953         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
9954         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
9955         ndr_print_hyper(ndr, "local_usn", r->local_usn);
9956         ndr->depth--;
9957 }
9958
9959 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
9960 {
9961         uint32_t cntr_array_0;
9962         if (ndr_flags & NDR_SCALARS) {
9963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9964                 NDR_CHECK(ndr_push_align(ndr, 8));
9965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9967                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9968                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9969                 }
9970         }
9971         if (ndr_flags & NDR_BUFFERS) {
9972                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9973                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9974                 }
9975         }
9976         return NDR_ERR_SUCCESS;
9977 }
9978
9979 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
9980 {
9981         uint32_t cntr_array_0;
9982         TALLOC_CTX *_mem_save_array_0;
9983         if (ndr_flags & NDR_SCALARS) {
9984                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9985                 NDR_CHECK(ndr_pull_align(ndr, 8));
9986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9988                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9989                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9990                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9991                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9992                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9993                 }
9994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9995                 if (r->array) {
9996                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9997                 }
9998         }
9999         if (ndr_flags & NDR_BUFFERS) {
10000                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10001                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10002                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10003                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10004                 }
10005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10006         }
10007         return NDR_ERR_SUCCESS;
10008 }
10009
10010 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10011 {
10012         uint32_t cntr_array_0;
10013         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10014         ndr->depth++;
10015         ndr_print_uint32(ndr, "count", r->count);
10016         ndr_print_uint32(ndr, "reserved", r->reserved);
10017         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10018         ndr->depth++;
10019         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10020                 char *idx_0=NULL;
10021                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10022                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10023                         free(idx_0);
10024                 }
10025         }
10026         ndr->depth--;
10027         ndr->depth--;
10028 }
10029
10030 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10031 {
10032         if (ndr_flags & NDR_SCALARS) {
10033                 NDR_CHECK(ndr_push_align(ndr, 4));
10034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10035                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10036                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10038                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10039         }
10040         if (ndr_flags & NDR_BUFFERS) {
10041                 if (r->dsa_obj_dn) {
10042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10045                         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));
10046                 }
10047         }
10048         return NDR_ERR_SUCCESS;
10049 }
10050
10051 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10052 {
10053         uint32_t _ptr_dsa_obj_dn;
10054         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10055         if (ndr_flags & NDR_SCALARS) {
10056                 NDR_CHECK(ndr_pull_align(ndr, 4));
10057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10058                 if (_ptr_dsa_obj_dn) {
10059                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10060                 } else {
10061                         r->dsa_obj_dn = NULL;
10062                 }
10063                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10064                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10066                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10067         }
10068         if (ndr_flags & NDR_BUFFERS) {
10069                 if (r->dsa_obj_dn) {
10070                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10071                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10074                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10075                                 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));
10076                         }
10077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10078                         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));
10079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10080                 }
10081         }
10082         return NDR_ERR_SUCCESS;
10083 }
10084
10085 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10086 {
10087         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10088         ndr->depth++;
10089         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10090         ndr->depth++;
10091         if (r->dsa_obj_dn) {
10092                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10093         }
10094         ndr->depth--;
10095         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10096         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10097         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10098         ndr_print_WERROR(ndr, "last_result", r->last_result);
10099         ndr->depth--;
10100 }
10101
10102 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10103 {
10104         uint32_t cntr_array_0;
10105         if (ndr_flags & NDR_SCALARS) {
10106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10107                 NDR_CHECK(ndr_push_align(ndr, 4));
10108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10110                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10111                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10112                 }
10113         }
10114         if (ndr_flags & NDR_BUFFERS) {
10115                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10116                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10117                 }
10118         }
10119         return NDR_ERR_SUCCESS;
10120 }
10121
10122 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10123 {
10124         uint32_t cntr_array_0;
10125         TALLOC_CTX *_mem_save_array_0;
10126         if (ndr_flags & NDR_SCALARS) {
10127                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10128                 NDR_CHECK(ndr_pull_align(ndr, 4));
10129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10131                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10132                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10133                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10134                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10135                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10136                 }
10137                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10138                 if (r->array) {
10139                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10140                 }
10141         }
10142         if (ndr_flags & NDR_BUFFERS) {
10143                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10144                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10145                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10146                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10147                 }
10148                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10149         }
10150         return NDR_ERR_SUCCESS;
10151 }
10152
10153 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10154 {
10155         uint32_t cntr_array_0;
10156         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10157         ndr->depth++;
10158         ndr_print_uint32(ndr, "count", r->count);
10159         ndr_print_uint32(ndr, "reserved", r->reserved);
10160         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10161         ndr->depth++;
10162         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10163                 char *idx_0=NULL;
10164                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10165                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10166                         free(idx_0);
10167                 }
10168         }
10169         ndr->depth--;
10170         ndr->depth--;
10171 }
10172
10173 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10174 {
10175         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
10176         return NDR_ERR_SUCCESS;
10177 }
10178
10179 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10180 {
10181         uint16_t v;
10182         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
10183         *r = v;
10184         return NDR_ERR_SUCCESS;
10185 }
10186
10187 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10188 {
10189         const char *val = NULL;
10190
10191         switch (r) {
10192                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10193                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10194                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10195                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10196                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10197         }
10198         ndr_print_enum(ndr, name, "ENUM", val, r);
10199 }
10200
10201 static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
10202 {
10203         if (ndr_flags & NDR_SCALARS) {
10204                 int level = ndr_push_get_switch_value(ndr, r);
10205                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
10206                 switch (level) {
10207                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10208                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
10209                         break; }
10210
10211                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10212                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
10213                         break; }
10214
10215                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10216                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
10217                         break; }
10218
10219                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10220                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
10221                         break; }
10222
10223                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10224                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
10225                         break; }
10226
10227                         default: {
10228                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
10229                         break; }
10230
10231                 }
10232         }
10233         if (ndr_flags & NDR_BUFFERS) {
10234                 int level = ndr_push_get_switch_value(ndr, r);
10235                 switch (level) {
10236                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10237                         break;
10238
10239                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10240                         break;
10241
10242                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10243                         break;
10244
10245                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10246                         break;
10247
10248                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10249                         break;
10250
10251                         default:
10252                         break;
10253
10254                 }
10255         }
10256         return NDR_ERR_SUCCESS;
10257 }
10258
10259 static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
10260 {
10261         int level;
10262         uint16_t _level;
10263         level = ndr_pull_get_switch_value(ndr, r);
10264         if (ndr_flags & NDR_SCALARS) {
10265                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
10266                 if (_level != level) {
10267                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10268                 }
10269                 switch (level) {
10270                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10271                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
10272                         break; }
10273
10274                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10275                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
10276                         break; }
10277
10278                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10279                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
10280                         break; }
10281
10282                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10283                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
10284                         break; }
10285
10286                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10287                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
10288                         break; }
10289
10290                         default: {
10291                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
10292                         break; }
10293
10294                 }
10295         }
10296         if (ndr_flags & NDR_BUFFERS) {
10297                 switch (level) {
10298                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10299                         break;
10300
10301                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10302                         break;
10303
10304                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10305                         break;
10306
10307                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10308                         break;
10309
10310                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10311                         break;
10312
10313                         default:
10314                         break;
10315
10316                 }
10317         }
10318         return NDR_ERR_SUCCESS;
10319 }
10320
10321 _PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
10322 {
10323         int level;
10324         level = ndr_print_get_switch_value(ndr, r);
10325         ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
10326         switch (level) {
10327                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10328                         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
10329                 break;
10330
10331                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10332                         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
10333                 break;
10334
10335                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10336                         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
10337                 break;
10338
10339                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10340                         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
10341                 break;
10342
10343                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10344                         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
10345                 break;
10346
10347                 default:
10348                         ndr_print_uint32(ndr, "unknown", r->unknown);
10349                 break;
10350
10351         }
10352 }
10353
10354 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10355 {
10356         if (ndr_flags & NDR_SCALARS) {
10357                 NDR_CHECK(ndr_push_align(ndr, 4));
10358                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10361                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10362                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
10363                 NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10367                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10368                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10369         }
10370         if (ndr_flags & NDR_BUFFERS) {
10371                 if (r->nc_dn) {
10372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10375                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10376                 }
10377                 if (r->remote_dsa_obj_dn) {
10378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10381                         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));
10382                 }
10383                 if (r->remote_dsa_address) {
10384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10387                         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));
10388                 }
10389         }
10390         return NDR_ERR_SUCCESS;
10391 }
10392
10393 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10394 {
10395         uint32_t _ptr_nc_dn;
10396         TALLOC_CTX *_mem_save_nc_dn_0;
10397         uint32_t _ptr_remote_dsa_obj_dn;
10398         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10399         uint32_t _ptr_remote_dsa_address;
10400         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10401         if (ndr_flags & NDR_SCALARS) {
10402                 NDR_CHECK(ndr_pull_align(ndr, 4));
10403                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10404                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10406                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10407                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
10408                 NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10409                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10410                 if (_ptr_nc_dn) {
10411                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10412                 } else {
10413                         r->nc_dn = NULL;
10414                 }
10415                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10416                 if (_ptr_remote_dsa_obj_dn) {
10417                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10418                 } else {
10419                         r->remote_dsa_obj_dn = NULL;
10420                 }
10421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10422                 if (_ptr_remote_dsa_address) {
10423                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10424                 } else {
10425                         r->remote_dsa_address = NULL;
10426                 }
10427                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10428                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10429         }
10430         if (ndr_flags & NDR_BUFFERS) {
10431                 if (r->nc_dn) {
10432                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10433                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10434                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10435                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10436                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10437                                 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));
10438                         }
10439                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10440                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10442                 }
10443                 if (r->remote_dsa_obj_dn) {
10444                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10445                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10446                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10447                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10448                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10449                                 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));
10450                         }
10451                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10452                         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));
10453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10454                 }
10455                 if (r->remote_dsa_address) {
10456                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10457                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10458                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10459                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10460                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10461                                 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));
10462                         }
10463                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10464                         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));
10465                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10466                 }
10467         }
10468         return NDR_ERR_SUCCESS;
10469 }
10470
10471 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10472 {
10473         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10474         ndr->depth++;
10475         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10476         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10477         ndr_print_uint32(ndr, "priority", r->priority);
10478         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10479         ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
10480         ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
10481         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10482         ndr->depth++;
10483         if (r->nc_dn) {
10484                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10485         }
10486         ndr->depth--;
10487         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10488         ndr->depth++;
10489         if (r->remote_dsa_obj_dn) {
10490                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10491         }
10492         ndr->depth--;
10493         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10494         ndr->depth++;
10495         if (r->remote_dsa_address) {
10496                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10497         }
10498         ndr->depth--;
10499         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10500         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10501         ndr->depth--;
10502 }
10503
10504 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10505 {
10506         uint32_t cntr_array_0;
10507         if (ndr_flags & NDR_SCALARS) {
10508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10509                 NDR_CHECK(ndr_push_align(ndr, 4));
10510                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10512                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10513                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10514                 }
10515         }
10516         if (ndr_flags & NDR_BUFFERS) {
10517                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10518                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10519                 }
10520         }
10521         return NDR_ERR_SUCCESS;
10522 }
10523
10524 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10525 {
10526         uint32_t cntr_array_0;
10527         TALLOC_CTX *_mem_save_array_0;
10528         if (ndr_flags & NDR_SCALARS) {
10529                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10530                 NDR_CHECK(ndr_pull_align(ndr, 4));
10531                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10533                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10534                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10535                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10536                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10537                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10538                 }
10539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10540                 if (r->array) {
10541                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10542                 }
10543         }
10544         if (ndr_flags & NDR_BUFFERS) {
10545                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10546                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10547                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10548                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10549                 }
10550                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10551         }
10552         return NDR_ERR_SUCCESS;
10553 }
10554
10555 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10556 {
10557         uint32_t cntr_array_0;
10558         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10559         ndr->depth++;
10560         ndr_print_NTTIME(ndr, "time", r->time);
10561         ndr_print_uint32(ndr, "count", r->count);
10562         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10563         ndr->depth++;
10564         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10565                 char *idx_0=NULL;
10566                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10567                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10568                         free(idx_0);
10569                 }
10570         }
10571         ndr->depth--;
10572         ndr->depth--;
10573 }
10574
10575 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10576 {
10577         if (ndr_flags & NDR_SCALARS) {
10578                 NDR_CHECK(ndr_push_align(ndr, 8));
10579                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10580                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10582                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10583                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10584                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10586                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10587                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10588                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10589                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10590         }
10591         if (ndr_flags & NDR_BUFFERS) {
10592                 if (r->attribute_name) {
10593                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10594                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10595                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10596                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10597                 }
10598                 if (r->object_dn) {
10599                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10600                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10601                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10602                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10603                 }
10604                 if (r->binary) {
10605                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10606                 }
10607         }
10608         return NDR_ERR_SUCCESS;
10609 }
10610
10611 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10612 {
10613         uint32_t _ptr_attribute_name;
10614         TALLOC_CTX *_mem_save_attribute_name_0;
10615         uint32_t _ptr_object_dn;
10616         TALLOC_CTX *_mem_save_object_dn_0;
10617         uint32_t _ptr_binary;
10618         TALLOC_CTX *_mem_save_binary_0;
10619         if (ndr_flags & NDR_SCALARS) {
10620                 NDR_CHECK(ndr_pull_align(ndr, 8));
10621                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10622                 if (_ptr_attribute_name) {
10623                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10624                 } else {
10625                         r->attribute_name = NULL;
10626                 }
10627                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10628                 if (_ptr_object_dn) {
10629                         NDR_PULL_ALLOC(ndr, r->object_dn);
10630                 } else {
10631                         r->object_dn = NULL;
10632                 }
10633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10634                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10635                 if (_ptr_binary) {
10636                         NDR_PULL_ALLOC(ndr, r->binary);
10637                 } else {
10638                         r->binary = NULL;
10639                 }
10640                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10641                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10643                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10644                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10645                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10646                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10647         }
10648         if (ndr_flags & NDR_BUFFERS) {
10649                 if (r->attribute_name) {
10650                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10651                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10652                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10653                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10654                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10655                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
10656                         }
10657                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10658                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10660                 }
10661                 if (r->object_dn) {
10662                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10663                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10666                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10667                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
10668                         }
10669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10672                 }
10673                 if (r->binary) {
10674                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10675                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10676                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10677                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10678                 }
10679         }
10680         return NDR_ERR_SUCCESS;
10681 }
10682
10683 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10684 {
10685         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10686         ndr->depth++;
10687         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10688         ndr->depth++;
10689         if (r->attribute_name) {
10690                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10691         }
10692         ndr->depth--;
10693         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10694         ndr->depth++;
10695         if (r->object_dn) {
10696                 ndr_print_string(ndr, "object_dn", r->object_dn);
10697         }
10698         ndr->depth--;
10699         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);
10700         ndr_print_ptr(ndr, "binary", r->binary);
10701         ndr->depth++;
10702         if (r->binary) {
10703                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10704         }
10705         ndr->depth--;
10706         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10707         ndr_print_NTTIME(ndr, "created", r->created);
10708         ndr_print_uint32(ndr, "version", r->version);
10709         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10710         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10711         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10712         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10713         ndr->depth--;
10714 }
10715
10716 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10717 {
10718         uint32_t cntr_array_0;
10719         if (ndr_flags & NDR_SCALARS) {
10720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10721                 NDR_CHECK(ndr_push_align(ndr, 8));
10722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10723                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10724                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10725                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10726                 }
10727         }
10728         if (ndr_flags & NDR_BUFFERS) {
10729                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10730                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10731                 }
10732         }
10733         return NDR_ERR_SUCCESS;
10734 }
10735
10736 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10737 {
10738         uint32_t cntr_array_0;
10739         TALLOC_CTX *_mem_save_array_0;
10740         if (ndr_flags & NDR_SCALARS) {
10741                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10742                 NDR_CHECK(ndr_pull_align(ndr, 8));
10743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10744                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10745                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10746                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10747                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10748                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10749                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10750                 }
10751                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10752                 if (r->array) {
10753                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10754                 }
10755         }
10756         if (ndr_flags & NDR_BUFFERS) {
10757                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10758                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10759                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10760                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10761                 }
10762                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10763         }
10764         return NDR_ERR_SUCCESS;
10765 }
10766
10767 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10768 {
10769         uint32_t cntr_array_0;
10770         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10771         ndr->depth++;
10772         ndr_print_uint32(ndr, "count", r->count);
10773         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10774         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10775         ndr->depth++;
10776         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10777                 char *idx_0=NULL;
10778                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10779                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10780                         free(idx_0);
10781                 }
10782         }
10783         ndr->depth--;
10784         ndr->depth--;
10785 }
10786
10787 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
10788 {
10789         uint32_t cntr_array_0;
10790         if (ndr_flags & NDR_SCALARS) {
10791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10792                 NDR_CHECK(ndr_push_align(ndr, 8));
10793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10794                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10795                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10796                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10797                 }
10798         }
10799         if (ndr_flags & NDR_BUFFERS) {
10800         }
10801         return NDR_ERR_SUCCESS;
10802 }
10803
10804 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
10805 {
10806         uint32_t cntr_array_0;
10807         TALLOC_CTX *_mem_save_array_0;
10808         if (ndr_flags & NDR_SCALARS) {
10809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10810                 NDR_CHECK(ndr_pull_align(ndr, 8));
10811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10812                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10813                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10814                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10815                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10816                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10817                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10818                 }
10819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10820                 if (r->array) {
10821                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10822                 }
10823         }
10824         if (ndr_flags & NDR_BUFFERS) {
10825         }
10826         return NDR_ERR_SUCCESS;
10827 }
10828
10829 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
10830 {
10831         uint32_t cntr_array_0;
10832         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
10833         ndr->depth++;
10834         ndr_print_uint32(ndr, "count", r->count);
10835         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10836         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10837         ndr->depth++;
10838         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10839                 char *idx_0=NULL;
10840                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10841                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
10842                         free(idx_0);
10843                 }
10844         }
10845         ndr->depth--;
10846         ndr->depth--;
10847 }
10848
10849 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
10850 {
10851         if (ndr_flags & NDR_SCALARS) {
10852                 NDR_CHECK(ndr_push_align(ndr, 8));
10853                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10854                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
10855                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
10856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
10857         }
10858         if (ndr_flags & NDR_BUFFERS) {
10859                 if (r->source_dsa_obj_dn) {
10860                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10861                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10862                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10863                         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));
10864                 }
10865         }
10866         return NDR_ERR_SUCCESS;
10867 }
10868
10869 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
10870 {
10871         uint32_t _ptr_source_dsa_obj_dn;
10872         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
10873         if (ndr_flags & NDR_SCALARS) {
10874                 NDR_CHECK(ndr_pull_align(ndr, 8));
10875                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10876                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
10877                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
10878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
10879                 if (_ptr_source_dsa_obj_dn) {
10880                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
10881                 } else {
10882                         r->source_dsa_obj_dn = NULL;
10883                 }
10884         }
10885         if (ndr_flags & NDR_BUFFERS) {
10886                 if (r->source_dsa_obj_dn) {
10887                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10888                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10889                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10890                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10891                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10892                                 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));
10893                         }
10894                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10895                         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));
10896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10897                 }
10898         }
10899         return NDR_ERR_SUCCESS;
10900 }
10901
10902 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
10903 {
10904         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
10905         ndr->depth++;
10906         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10907         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10908         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
10909         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10910         ndr->depth++;
10911         if (r->source_dsa_obj_dn) {
10912                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10913         }
10914         ndr->depth--;
10915         ndr->depth--;
10916 }
10917
10918 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
10919 {
10920         uint32_t cntr_array_0;
10921         if (ndr_flags & NDR_SCALARS) {
10922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10923                 NDR_CHECK(ndr_push_align(ndr, 8));
10924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10925                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10926                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10927                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10928                 }
10929         }
10930         if (ndr_flags & NDR_BUFFERS) {
10931                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10932                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10933                 }
10934         }
10935         return NDR_ERR_SUCCESS;
10936 }
10937
10938 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
10939 {
10940         uint32_t cntr_array_0;
10941         TALLOC_CTX *_mem_save_array_0;
10942         if (ndr_flags & NDR_SCALARS) {
10943                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10944                 NDR_CHECK(ndr_pull_align(ndr, 8));
10945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10946                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10947                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10948                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10949                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10950                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10951                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10952                 }
10953                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10954                 if (r->array) {
10955                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10956                 }
10957         }
10958         if (ndr_flags & NDR_BUFFERS) {
10959                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10960                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10961                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10962                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10963                 }
10964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10965         }
10966         return NDR_ERR_SUCCESS;
10967 }
10968
10969 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
10970 {
10971         uint32_t cntr_array_0;
10972         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
10973         ndr->depth++;
10974         ndr_print_uint32(ndr, "count", r->count);
10975         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10976         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10977         ndr->depth++;
10978         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10979                 char *idx_0=NULL;
10980                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10981                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
10982                         free(idx_0);
10983                 }
10984         }
10985         ndr->depth--;
10986         ndr->depth--;
10987 }
10988
10989 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
10990 {
10991         if (ndr_flags & NDR_SCALARS) {
10992                 NDR_CHECK(ndr_push_align(ndr, 8));
10993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10995                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10996                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10997                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10998                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11000         }
11001         if (ndr_flags & NDR_BUFFERS) {
11002                 if (r->attribute_name) {
11003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11006                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11007                 }
11008                 if (r->originating_dsa_dn) {
11009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11012                         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));
11013                 }
11014         }
11015         return NDR_ERR_SUCCESS;
11016 }
11017
11018 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11019 {
11020         uint32_t _ptr_attribute_name;
11021         TALLOC_CTX *_mem_save_attribute_name_0;
11022         uint32_t _ptr_originating_dsa_dn;
11023         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11024         if (ndr_flags & NDR_SCALARS) {
11025                 NDR_CHECK(ndr_pull_align(ndr, 8));
11026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11027                 if (_ptr_attribute_name) {
11028                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11029                 } else {
11030                         r->attribute_name = NULL;
11031                 }
11032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11033                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11034                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11035                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11036                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11037                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11038                 if (_ptr_originating_dsa_dn) {
11039                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11040                 } else {
11041                         r->originating_dsa_dn = NULL;
11042                 }
11043         }
11044         if (ndr_flags & NDR_BUFFERS) {
11045                 if (r->attribute_name) {
11046                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11047                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11050                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11051                                 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));
11052                         }
11053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11056                 }
11057                 if (r->originating_dsa_dn) {
11058                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11059                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11062                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11063                                 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));
11064                         }
11065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11066                         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));
11067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11068                 }
11069         }
11070         return NDR_ERR_SUCCESS;
11071 }
11072
11073 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11074 {
11075         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11076         ndr->depth++;
11077         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11078         ndr->depth++;
11079         if (r->attribute_name) {
11080                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11081         }
11082         ndr->depth--;
11083         ndr_print_uint32(ndr, "version", r->version);
11084         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11085         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11086         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11087         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11088         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11089         ndr->depth++;
11090         if (r->originating_dsa_dn) {
11091                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11092         }
11093         ndr->depth--;
11094         ndr->depth--;
11095 }
11096
11097 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11098 {
11099         uint32_t cntr_array_0;
11100         if (ndr_flags & NDR_SCALARS) {
11101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11102                 NDR_CHECK(ndr_push_align(ndr, 8));
11103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11104                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11105                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11106                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11107                 }
11108         }
11109         if (ndr_flags & NDR_BUFFERS) {
11110                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11111                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11112                 }
11113         }
11114         return NDR_ERR_SUCCESS;
11115 }
11116
11117 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11118 {
11119         uint32_t cntr_array_0;
11120         TALLOC_CTX *_mem_save_array_0;
11121         if (ndr_flags & NDR_SCALARS) {
11122                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11123                 NDR_CHECK(ndr_pull_align(ndr, 8));
11124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11125                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11126                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11127                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11128                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11129                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11130                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11131                 }
11132                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11133                 if (r->array) {
11134                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11135                 }
11136         }
11137         if (ndr_flags & NDR_BUFFERS) {
11138                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11139                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11140                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11141                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11142                 }
11143                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11144         }
11145         return NDR_ERR_SUCCESS;
11146 }
11147
11148 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11149 {
11150         uint32_t cntr_array_0;
11151         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11152         ndr->depth++;
11153         ndr_print_uint32(ndr, "count", r->count);
11154         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11155         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11156         ndr->depth++;
11157         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11158                 char *idx_0=NULL;
11159                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11160                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11161                         free(idx_0);
11162                 }
11163         }
11164         ndr->depth--;
11165         ndr->depth--;
11166 }
11167
11168 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11169 {
11170         if (ndr_flags & NDR_SCALARS) {
11171                 NDR_CHECK(ndr_push_align(ndr, 8));
11172                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11173                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11175                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11176                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11177                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11179                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11180                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11181                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11182                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11184         }
11185         if (ndr_flags & NDR_BUFFERS) {
11186                 if (r->attribute_name) {
11187                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11188                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11189                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11190                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11191                 }
11192                 if (r->object_dn) {
11193                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11197                 }
11198                 if (r->binary) {
11199                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11200                 }
11201                 if (r->originating_dsa_dn) {
11202                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11203                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11204                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11205                         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));
11206                 }
11207         }
11208         return NDR_ERR_SUCCESS;
11209 }
11210
11211 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11212 {
11213         uint32_t _ptr_attribute_name;
11214         TALLOC_CTX *_mem_save_attribute_name_0;
11215         uint32_t _ptr_object_dn;
11216         TALLOC_CTX *_mem_save_object_dn_0;
11217         uint32_t _ptr_binary;
11218         TALLOC_CTX *_mem_save_binary_0;
11219         uint32_t _ptr_originating_dsa_dn;
11220         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11221         if (ndr_flags & NDR_SCALARS) {
11222                 NDR_CHECK(ndr_pull_align(ndr, 8));
11223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11224                 if (_ptr_attribute_name) {
11225                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11226                 } else {
11227                         r->attribute_name = NULL;
11228                 }
11229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11230                 if (_ptr_object_dn) {
11231                         NDR_PULL_ALLOC(ndr, r->object_dn);
11232                 } else {
11233                         r->object_dn = NULL;
11234                 }
11235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11237                 if (_ptr_binary) {
11238                         NDR_PULL_ALLOC(ndr, r->binary);
11239                 } else {
11240                         r->binary = NULL;
11241                 }
11242                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11243                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11245                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11246                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11247                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11248                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11249                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11250                 if (_ptr_originating_dsa_dn) {
11251                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11252                 } else {
11253                         r->originating_dsa_dn = NULL;
11254                 }
11255         }
11256         if (ndr_flags & NDR_BUFFERS) {
11257                 if (r->attribute_name) {
11258                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11259                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11260                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11261                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11262                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11263                                 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));
11264                         }
11265                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11266                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11267                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11268                 }
11269                 if (r->object_dn) {
11270                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11271                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11272                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11273                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11274                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11275                                 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));
11276                         }
11277                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11278                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11280                 }
11281                 if (r->binary) {
11282                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11283                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11284                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11286                 }
11287                 if (r->originating_dsa_dn) {
11288                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11289                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11290                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11291                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11292                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11293                                 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));
11294                         }
11295                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11296                         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));
11297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11298                 }
11299         }
11300         return NDR_ERR_SUCCESS;
11301 }
11302
11303 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11304 {
11305         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11306         ndr->depth++;
11307         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11308         ndr->depth++;
11309         if (r->attribute_name) {
11310                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11311         }
11312         ndr->depth--;
11313         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11314         ndr->depth++;
11315         if (r->object_dn) {
11316                 ndr_print_string(ndr, "object_dn", r->object_dn);
11317         }
11318         ndr->depth--;
11319         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);
11320         ndr_print_ptr(ndr, "binary", r->binary);
11321         ndr->depth++;
11322         if (r->binary) {
11323                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11324         }
11325         ndr->depth--;
11326         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11327         ndr_print_NTTIME(ndr, "created", r->created);
11328         ndr_print_uint32(ndr, "version", r->version);
11329         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11330         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11331         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11332         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11333         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11334         ndr->depth++;
11335         if (r->originating_dsa_dn) {
11336                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11337         }
11338         ndr->depth--;
11339         ndr->depth--;
11340 }
11341
11342 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *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_int32(ndr, NDR_SCALARS, r->enumeration_context));
11350                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11351                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11352                 }
11353         }
11354         if (ndr_flags & NDR_BUFFERS) {
11355                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11356                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11357                 }
11358         }
11359         return NDR_ERR_SUCCESS;
11360 }
11361
11362 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11363 {
11364         uint32_t cntr_array_0;
11365         TALLOC_CTX *_mem_save_array_0;
11366         if (ndr_flags & NDR_SCALARS) {
11367                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11368                 NDR_CHECK(ndr_pull_align(ndr, 8));
11369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11370                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
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_DsReplicaAttrValMetaData2(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                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11384                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11385                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11386                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11387                 }
11388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11389         }
11390         return NDR_ERR_SUCCESS;
11391 }
11392
11393 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11394 {
11395         uint32_t cntr_array_0;
11396         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11397         ndr->depth++;
11398         ndr_print_uint32(ndr, "count", r->count);
11399         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11400         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11401         ndr->depth++;
11402         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11403                 char *idx_0=NULL;
11404                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11405                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11406                         free(idx_0);
11407                 }
11408         }
11409         ndr->depth--;
11410         ndr->depth--;
11411 }
11412
11413 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11414 {
11415         if (ndr_flags & NDR_SCALARS) {
11416                 NDR_CHECK(ndr_push_align(ndr, 8));
11417                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11420                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11421                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11422                 {
11423                         uint32_t _flags_save_ipv4address = ndr->flags;
11424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11425                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11426                         ndr->flags = _flags_save_ipv4address;
11427                 }
11428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11429         }
11430         if (ndr_flags & NDR_BUFFERS) {
11431         }
11432         return NDR_ERR_SUCCESS;
11433 }
11434
11435 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11436 {
11437         if (ndr_flags & NDR_SCALARS) {
11438                 NDR_CHECK(ndr_pull_align(ndr, 8));
11439                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11442                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11443                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11444                 {
11445                         uint32_t _flags_save_ipv4address = ndr->flags;
11446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11447                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11448                         ndr->flags = _flags_save_ipv4address;
11449                 }
11450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11451         }
11452         if (ndr_flags & NDR_BUFFERS) {
11453         }
11454         return NDR_ERR_SUCCESS;
11455 }
11456
11457 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11458 {
11459         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11460         ndr->depth++;
11461         ndr_print_hyper(ndr, "u1", r->u1);
11462         ndr_print_uint32(ndr, "u2", r->u2);
11463         ndr_print_uint32(ndr, "u3", r->u3);
11464         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11465         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11466         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11467         ndr_print_uint32(ndr, "u5", r->u5);
11468         ndr->depth--;
11469 }
11470
11471 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11472 {
11473         uint32_t cntr_array_0;
11474         if (ndr_flags & NDR_SCALARS) {
11475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11476                 NDR_CHECK(ndr_push_align(ndr, 8));
11477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11479                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11480                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11481                 }
11482         }
11483         if (ndr_flags & NDR_BUFFERS) {
11484         }
11485         return NDR_ERR_SUCCESS;
11486 }
11487
11488 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11489 {
11490         uint32_t cntr_array_0;
11491         TALLOC_CTX *_mem_save_array_0;
11492         if (ndr_flags & NDR_SCALARS) {
11493                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11494                 NDR_CHECK(ndr_pull_align(ndr, 8));
11495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11496                 if (r->count > 10000) {
11497                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11498                 }
11499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11500                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11501                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11502                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11503                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11504                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11505                 }
11506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11507                 if (r->array) {
11508                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11509                 }
11510         }
11511         if (ndr_flags & NDR_BUFFERS) {
11512         }
11513         return NDR_ERR_SUCCESS;
11514 }
11515
11516 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11517 {
11518         uint32_t cntr_array_0;
11519         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11520         ndr->depth++;
11521         ndr_print_uint32(ndr, "count", r->count);
11522         ndr_print_uint32(ndr, "reserved", r->reserved);
11523         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11524         ndr->depth++;
11525         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11526                 char *idx_0=NULL;
11527                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11528                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11529                         free(idx_0);
11530                 }
11531         }
11532         ndr->depth--;
11533         ndr->depth--;
11534 }
11535
11536 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11537 {
11538         if (ndr_flags & NDR_SCALARS) {
11539                 NDR_CHECK(ndr_push_align(ndr, 8));
11540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11546                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11548         }
11549         if (ndr_flags & NDR_BUFFERS) {
11550                 if (r->str1) {
11551                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11552                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11554                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11555                 }
11556         }
11557         return NDR_ERR_SUCCESS;
11558 }
11559
11560 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11561 {
11562         uint32_t _ptr_str1;
11563         TALLOC_CTX *_mem_save_str1_0;
11564         if (ndr_flags & NDR_SCALARS) {
11565                 NDR_CHECK(ndr_pull_align(ndr, 8));
11566                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11567                 if (_ptr_str1) {
11568                         NDR_PULL_ALLOC(ndr, r->str1);
11569                 } else {
11570                         r->str1 = NULL;
11571                 }
11572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11577                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11579         }
11580         if (ndr_flags & NDR_BUFFERS) {
11581                 if (r->str1) {
11582                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11583                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11584                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11585                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11586                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11587                                 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));
11588                         }
11589                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11592                 }
11593         }
11594         return NDR_ERR_SUCCESS;
11595 }
11596
11597 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11598 {
11599         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11600         ndr->depth++;
11601         ndr_print_ptr(ndr, "str1", r->str1);
11602         ndr->depth++;
11603         if (r->str1) {
11604                 ndr_print_string(ndr, "str1", r->str1);
11605         }
11606         ndr->depth--;
11607         ndr_print_uint32(ndr, "u1", r->u1);
11608         ndr_print_uint32(ndr, "u2", r->u2);
11609         ndr_print_uint32(ndr, "u3", r->u3);
11610         ndr_print_uint32(ndr, "u4", r->u4);
11611         ndr_print_uint32(ndr, "u5", r->u5);
11612         ndr_print_hyper(ndr, "u6", r->u6);
11613         ndr_print_uint32(ndr, "u7", r->u7);
11614         ndr->depth--;
11615 }
11616
11617 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11618 {
11619         uint32_t cntr_array_0;
11620         if (ndr_flags & NDR_SCALARS) {
11621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11622                 NDR_CHECK(ndr_push_align(ndr, 8));
11623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11625                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11626                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11627                 }
11628         }
11629         if (ndr_flags & NDR_BUFFERS) {
11630                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11631                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11632                 }
11633         }
11634         return NDR_ERR_SUCCESS;
11635 }
11636
11637 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11638 {
11639         uint32_t cntr_array_0;
11640         TALLOC_CTX *_mem_save_array_0;
11641         if (ndr_flags & NDR_SCALARS) {
11642                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11643                 NDR_CHECK(ndr_pull_align(ndr, 8));
11644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11645                 if (r->count > 256) {
11646                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11647                 }
11648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11649                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11650                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11651                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11652                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11653                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11654                 }
11655                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11656                 if (r->array) {
11657                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11658                 }
11659         }
11660         if (ndr_flags & NDR_BUFFERS) {
11661                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11662                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11663                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11664                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11665                 }
11666                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11667         }
11668         return NDR_ERR_SUCCESS;
11669 }
11670
11671 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11672 {
11673         uint32_t cntr_array_0;
11674         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11675         ndr->depth++;
11676         ndr_print_uint32(ndr, "count", r->count);
11677         ndr_print_uint32(ndr, "reserved", r->reserved);
11678         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11679         ndr->depth++;
11680         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11681                 char *idx_0=NULL;
11682                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11683                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11684                         free(idx_0);
11685                 }
11686         }
11687         ndr->depth--;
11688         ndr->depth--;
11689 }
11690
11691 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11692 {
11693         if (ndr_flags & NDR_SCALARS) {
11694                 int level = ndr_push_get_switch_value(ndr, r);
11695                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11696                 switch (level) {
11697                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11698                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11699                         break; }
11700
11701                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11702                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11703                         break; }
11704
11705                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11706                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11707                         break; }
11708
11709                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11710                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11711                         break; }
11712
11713                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11714                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11715                         break; }
11716
11717                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11718                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11719                         break; }
11720
11721                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11722                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11723                         break; }
11724
11725                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11726                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11727                         break; }
11728
11729                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11730                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11731                         break; }
11732
11733                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11734                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11735                         break; }
11736
11737                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11738                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11739                         break; }
11740
11741                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11742                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
11743                         break; }
11744
11745                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
11746                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
11747                         break; }
11748
11749                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
11750                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
11751                         break; }
11752
11753                         case DRSUAPI_DS_REPLICA_INFO_06: {
11754                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
11755                         break; }
11756
11757                         default:
11758                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11759                 }
11760         }
11761         if (ndr_flags & NDR_BUFFERS) {
11762                 int level = ndr_push_get_switch_value(ndr, r);
11763                 switch (level) {
11764                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11765                                 if (r->neighbours) {
11766                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11767                                 }
11768                         break;
11769
11770                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11771                                 if (r->cursors) {
11772                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11773                                 }
11774                         break;
11775
11776                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11777                                 if (r->objmetadata) {
11778                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11779                                 }
11780                         break;
11781
11782                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11783                                 if (r->connectfailures) {
11784                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11785                                 }
11786                         break;
11787
11788                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11789                                 if (r->linkfailures) {
11790                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
11791                                 }
11792                         break;
11793
11794                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11795                                 if (r->pendingops) {
11796                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
11797                                 }
11798                         break;
11799
11800                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11801                                 if (r->attrvalmetadata) {
11802                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
11803                                 }
11804                         break;
11805
11806                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11807                                 if (r->cursors2) {
11808                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
11809                                 }
11810                         break;
11811
11812                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11813                                 if (r->cursors3) {
11814                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
11815                                 }
11816                         break;
11817
11818                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11819                                 if (r->objmetadata2) {
11820                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
11821                                 }
11822                         break;
11823
11824                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
11825                                 if (r->attrvalmetadata2) {
11826                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
11827                                 }
11828                         break;
11829
11830                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
11831                                 if (r->neighbours02) {
11832                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
11833                                 }
11834                         break;
11835
11836                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
11837                                 if (r->connections04) {
11838                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
11839                                 }
11840                         break;
11841
11842                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
11843                                 if (r->cursors05) {
11844                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
11845                                 }
11846                         break;
11847
11848                         case DRSUAPI_DS_REPLICA_INFO_06:
11849                                 if (r->i06) {
11850                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
11851                                 }
11852                         break;
11853
11854                         default:
11855                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11856                 }
11857         }
11858         return NDR_ERR_SUCCESS;
11859 }
11860
11861 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
11862 {
11863         int level;
11864         uint32_t _level;
11865         TALLOC_CTX *_mem_save_neighbours_0;
11866         TALLOC_CTX *_mem_save_cursors_0;
11867         TALLOC_CTX *_mem_save_objmetadata_0;
11868         TALLOC_CTX *_mem_save_connectfailures_0;
11869         TALLOC_CTX *_mem_save_linkfailures_0;
11870         TALLOC_CTX *_mem_save_pendingops_0;
11871         TALLOC_CTX *_mem_save_attrvalmetadata_0;
11872         TALLOC_CTX *_mem_save_cursors2_0;
11873         TALLOC_CTX *_mem_save_cursors3_0;
11874         TALLOC_CTX *_mem_save_objmetadata2_0;
11875         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
11876         TALLOC_CTX *_mem_save_neighbours02_0;
11877         TALLOC_CTX *_mem_save_connections04_0;
11878         TALLOC_CTX *_mem_save_cursors05_0;
11879         TALLOC_CTX *_mem_save_i06_0;
11880         level = ndr_pull_get_switch_value(ndr, r);
11881         if (ndr_flags & NDR_SCALARS) {
11882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11883                 if (_level != level) {
11884                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
11885                 }
11886                 switch (level) {
11887                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11888                                 uint32_t _ptr_neighbours;
11889                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
11890                                 if (_ptr_neighbours) {
11891                                         NDR_PULL_ALLOC(ndr, r->neighbours);
11892                                 } else {
11893                                         r->neighbours = NULL;
11894                                 }
11895                         break; }
11896
11897                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11898                                 uint32_t _ptr_cursors;
11899                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
11900                                 if (_ptr_cursors) {
11901                                         NDR_PULL_ALLOC(ndr, r->cursors);
11902                                 } else {
11903                                         r->cursors = NULL;
11904                                 }
11905                         break; }
11906
11907                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11908                                 uint32_t _ptr_objmetadata;
11909                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
11910                                 if (_ptr_objmetadata) {
11911                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
11912                                 } else {
11913                                         r->objmetadata = NULL;
11914                                 }
11915                         break; }
11916
11917                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11918                                 uint32_t _ptr_connectfailures;
11919                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
11920                                 if (_ptr_connectfailures) {
11921                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
11922                                 } else {
11923                                         r->connectfailures = NULL;
11924                                 }
11925                         break; }
11926
11927                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11928                                 uint32_t _ptr_linkfailures;
11929                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
11930                                 if (_ptr_linkfailures) {
11931                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
11932                                 } else {
11933                                         r->linkfailures = NULL;
11934                                 }
11935                         break; }
11936
11937                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11938                                 uint32_t _ptr_pendingops;
11939                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
11940                                 if (_ptr_pendingops) {
11941                                         NDR_PULL_ALLOC(ndr, r->pendingops);
11942                                 } else {
11943                                         r->pendingops = NULL;
11944                                 }
11945                         break; }
11946
11947                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11948                                 uint32_t _ptr_attrvalmetadata;
11949                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
11950                                 if (_ptr_attrvalmetadata) {
11951                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
11952                                 } else {
11953                                         r->attrvalmetadata = NULL;
11954                                 }
11955                         break; }
11956
11957                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11958                                 uint32_t _ptr_cursors2;
11959                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
11960                                 if (_ptr_cursors2) {
11961                                         NDR_PULL_ALLOC(ndr, r->cursors2);
11962                                 } else {
11963                                         r->cursors2 = NULL;
11964                                 }
11965                         break; }
11966
11967                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11968                                 uint32_t _ptr_cursors3;
11969                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
11970                                 if (_ptr_cursors3) {
11971                                         NDR_PULL_ALLOC(ndr, r->cursors3);
11972                                 } else {
11973                                         r->cursors3 = NULL;
11974                                 }
11975                         break; }
11976
11977                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11978                                 uint32_t _ptr_objmetadata2;
11979                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
11980                                 if (_ptr_objmetadata2) {
11981                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
11982                                 } else {
11983                                         r->objmetadata2 = NULL;
11984                                 }
11985                         break; }
11986
11987                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11988                                 uint32_t _ptr_attrvalmetadata2;
11989                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
11990                                 if (_ptr_attrvalmetadata2) {
11991                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
11992                                 } else {
11993                                         r->attrvalmetadata2 = NULL;
11994                                 }
11995                         break; }
11996
11997                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11998                                 uint32_t _ptr_neighbours02;
11999                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12000                                 if (_ptr_neighbours02) {
12001                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
12002                                 } else {
12003                                         r->neighbours02 = NULL;
12004                                 }
12005                         break; }
12006
12007                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12008                                 uint32_t _ptr_connections04;
12009                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12010                                 if (_ptr_connections04) {
12011                                         NDR_PULL_ALLOC(ndr, r->connections04);
12012                                 } else {
12013                                         r->connections04 = NULL;
12014                                 }
12015                         break; }
12016
12017                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12018                                 uint32_t _ptr_cursors05;
12019                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12020                                 if (_ptr_cursors05) {
12021                                         NDR_PULL_ALLOC(ndr, r->cursors05);
12022                                 } else {
12023                                         r->cursors05 = NULL;
12024                                 }
12025                         break; }
12026
12027                         case DRSUAPI_DS_REPLICA_INFO_06: {
12028                                 uint32_t _ptr_i06;
12029                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12030                                 if (_ptr_i06) {
12031                                         NDR_PULL_ALLOC(ndr, r->i06);
12032                                 } else {
12033                                         r->i06 = NULL;
12034                                 }
12035                         break; }
12036
12037                         default:
12038                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12039                 }
12040         }
12041         if (ndr_flags & NDR_BUFFERS) {
12042                 switch (level) {
12043                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12044                                 if (r->neighbours) {
12045                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12046                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12047                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12048                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12049                                 }
12050                         break;
12051
12052                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12053                                 if (r->cursors) {
12054                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12055                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12056                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12057                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12058                                 }
12059                         break;
12060
12061                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12062                                 if (r->objmetadata) {
12063                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12064                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12065                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12066                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12067                                 }
12068                         break;
12069
12070                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12071                                 if (r->connectfailures) {
12072                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12073                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12074                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12075                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12076                                 }
12077                         break;
12078
12079                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12080                                 if (r->linkfailures) {
12081                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12082                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12083                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12084                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12085                                 }
12086                         break;
12087
12088                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12089                                 if (r->pendingops) {
12090                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12091                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12092                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12093                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12094                                 }
12095                         break;
12096
12097                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12098                                 if (r->attrvalmetadata) {
12099                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12100                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12101                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12102                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12103                                 }
12104                         break;
12105
12106                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12107                                 if (r->cursors2) {
12108                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12109                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12110                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12111                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12112                                 }
12113                         break;
12114
12115                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12116                                 if (r->cursors3) {
12117                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12118                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12119                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12120                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12121                                 }
12122                         break;
12123
12124                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12125                                 if (r->objmetadata2) {
12126                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12127                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12128                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12129                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12130                                 }
12131                         break;
12132
12133                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12134                                 if (r->attrvalmetadata2) {
12135                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12136                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12137                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12138                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12139                                 }
12140                         break;
12141
12142                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12143                                 if (r->neighbours02) {
12144                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12145                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12146                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12147                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12148                                 }
12149                         break;
12150
12151                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12152                                 if (r->connections04) {
12153                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12154                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12155                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12156                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12157                                 }
12158                         break;
12159
12160                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12161                                 if (r->cursors05) {
12162                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12163                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12164                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12165                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12166                                 }
12167                         break;
12168
12169                         case DRSUAPI_DS_REPLICA_INFO_06:
12170                                 if (r->i06) {
12171                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12172                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12173                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12174                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12175                                 }
12176                         break;
12177
12178                         default:
12179                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12180                 }
12181         }
12182         return NDR_ERR_SUCCESS;
12183 }
12184
12185 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12186 {
12187         int level;
12188         level = ndr_print_get_switch_value(ndr, r);
12189         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12190         switch (level) {
12191                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12192                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12193                         ndr->depth++;
12194                         if (r->neighbours) {
12195                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12196                         }
12197                         ndr->depth--;
12198                 break;
12199
12200                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12201                         ndr_print_ptr(ndr, "cursors", r->cursors);
12202                         ndr->depth++;
12203                         if (r->cursors) {
12204                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12205                         }
12206                         ndr->depth--;
12207                 break;
12208
12209                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12210                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12211                         ndr->depth++;
12212                         if (r->objmetadata) {
12213                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12214                         }
12215                         ndr->depth--;
12216                 break;
12217
12218                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12219                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12220                         ndr->depth++;
12221                         if (r->connectfailures) {
12222                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12223                         }
12224                         ndr->depth--;
12225                 break;
12226
12227                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12228                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12229                         ndr->depth++;
12230                         if (r->linkfailures) {
12231                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12232                         }
12233                         ndr->depth--;
12234                 break;
12235
12236                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12237                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12238                         ndr->depth++;
12239                         if (r->pendingops) {
12240                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12241                         }
12242                         ndr->depth--;
12243                 break;
12244
12245                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12246                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12247                         ndr->depth++;
12248                         if (r->attrvalmetadata) {
12249                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12250                         }
12251                         ndr->depth--;
12252                 break;
12253
12254                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12255                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12256                         ndr->depth++;
12257                         if (r->cursors2) {
12258                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12259                         }
12260                         ndr->depth--;
12261                 break;
12262
12263                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12264                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12265                         ndr->depth++;
12266                         if (r->cursors3) {
12267                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12268                         }
12269                         ndr->depth--;
12270                 break;
12271
12272                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12273                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12274                         ndr->depth++;
12275                         if (r->objmetadata2) {
12276                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12277                         }
12278                         ndr->depth--;
12279                 break;
12280
12281                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12282                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12283                         ndr->depth++;
12284                         if (r->attrvalmetadata2) {
12285                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12286                         }
12287                         ndr->depth--;
12288                 break;
12289
12290                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12291                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12292                         ndr->depth++;
12293                         if (r->neighbours02) {
12294                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12295                         }
12296                         ndr->depth--;
12297                 break;
12298
12299                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12300                         ndr_print_ptr(ndr, "connections04", r->connections04);
12301                         ndr->depth++;
12302                         if (r->connections04) {
12303                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12304                         }
12305                         ndr->depth--;
12306                 break;
12307
12308                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12309                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12310                         ndr->depth++;
12311                         if (r->cursors05) {
12312                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12313                         }
12314                         ndr->depth--;
12315                 break;
12316
12317                 case DRSUAPI_DS_REPLICA_INFO_06:
12318                         ndr_print_ptr(ndr, "i06", r->i06);
12319                         ndr->depth++;
12320                         if (r->i06) {
12321                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12322                         }
12323                         ndr->depth--;
12324                 break;
12325
12326                 default:
12327                         ndr_print_bad_level(ndr, name, level);
12328         }
12329 }
12330
12331 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12332 {
12333         if (ndr_flags & NDR_SCALARS) {
12334                 int level = ndr_push_get_switch_value(ndr, r);
12335                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12336                 switch (level) {
12337                         case 1: {
12338                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12339                         break; }
12340
12341                         default:
12342                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12343                 }
12344         }
12345         if (ndr_flags & NDR_BUFFERS) {
12346                 int level = ndr_push_get_switch_value(ndr, r);
12347                 switch (level) {
12348                         case 1:
12349                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12350                         break;
12351
12352                         default:
12353                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12354                 }
12355         }
12356         return NDR_ERR_SUCCESS;
12357 }
12358
12359 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12360 {
12361         int level;
12362         int32_t _level;
12363         level = ndr_pull_get_switch_value(ndr, r);
12364         if (ndr_flags & NDR_SCALARS) {
12365                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12366                 if (_level != level) {
12367                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12368                 }
12369                 switch (level) {
12370                         case 1: {
12371                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12372                         break; }
12373
12374                         default:
12375                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12376                 }
12377         }
12378         if (ndr_flags & NDR_BUFFERS) {
12379                 switch (level) {
12380                         case 1:
12381                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12382                         break;
12383
12384                         default:
12385                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12386                 }
12387         }
12388         return NDR_ERR_SUCCESS;
12389 }
12390
12391 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12392 {
12393         int level;
12394         level = ndr_print_get_switch_value(ndr, r);
12395         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12396         switch (level) {
12397                 case 1:
12398                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12399                 break;
12400
12401                 default:
12402                         ndr_print_bad_level(ndr, name, level);
12403         }
12404 }
12405
12406 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12407 {
12408         uint32_t cntr_req_array_1;
12409         if (ndr_flags & NDR_SCALARS) {
12410                 NDR_CHECK(ndr_push_align(ndr, 4));
12411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12413         }
12414         if (ndr_flags & NDR_BUFFERS) {
12415                 if (r->req_array) {
12416                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12417                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12418                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12419                         }
12420                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12421                                 if (r->req_array[cntr_req_array_1]) {
12422                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12423                                 }
12424                         }
12425                 }
12426         }
12427         return NDR_ERR_SUCCESS;
12428 }
12429
12430 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12431 {
12432         uint32_t _ptr_req_array;
12433         uint32_t cntr_req_array_1;
12434         TALLOC_CTX *_mem_save_req_array_0;
12435         TALLOC_CTX *_mem_save_req_array_1;
12436         TALLOC_CTX *_mem_save_req_array_2;
12437         if (ndr_flags & NDR_SCALARS) {
12438                 NDR_CHECK(ndr_pull_align(ndr, 4));
12439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12440                 if (r->num_req < 1 || r->num_req > 10000) {
12441                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12442                 }
12443                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12444                 if (_ptr_req_array) {
12445                         NDR_PULL_ALLOC(ndr, r->req_array);
12446                 } else {
12447                         r->req_array = NULL;
12448                 }
12449         }
12450         if (ndr_flags & NDR_BUFFERS) {
12451                 if (r->req_array) {
12452                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12453                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12454                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12455                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12456                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12457                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12458                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12459                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12460                                 if (_ptr_req_array) {
12461                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12462                                 } else {
12463                                         r->req_array[cntr_req_array_1] = NULL;
12464                                 }
12465                         }
12466                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12467                                 if (r->req_array[cntr_req_array_1]) {
12468                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12469                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12470                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12471                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12472                                 }
12473                         }
12474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12476                 }
12477                 if (r->req_array) {
12478                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12479                 }
12480         }
12481         return NDR_ERR_SUCCESS;
12482 }
12483
12484 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12485 {
12486         uint32_t cntr_req_array_1;
12487         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12488         ndr->depth++;
12489         ndr_print_uint32(ndr, "num_req", r->num_req);
12490         ndr_print_ptr(ndr, "req_array", r->req_array);
12491         ndr->depth++;
12492         if (r->req_array) {
12493                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12494                 ndr->depth++;
12495                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12496                         char *idx_1=NULL;
12497                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12498                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12499                                 ndr->depth++;
12500                                 if (r->req_array[cntr_req_array_1]) {
12501                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12502                                 }
12503                                 ndr->depth--;
12504                                 free(idx_1);
12505                         }
12506                 }
12507                 ndr->depth--;
12508         }
12509         ndr->depth--;
12510         ndr->depth--;
12511 }
12512
12513 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12514 {
12515         if (ndr_flags & NDR_SCALARS) {
12516                 int level = ndr_push_get_switch_value(ndr, r);
12517                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12518                 switch (level) {
12519                         case 1: {
12520                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12521                         break; }
12522
12523                         default:
12524                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12525                 }
12526         }
12527         if (ndr_flags & NDR_BUFFERS) {
12528                 int level = ndr_push_get_switch_value(ndr, r);
12529                 switch (level) {
12530                         case 1:
12531                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12532                         break;
12533
12534                         default:
12535                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12536                 }
12537         }
12538         return NDR_ERR_SUCCESS;
12539 }
12540
12541 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12542 {
12543         int level;
12544         int32_t _level;
12545         level = ndr_pull_get_switch_value(ndr, r);
12546         if (ndr_flags & NDR_SCALARS) {
12547                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12548                 if (_level != level) {
12549                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12550                 }
12551                 switch (level) {
12552                         case 1: {
12553                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12554                         break; }
12555
12556                         default:
12557                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12558                 }
12559         }
12560         if (ndr_flags & NDR_BUFFERS) {
12561                 switch (level) {
12562                         case 1:
12563                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12564                         break;
12565
12566                         default:
12567                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12568                 }
12569         }
12570         return NDR_ERR_SUCCESS;
12571 }
12572
12573 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12574 {
12575         int level;
12576         level = ndr_print_get_switch_value(ndr, r);
12577         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12578         switch (level) {
12579                 case 1:
12580                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12581                 break;
12582
12583                 default:
12584                         ndr_print_bad_level(ndr, name, level);
12585         }
12586 }
12587
12588 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12589 {
12590         if (ndr_flags & NDR_SCALARS) {
12591                 NDR_CHECK(ndr_push_align(ndr, 4));
12592                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12594         }
12595         if (ndr_flags & NDR_BUFFERS) {
12596         }
12597         return NDR_ERR_SUCCESS;
12598 }
12599
12600 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12601 {
12602         if (ndr_flags & NDR_SCALARS) {
12603                 NDR_CHECK(ndr_pull_align(ndr, 4));
12604                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12606         }
12607         if (ndr_flags & NDR_BUFFERS) {
12608         }
12609         return NDR_ERR_SUCCESS;
12610 }
12611
12612 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12613 {
12614         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12615         ndr->depth++;
12616         ndr_print_WERROR(ndr, "error_code", r->error_code);
12617         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12618         ndr->depth--;
12619 }
12620
12621 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12622 {
12623         uint32_t cntr_info_1;
12624         if (ndr_flags & NDR_SCALARS) {
12625                 NDR_CHECK(ndr_push_align(ndr, 4));
12626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12629         }
12630         if (ndr_flags & NDR_BUFFERS) {
12631                 if (r->info) {
12632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12633                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12634                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12635                         }
12636                 }
12637         }
12638         return NDR_ERR_SUCCESS;
12639 }
12640
12641 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12642 {
12643         uint32_t _ptr_info;
12644         uint32_t cntr_info_1;
12645         TALLOC_CTX *_mem_save_info_0;
12646         TALLOC_CTX *_mem_save_info_1;
12647         if (ndr_flags & NDR_SCALARS) {
12648                 NDR_CHECK(ndr_pull_align(ndr, 4));
12649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12650                 if (r->num_info > 10000) {
12651                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12652                 }
12653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12654                 if (_ptr_info) {
12655                         NDR_PULL_ALLOC(ndr, r->info);
12656                 } else {
12657                         r->info = NULL;
12658                 }
12659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12660         }
12661         if (ndr_flags & NDR_BUFFERS) {
12662                 if (r->info) {
12663                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12664                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12665                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12666                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12667                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12668                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12669                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12670                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12671                         }
12672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12674                 }
12675                 if (r->info) {
12676                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12677                 }
12678         }
12679         return NDR_ERR_SUCCESS;
12680 }
12681
12682 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12683 {
12684         uint32_t cntr_info_1;
12685         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12686         ndr->depth++;
12687         ndr_print_uint32(ndr, "num_info", r->num_info);
12688         ndr_print_ptr(ndr, "info", r->info);
12689         ndr->depth++;
12690         if (r->info) {
12691                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12692                 ndr->depth++;
12693                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12694                         char *idx_1=NULL;
12695                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12696                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12697                                 free(idx_1);
12698                         }
12699                 }
12700                 ndr->depth--;
12701         }
12702         ndr->depth--;
12703         ndr_print_uint32(ndr, "unknown", r->unknown);
12704         ndr->depth--;
12705 }
12706
12707 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12708 {
12709         if (ndr_flags & NDR_SCALARS) {
12710                 int level = ndr_push_get_switch_value(ndr, r);
12711                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12712                 switch (level) {
12713                         case 1: {
12714                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12715                         break; }
12716
12717                         default:
12718                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12719                 }
12720         }
12721         if (ndr_flags & NDR_BUFFERS) {
12722                 int level = ndr_push_get_switch_value(ndr, r);
12723                 switch (level) {
12724                         case 1:
12725                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12726                         break;
12727
12728                         default:
12729                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12730                 }
12731         }
12732         return NDR_ERR_SUCCESS;
12733 }
12734
12735 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12736 {
12737         int level;
12738         int32_t _level;
12739         level = ndr_pull_get_switch_value(ndr, r);
12740         if (ndr_flags & NDR_SCALARS) {
12741                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12742                 if (_level != level) {
12743                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12744                 }
12745                 switch (level) {
12746                         case 1: {
12747                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12748                         break; }
12749
12750                         default:
12751                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12752                 }
12753         }
12754         if (ndr_flags & NDR_BUFFERS) {
12755                 switch (level) {
12756                         case 1:
12757                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12758                         break;
12759
12760                         default:
12761                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12762                 }
12763         }
12764         return NDR_ERR_SUCCESS;
12765 }
12766
12767 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
12768 {
12769         int level;
12770         level = ndr_print_get_switch_value(ndr, r);
12771         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
12772         switch (level) {
12773                 case 1:
12774                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
12775                 break;
12776
12777                 default:
12778                         ndr_print_bad_level(ndr, name, level);
12779         }
12780 }
12781
12782 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
12783 {
12784         uint32_t cntr_site_to_1;
12785         if (ndr_flags & NDR_SCALARS) {
12786                 NDR_CHECK(ndr_push_align(ndr, 4));
12787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
12788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
12790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
12791         }
12792         if (ndr_flags & NDR_BUFFERS) {
12793                 if (r->site_from) {
12794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12795                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12796                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12798                 }
12799                 if (r->site_to) {
12800                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12801                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12802                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
12803                         }
12804                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12805                                 if (r->site_to[cntr_site_to_1]) {
12806                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12807                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12808                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12809                                         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));
12810                                 }
12811                         }
12812                 }
12813         }
12814         return NDR_ERR_SUCCESS;
12815 }
12816
12817 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
12818 {
12819         uint32_t _ptr_site_from;
12820         TALLOC_CTX *_mem_save_site_from_0;
12821         uint32_t _ptr_site_to;
12822         uint32_t cntr_site_to_1;
12823         TALLOC_CTX *_mem_save_site_to_0;
12824         TALLOC_CTX *_mem_save_site_to_1;
12825         TALLOC_CTX *_mem_save_site_to_2;
12826         if (ndr_flags & NDR_SCALARS) {
12827                 NDR_CHECK(ndr_pull_align(ndr, 4));
12828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
12829                 if (_ptr_site_from) {
12830                         NDR_PULL_ALLOC(ndr, r->site_from);
12831                 } else {
12832                         r->site_from = NULL;
12833                 }
12834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12835                 if (r->num_req < 1 || r->num_req > 10000) {
12836                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12837                 }
12838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
12839                 if (_ptr_site_to) {
12840                         NDR_PULL_ALLOC(ndr, r->site_to);
12841                 } else {
12842                         r->site_to = NULL;
12843                 }
12844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
12845         }
12846         if (ndr_flags & NDR_BUFFERS) {
12847                 if (r->site_from) {
12848                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
12849                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
12850                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
12851                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
12852                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
12853                                 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));
12854                         }
12855                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
12856                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
12857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
12858                 }
12859                 if (r->site_to) {
12860                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
12861                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
12862                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
12863                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
12864                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
12865                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
12866                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12867                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
12868                                 if (_ptr_site_to) {
12869                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
12870                                 } else {
12871                                         r->site_to[cntr_site_to_1] = NULL;
12872                                 }
12873                         }
12874                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12875                                 if (r->site_to[cntr_site_to_1]) {
12876                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
12877                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
12878                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
12879                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
12880                                         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])) {
12881                                                 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]));
12882                                         }
12883                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
12884                                         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));
12885                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
12886                                 }
12887                         }
12888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
12889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
12890                 }
12891                 if (r->site_to) {
12892                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
12893                 }
12894         }
12895         return NDR_ERR_SUCCESS;
12896 }
12897
12898 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
12899 {
12900         uint32_t cntr_site_to_1;
12901         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
12902         ndr->depth++;
12903         ndr_print_ptr(ndr, "site_from", r->site_from);
12904         ndr->depth++;
12905         if (r->site_from) {
12906                 ndr_print_string(ndr, "site_from", r->site_from);
12907         }
12908         ndr->depth--;
12909         ndr_print_uint32(ndr, "num_req", r->num_req);
12910         ndr_print_ptr(ndr, "site_to", r->site_to);
12911         ndr->depth++;
12912         if (r->site_to) {
12913                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
12914                 ndr->depth++;
12915                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
12916                         char *idx_1=NULL;
12917                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
12918                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
12919                                 ndr->depth++;
12920                                 if (r->site_to[cntr_site_to_1]) {
12921                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
12922                                 }
12923                                 ndr->depth--;
12924                                 free(idx_1);
12925                         }
12926                 }
12927                 ndr->depth--;
12928         }
12929         ndr->depth--;
12930         ndr_print_uint32(ndr, "flags", r->flags);
12931         ndr->depth--;
12932 }
12933
12934 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
12935 {
12936         if (ndr_flags & NDR_SCALARS) {
12937                 int level = ndr_push_get_switch_value(ndr, r);
12938                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12939                 switch (level) {
12940                         case 1: {
12941                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
12942                         break; }
12943
12944                         default:
12945                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12946                 }
12947         }
12948         if (ndr_flags & NDR_BUFFERS) {
12949                 int level = ndr_push_get_switch_value(ndr, r);
12950                 switch (level) {
12951                         case 1:
12952                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
12953                         break;
12954
12955                         default:
12956                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12957                 }
12958         }
12959         return NDR_ERR_SUCCESS;
12960 }
12961
12962 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
12963 {
12964         int level;
12965         int32_t _level;
12966         level = ndr_pull_get_switch_value(ndr, r);
12967         if (ndr_flags & NDR_SCALARS) {
12968                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12969                 if (_level != level) {
12970                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12971                 }
12972                 switch (level) {
12973                         case 1: {
12974                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
12975                         break; }
12976
12977                         default:
12978                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12979                 }
12980         }
12981         if (ndr_flags & NDR_BUFFERS) {
12982                 switch (level) {
12983                         case 1:
12984                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
12985                         break;
12986
12987                         default:
12988                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12989                 }
12990         }
12991         return NDR_ERR_SUCCESS;
12992 }
12993
12994 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
12995 {
12996         int level;
12997         level = ndr_print_get_switch_value(ndr, r);
12998         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
12999         switch (level) {
13000                 case 1:
13001                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13002                 break;
13003
13004                 default:
13005                         ndr_print_bad_level(ndr, name, level);
13006         }
13007 }
13008
13009 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13010 {
13011         if (flags & NDR_IN) {
13012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13013                 if (r->in.bind_guid) {
13014                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13015                 }
13016                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13017                 if (r->in.bind_info) {
13018                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13019                 }
13020         }
13021         if (flags & NDR_OUT) {
13022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13023                 if (r->out.bind_info) {
13024                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13025                 }
13026                 if (r->out.bind_handle == NULL) {
13027                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13028                 }
13029                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13030                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13031         }
13032         return NDR_ERR_SUCCESS;
13033 }
13034
13035 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13036 {
13037         uint32_t _ptr_bind_guid;
13038         uint32_t _ptr_bind_info;
13039         TALLOC_CTX *_mem_save_bind_guid_0;
13040         TALLOC_CTX *_mem_save_bind_info_0;
13041         TALLOC_CTX *_mem_save_bind_handle_0;
13042         if (flags & NDR_IN) {
13043                 ZERO_STRUCT(r->out);
13044
13045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13046                 if (_ptr_bind_guid) {
13047                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13048                 } else {
13049                         r->in.bind_guid = NULL;
13050                 }
13051                 if (r->in.bind_guid) {
13052                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13053                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13054                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13056                 }
13057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13058                 if (_ptr_bind_info) {
13059                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13060                 } else {
13061                         r->in.bind_info = NULL;
13062                 }
13063                 if (r->in.bind_info) {
13064                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13065                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13066                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13068                 }
13069                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13070                 ZERO_STRUCTP(r->out.bind_handle);
13071         }
13072         if (flags & NDR_OUT) {
13073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13074                 if (_ptr_bind_info) {
13075                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13076                 } else {
13077                         r->out.bind_info = NULL;
13078                 }
13079                 if (r->out.bind_info) {
13080                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13081                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13082                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13084                 }
13085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13086                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13087                 }
13088                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13089                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13090                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13092                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13093         }
13094         return NDR_ERR_SUCCESS;
13095 }
13096
13097 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13098 {
13099         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13100         ndr->depth++;
13101         if (flags & NDR_SET_VALUES) {
13102                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13103         }
13104         if (flags & NDR_IN) {
13105                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13106                 ndr->depth++;
13107                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13108                 ndr->depth++;
13109                 if (r->in.bind_guid) {
13110                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13111                 }
13112                 ndr->depth--;
13113                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13114                 ndr->depth++;
13115                 if (r->in.bind_info) {
13116                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13117                 }
13118                 ndr->depth--;
13119                 ndr->depth--;
13120         }
13121         if (flags & NDR_OUT) {
13122                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13123                 ndr->depth++;
13124                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13125                 ndr->depth++;
13126                 if (r->out.bind_info) {
13127                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13128                 }
13129                 ndr->depth--;
13130                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13131                 ndr->depth++;
13132                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13133                 ndr->depth--;
13134                 ndr_print_WERROR(ndr, "result", r->out.result);
13135                 ndr->depth--;
13136         }
13137         ndr->depth--;
13138 }
13139
13140 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13141 {
13142         if (flags & NDR_IN) {
13143                 if (r->in.bind_handle == NULL) {
13144                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13145                 }
13146                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13147         }
13148         if (flags & NDR_OUT) {
13149                 if (r->out.bind_handle == NULL) {
13150                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13151                 }
13152                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13153                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13154         }
13155         return NDR_ERR_SUCCESS;
13156 }
13157
13158 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13159 {
13160         TALLOC_CTX *_mem_save_bind_handle_0;
13161         if (flags & NDR_IN) {
13162                 ZERO_STRUCT(r->out);
13163
13164                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13165                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13166                 }
13167                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13168                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13169                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13170                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13171                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13172                 *r->out.bind_handle = *r->in.bind_handle;
13173         }
13174         if (flags & NDR_OUT) {
13175                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13176                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13177                 }
13178                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13179                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13180                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13181                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13182                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13183         }
13184         return NDR_ERR_SUCCESS;
13185 }
13186
13187 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13188 {
13189         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13190         ndr->depth++;
13191         if (flags & NDR_SET_VALUES) {
13192                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13193         }
13194         if (flags & NDR_IN) {
13195                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13196                 ndr->depth++;
13197                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13198                 ndr->depth++;
13199                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13200                 ndr->depth--;
13201                 ndr->depth--;
13202         }
13203         if (flags & NDR_OUT) {
13204                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13205                 ndr->depth++;
13206                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13207                 ndr->depth++;
13208                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13209                 ndr->depth--;
13210                 ndr_print_WERROR(ndr, "result", r->out.result);
13211                 ndr->depth--;
13212         }
13213         ndr->depth--;
13214 }
13215
13216 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13217 {
13218         if (flags & NDR_IN) {
13219                 if (r->in.bind_handle == NULL) {
13220                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13221                 }
13222                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13223                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13224                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13225                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13226         }
13227         if (flags & NDR_OUT) {
13228                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13229         }
13230         return NDR_ERR_SUCCESS;
13231 }
13232
13233 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13234 {
13235         TALLOC_CTX *_mem_save_bind_handle_0;
13236         if (flags & NDR_IN) {
13237                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13238                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13239                 }
13240                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13241                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13242                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13243                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13244                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13245                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13246                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13247         }
13248         if (flags & NDR_OUT) {
13249                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13250         }
13251         return NDR_ERR_SUCCESS;
13252 }
13253
13254 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13255 {
13256         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13257         ndr->depth++;
13258         if (flags & NDR_SET_VALUES) {
13259                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13260         }
13261         if (flags & NDR_IN) {
13262                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13263                 ndr->depth++;
13264                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13265                 ndr->depth++;
13266                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13267                 ndr->depth--;
13268                 ndr_print_int32(ndr, "level", r->in.level);
13269                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13270                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13271                 ndr->depth--;
13272         }
13273         if (flags & NDR_OUT) {
13274                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13275                 ndr->depth++;
13276                 ndr_print_WERROR(ndr, "result", r->out.result);
13277                 ndr->depth--;
13278         }
13279         ndr->depth--;
13280 }
13281
13282 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13283 {
13284         if (flags & NDR_IN) {
13285                 if (r->in.bind_handle == NULL) {
13286                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13287                 }
13288                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13289                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13290                 if (r->in.req == NULL) {
13291                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13292                 }
13293                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13294                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13295         }
13296         if (flags & NDR_OUT) {
13297                 if (r->out.level_out == NULL) {
13298                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13299                 }
13300                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13301                 if (r->out.ctr == NULL) {
13302                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13303                 }
13304                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13305                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13306                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13307         }
13308         return NDR_ERR_SUCCESS;
13309 }
13310
13311 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13312 {
13313         TALLOC_CTX *_mem_save_bind_handle_0;
13314         TALLOC_CTX *_mem_save_req_0;
13315         TALLOC_CTX *_mem_save_level_out_0;
13316         TALLOC_CTX *_mem_save_ctr_0;
13317         if (flags & NDR_IN) {
13318                 ZERO_STRUCT(r->out);
13319
13320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13321                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13322                 }
13323                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13324                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13325                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13327                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13329                         NDR_PULL_ALLOC(ndr, r->in.req);
13330                 }
13331                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13333                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13334                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13335                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13336                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13337                 ZERO_STRUCTP(r->out.level_out);
13338                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13339                 ZERO_STRUCTP(r->out.ctr);
13340         }
13341         if (flags & NDR_OUT) {
13342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13343                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13344                 }
13345                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13346                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13347                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13349                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13350                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13351                 }
13352                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13353                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13354                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13355                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13356                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13357                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13358         }
13359         return NDR_ERR_SUCCESS;
13360 }
13361
13362 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13363 {
13364         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13365         ndr->depth++;
13366         if (flags & NDR_SET_VALUES) {
13367                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13368         }
13369         if (flags & NDR_IN) {
13370                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13371                 ndr->depth++;
13372                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13373                 ndr->depth++;
13374                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13375                 ndr->depth--;
13376                 ndr_print_int32(ndr, "level", r->in.level);
13377                 ndr_print_ptr(ndr, "req", r->in.req);
13378                 ndr->depth++;
13379                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13380                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13381                 ndr->depth--;
13382                 ndr->depth--;
13383         }
13384         if (flags & NDR_OUT) {
13385                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13386                 ndr->depth++;
13387                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13388                 ndr->depth++;
13389                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13390                 ndr->depth--;
13391                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13392                 ndr->depth++;
13393                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13394                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13395                 ndr->depth--;
13396                 ndr_print_WERROR(ndr, "result", r->out.result);
13397                 ndr->depth--;
13398         }
13399         ndr->depth--;
13400 }
13401
13402 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13403 {
13404         if (flags & NDR_IN) {
13405                 if (r->in.bind_handle == NULL) {
13406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13407                 }
13408                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13409                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13410                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13411                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13412         }
13413         if (flags & NDR_OUT) {
13414                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13415         }
13416         return NDR_ERR_SUCCESS;
13417 }
13418
13419 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13420 {
13421         TALLOC_CTX *_mem_save_bind_handle_0;
13422         if (flags & NDR_IN) {
13423                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13424                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13425                 }
13426                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13427                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13428                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13429                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13430                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13431                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13432                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13433         }
13434         if (flags & NDR_OUT) {
13435                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13436         }
13437         return NDR_ERR_SUCCESS;
13438 }
13439
13440 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13441 {
13442         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13443         ndr->depth++;
13444         if (flags & NDR_SET_VALUES) {
13445                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13446         }
13447         if (flags & NDR_IN) {
13448                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13449                 ndr->depth++;
13450                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13451                 ndr->depth++;
13452                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13453                 ndr->depth--;
13454                 ndr_print_int32(ndr, "level", r->in.level);
13455                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13456                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13457                 ndr->depth--;
13458         }
13459         if (flags & NDR_OUT) {
13460                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13461                 ndr->depth++;
13462                 ndr_print_WERROR(ndr, "result", r->out.result);
13463                 ndr->depth--;
13464         }
13465         ndr->depth--;
13466 }
13467
13468 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13469 {
13470         if (flags & NDR_IN) {
13471                 if (r->in.bind_handle == NULL) {
13472                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13473                 }
13474                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13475                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13476                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13477                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13478         }
13479         if (flags & NDR_OUT) {
13480                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13481         }
13482         return NDR_ERR_SUCCESS;
13483 }
13484
13485 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13486 {
13487         TALLOC_CTX *_mem_save_bind_handle_0;
13488         if (flags & NDR_IN) {
13489                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13490                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13491                 }
13492                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13493                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13494                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13495                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13496                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13497                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13498                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13499         }
13500         if (flags & NDR_OUT) {
13501                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13502         }
13503         return NDR_ERR_SUCCESS;
13504 }
13505
13506 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13507 {
13508         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13509         ndr->depth++;
13510         if (flags & NDR_SET_VALUES) {
13511                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13512         }
13513         if (flags & NDR_IN) {
13514                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13515                 ndr->depth++;
13516                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13517                 ndr->depth++;
13518                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13519                 ndr->depth--;
13520                 ndr_print_int32(ndr, "level", r->in.level);
13521                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13522                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13523                 ndr->depth--;
13524         }
13525         if (flags & NDR_OUT) {
13526                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13527                 ndr->depth++;
13528                 ndr_print_WERROR(ndr, "result", r->out.result);
13529                 ndr->depth--;
13530         }
13531         ndr->depth--;
13532 }
13533
13534 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13535 {
13536         if (flags & NDR_IN) {
13537                 if (r->in.bind_handle == NULL) {
13538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13539                 }
13540                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13541                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13542                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13543                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13544         }
13545         if (flags & NDR_OUT) {
13546                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13547         }
13548         return NDR_ERR_SUCCESS;
13549 }
13550
13551 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13552 {
13553         TALLOC_CTX *_mem_save_bind_handle_0;
13554         if (flags & NDR_IN) {
13555                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13556                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13557                 }
13558                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13559                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13560                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13562                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13563                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13564                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13565         }
13566         if (flags & NDR_OUT) {
13567                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13568         }
13569         return NDR_ERR_SUCCESS;
13570 }
13571
13572 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13573 {
13574         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13575         ndr->depth++;
13576         if (flags & NDR_SET_VALUES) {
13577                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13578         }
13579         if (flags & NDR_IN) {
13580                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13581                 ndr->depth++;
13582                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13583                 ndr->depth++;
13584                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13585                 ndr->depth--;
13586                 ndr_print_int32(ndr, "level", r->in.level);
13587                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13588                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13589                 ndr->depth--;
13590         }
13591         if (flags & NDR_OUT) {
13592                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13593                 ndr->depth++;
13594                 ndr_print_WERROR(ndr, "result", r->out.result);
13595                 ndr->depth--;
13596         }
13597         ndr->depth--;
13598 }
13599
13600 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13601 {
13602         if (flags & NDR_IN) {
13603                 if (r->in.bind_handle == NULL) {
13604                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13605                 }
13606                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13607                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13608                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13609                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13610         }
13611         if (flags & NDR_OUT) {
13612                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13613         }
13614         return NDR_ERR_SUCCESS;
13615 }
13616
13617 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13618 {
13619         TALLOC_CTX *_mem_save_bind_handle_0;
13620         if (flags & NDR_IN) {
13621                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13622                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13623                 }
13624                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13625                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13626                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13627                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13628                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13629                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13630                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13631         }
13632         if (flags & NDR_OUT) {
13633                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13634         }
13635         return NDR_ERR_SUCCESS;
13636 }
13637
13638 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13639 {
13640         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13641         ndr->depth++;
13642         if (flags & NDR_SET_VALUES) {
13643                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13644         }
13645         if (flags & NDR_IN) {
13646                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13647                 ndr->depth++;
13648                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13649                 ndr->depth++;
13650                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13651                 ndr->depth--;
13652                 ndr_print_int32(ndr, "level", r->in.level);
13653                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13654                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13655                 ndr->depth--;
13656         }
13657         if (flags & NDR_OUT) {
13658                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13659                 ndr->depth++;
13660                 ndr_print_WERROR(ndr, "result", r->out.result);
13661                 ndr->depth--;
13662         }
13663         ndr->depth--;
13664 }
13665
13666 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13667 {
13668         if (flags & NDR_IN) {
13669         }
13670         if (flags & NDR_OUT) {
13671                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13672         }
13673         return NDR_ERR_SUCCESS;
13674 }
13675
13676 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13677 {
13678         if (flags & NDR_IN) {
13679         }
13680         if (flags & NDR_OUT) {
13681                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13682         }
13683         return NDR_ERR_SUCCESS;
13684 }
13685
13686 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13687 {
13688         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13689         ndr->depth++;
13690         if (flags & NDR_SET_VALUES) {
13691                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13692         }
13693         if (flags & NDR_IN) {
13694                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13695                 ndr->depth++;
13696                 ndr->depth--;
13697         }
13698         if (flags & NDR_OUT) {
13699                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13700                 ndr->depth++;
13701                 ndr_print_WERROR(ndr, "result", r->out.result);
13702                 ndr->depth--;
13703         }
13704         ndr->depth--;
13705 }
13706
13707 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13708 {
13709         if (flags & NDR_IN) {
13710                 if (r->in.bind_handle == NULL) {
13711                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13712                 }
13713                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13714                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13715                 if (r->in.req == NULL) {
13716                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13717                 }
13718                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13719                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13720         }
13721         if (flags & NDR_OUT) {
13722                 if (r->out.level_out == NULL) {
13723                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13724                 }
13725                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13726                 if (r->out.ctr == NULL) {
13727                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13728                 }
13729                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13730                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13731                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13732         }
13733         return NDR_ERR_SUCCESS;
13734 }
13735
13736 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13737 {
13738         TALLOC_CTX *_mem_save_bind_handle_0;
13739         TALLOC_CTX *_mem_save_req_0;
13740         TALLOC_CTX *_mem_save_level_out_0;
13741         TALLOC_CTX *_mem_save_ctr_0;
13742         if (flags & NDR_IN) {
13743                 ZERO_STRUCT(r->out);
13744
13745                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13746                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13747                 }
13748                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13749                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13750                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13751                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13752                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13753                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13754                         NDR_PULL_ALLOC(ndr, r->in.req);
13755                 }
13756                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13757                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13758                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13759                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13760                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13761                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13762                 ZERO_STRUCTP(r->out.level_out);
13763                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13764                 ZERO_STRUCTP(r->out.ctr);
13765         }
13766         if (flags & NDR_OUT) {
13767                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13768                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13769                 }
13770                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13771                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13772                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13773                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13775                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13776                 }
13777                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13778                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13779                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13780                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13782                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13783         }
13784         return NDR_ERR_SUCCESS;
13785 }
13786
13787 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
13788 {
13789         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
13790         ndr->depth++;
13791         if (flags & NDR_SET_VALUES) {
13792                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13793         }
13794         if (flags & NDR_IN) {
13795                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
13796                 ndr->depth++;
13797                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13798                 ndr->depth++;
13799                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13800                 ndr->depth--;
13801                 ndr_print_int32(ndr, "level", r->in.level);
13802                 ndr_print_ptr(ndr, "req", r->in.req);
13803                 ndr->depth++;
13804                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13805                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
13806                 ndr->depth--;
13807                 ndr->depth--;
13808         }
13809         if (flags & NDR_OUT) {
13810                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
13811                 ndr->depth++;
13812                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13813                 ndr->depth++;
13814                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13815                 ndr->depth--;
13816                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13817                 ndr->depth++;
13818                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13819                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
13820                 ndr->depth--;
13821                 ndr_print_WERROR(ndr, "result", r->out.result);
13822                 ndr->depth--;
13823         }
13824         ndr->depth--;
13825 }
13826
13827 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13828 {
13829         if (flags & NDR_IN) {
13830         }
13831         if (flags & NDR_OUT) {
13832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13833         }
13834         return NDR_ERR_SUCCESS;
13835 }
13836
13837 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13838 {
13839         if (flags & NDR_IN) {
13840         }
13841         if (flags & NDR_OUT) {
13842                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13843         }
13844         return NDR_ERR_SUCCESS;
13845 }
13846
13847 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13848 {
13849         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
13850         ndr->depth++;
13851         if (flags & NDR_SET_VALUES) {
13852                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13853         }
13854         if (flags & NDR_IN) {
13855                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
13856                 ndr->depth++;
13857                 ndr->depth--;
13858         }
13859         if (flags & NDR_OUT) {
13860                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
13861                 ndr->depth++;
13862                 ndr_print_WERROR(ndr, "result", r->out.result);
13863                 ndr->depth--;
13864         }
13865         ndr->depth--;
13866 }
13867
13868 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
13869 {
13870         if (flags & NDR_IN) {
13871                 if (r->in.bind_handle == NULL) {
13872                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13873                 }
13874                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13876                 if (r->in.req == NULL) {
13877                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13878                 }
13879                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13880                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13881         }
13882         if (flags & NDR_OUT) {
13883                 if (r->out.level_out == NULL) {
13884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13885                 }
13886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
13887                 if (r->out.info == NULL) {
13888                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13889                 }
13890                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
13891                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13892                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13893         }
13894         return NDR_ERR_SUCCESS;
13895 }
13896
13897 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
13898 {
13899         TALLOC_CTX *_mem_save_bind_handle_0;
13900         TALLOC_CTX *_mem_save_req_0;
13901         TALLOC_CTX *_mem_save_level_out_0;
13902         TALLOC_CTX *_mem_save_info_0;
13903         if (flags & NDR_IN) {
13904                 ZERO_STRUCT(r->out);
13905
13906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13907                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13908                 }
13909                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13910                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13911                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13915                         NDR_PULL_ALLOC(ndr, r->in.req);
13916                 }
13917                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13918                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13919                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13920                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13921                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13922                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13923                 ZERO_STRUCTP(r->out.level_out);
13924                 NDR_PULL_ALLOC(ndr, r->out.info);
13925                 ZERO_STRUCTP(r->out.info);
13926         }
13927         if (flags & NDR_OUT) {
13928                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13929                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13930                 }
13931                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13932                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
13934                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13935                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13936                         NDR_PULL_ALLOC(ndr, r->out.info);
13937                 }
13938                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13939                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
13940                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
13941                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13942                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
13943                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13944         }
13945         return NDR_ERR_SUCCESS;
13946 }
13947
13948 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
13949 {
13950         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
13951         ndr->depth++;
13952         if (flags & NDR_SET_VALUES) {
13953                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13954         }
13955         if (flags & NDR_IN) {
13956                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
13957                 ndr->depth++;
13958                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13959                 ndr->depth++;
13960                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13961                 ndr->depth--;
13962                 ndr_print_uint32(ndr, "level", r->in.level);
13963                 ndr_print_ptr(ndr, "req", r->in.req);
13964                 ndr->depth++;
13965                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13966                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
13967                 ndr->depth--;
13968                 ndr->depth--;
13969         }
13970         if (flags & NDR_OUT) {
13971                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
13972                 ndr->depth++;
13973                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13974                 ndr->depth++;
13975                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
13976                 ndr->depth--;
13977                 ndr_print_ptr(ndr, "info", r->out.info);
13978                 ndr->depth++;
13979                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
13980                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
13981                 ndr->depth--;
13982                 ndr_print_WERROR(ndr, "result", r->out.result);
13983                 ndr->depth--;
13984         }
13985         ndr->depth--;
13986 }
13987
13988 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
13989 {
13990         if (flags & NDR_IN) {
13991                 if (r->in.bind_handle == NULL) {
13992                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13993                 }
13994                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13995                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13996                 if (r->in.req == NULL) {
13997                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13998                 }
13999                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14000                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14001         }
14002         if (flags & NDR_OUT) {
14003                 if (r->out.level_out == NULL) {
14004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14005                 }
14006                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14007                 if (r->out.ctr == NULL) {
14008                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14009                 }
14010                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14011                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14012                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14013         }
14014         return NDR_ERR_SUCCESS;
14015 }
14016
14017 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14018 {
14019         TALLOC_CTX *_mem_save_bind_handle_0;
14020         TALLOC_CTX *_mem_save_req_0;
14021         TALLOC_CTX *_mem_save_level_out_0;
14022         TALLOC_CTX *_mem_save_ctr_0;
14023         if (flags & NDR_IN) {
14024                 ZERO_STRUCT(r->out);
14025
14026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14027                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14028                 }
14029                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14030                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14031                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14033                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14034                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14035                         NDR_PULL_ALLOC(ndr, r->in.req);
14036                 }
14037                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14038                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14039                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14040                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14041                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14042                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14043                 ZERO_STRUCTP(r->out.level_out);
14044                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14045                 ZERO_STRUCTP(r->out.ctr);
14046         }
14047         if (flags & NDR_OUT) {
14048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14049                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14050                 }
14051                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14052                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14053                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14056                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14057                 }
14058                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14059                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14060                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14061                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14062                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14063                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14064         }
14065         return NDR_ERR_SUCCESS;
14066 }
14067
14068 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14069 {
14070         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14071         ndr->depth++;
14072         if (flags & NDR_SET_VALUES) {
14073                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14074         }
14075         if (flags & NDR_IN) {
14076                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14077                 ndr->depth++;
14078                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14079                 ndr->depth++;
14080                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14081                 ndr->depth--;
14082                 ndr_print_int32(ndr, "level", r->in.level);
14083                 ndr_print_ptr(ndr, "req", r->in.req);
14084                 ndr->depth++;
14085                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14086                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14087                 ndr->depth--;
14088                 ndr->depth--;
14089         }
14090         if (flags & NDR_OUT) {
14091                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14092                 ndr->depth++;
14093                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14094                 ndr->depth++;
14095                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14096                 ndr->depth--;
14097                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14098                 ndr->depth++;
14099                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14100                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14101                 ndr->depth--;
14102                 ndr_print_WERROR(ndr, "result", r->out.result);
14103                 ndr->depth--;
14104         }
14105         ndr->depth--;
14106 }
14107
14108 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14109 {
14110         if (flags & NDR_IN) {
14111                 if (r->in.bind_handle == NULL) {
14112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14113                 }
14114                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14115                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14116                 if (r->in.req == NULL) {
14117                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14118                 }
14119                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14120                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14121         }
14122         if (flags & NDR_OUT) {
14123                 if (r->out.level_out == NULL) {
14124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14125                 }
14126                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14127                 if (r->out.res == NULL) {
14128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14129                 }
14130                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14131                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14132                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14133         }
14134         return NDR_ERR_SUCCESS;
14135 }
14136
14137 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14138 {
14139         TALLOC_CTX *_mem_save_bind_handle_0;
14140         TALLOC_CTX *_mem_save_req_0;
14141         TALLOC_CTX *_mem_save_level_out_0;
14142         TALLOC_CTX *_mem_save_res_0;
14143         if (flags & NDR_IN) {
14144                 ZERO_STRUCT(r->out);
14145
14146                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14147                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14148                 }
14149                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14150                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14151                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14152                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14153                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14155                         NDR_PULL_ALLOC(ndr, r->in.req);
14156                 }
14157                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14158                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14159                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14160                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14161                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14162                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14163                 ZERO_STRUCTP(r->out.level_out);
14164                 NDR_PULL_ALLOC(ndr, r->out.res);
14165                 ZERO_STRUCTP(r->out.res);
14166         }
14167         if (flags & NDR_OUT) {
14168                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14169                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14170                 }
14171                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14172                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14173                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14175                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14176                         NDR_PULL_ALLOC(ndr, r->out.res);
14177                 }
14178                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14179                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14180                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14181                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14183                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14184         }
14185         return NDR_ERR_SUCCESS;
14186 }
14187
14188 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14189 {
14190         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14191         ndr->depth++;
14192         if (flags & NDR_SET_VALUES) {
14193                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14194         }
14195         if (flags & NDR_IN) {
14196                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14197                 ndr->depth++;
14198                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14199                 ndr->depth++;
14200                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14201                 ndr->depth--;
14202                 ndr_print_int32(ndr, "level", r->in.level);
14203                 ndr_print_ptr(ndr, "req", r->in.req);
14204                 ndr->depth++;
14205                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14206                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14207                 ndr->depth--;
14208                 ndr->depth--;
14209         }
14210         if (flags & NDR_OUT) {
14211                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14212                 ndr->depth++;
14213                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14214                 ndr->depth++;
14215                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14216                 ndr->depth--;
14217                 ndr_print_ptr(ndr, "res", r->out.res);
14218                 ndr->depth++;
14219                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14220                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14221                 ndr->depth--;
14222                 ndr_print_WERROR(ndr, "result", r->out.result);
14223                 ndr->depth--;
14224         }
14225         ndr->depth--;
14226 }
14227
14228 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14229 {
14230         if (flags & NDR_IN) {
14231                 if (r->in.bind_handle == NULL) {
14232                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14233                 }
14234                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14235                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14236                 if (r->in.req == NULL) {
14237                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14238                 }
14239                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14240                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14241         }
14242         if (flags & NDR_OUT) {
14243                 if (r->out.level_out == NULL) {
14244                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14245                 }
14246                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14247                 if (r->out.res == NULL) {
14248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14249                 }
14250                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14251                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14252                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14253         }
14254         return NDR_ERR_SUCCESS;
14255 }
14256
14257 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14258 {
14259         TALLOC_CTX *_mem_save_bind_handle_0;
14260         TALLOC_CTX *_mem_save_req_0;
14261         TALLOC_CTX *_mem_save_level_out_0;
14262         TALLOC_CTX *_mem_save_res_0;
14263         if (flags & NDR_IN) {
14264                 ZERO_STRUCT(r->out);
14265
14266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14267                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14268                 }
14269                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14270                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14271                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14273                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14274                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14275                         NDR_PULL_ALLOC(ndr, r->in.req);
14276                 }
14277                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14278                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14279                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14280                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14282                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14283                 ZERO_STRUCTP(r->out.level_out);
14284                 NDR_PULL_ALLOC(ndr, r->out.res);
14285                 ZERO_STRUCTP(r->out.res);
14286         }
14287         if (flags & NDR_OUT) {
14288                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14289                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14290                 }
14291                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14292                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14293                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14295                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14296                         NDR_PULL_ALLOC(ndr, r->out.res);
14297                 }
14298                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14299                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14300                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14301                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14302                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14303                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14304         }
14305         return NDR_ERR_SUCCESS;
14306 }
14307
14308 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14309 {
14310         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14311         ndr->depth++;
14312         if (flags & NDR_SET_VALUES) {
14313                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14314         }
14315         if (flags & NDR_IN) {
14316                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14317                 ndr->depth++;
14318                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14319                 ndr->depth++;
14320                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14321                 ndr->depth--;
14322                 ndr_print_int32(ndr, "level", r->in.level);
14323                 ndr_print_ptr(ndr, "req", r->in.req);
14324                 ndr->depth++;
14325                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14326                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14327                 ndr->depth--;
14328                 ndr->depth--;
14329         }
14330         if (flags & NDR_OUT) {
14331                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14332                 ndr->depth++;
14333                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14334                 ndr->depth++;
14335                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14336                 ndr->depth--;
14337                 ndr_print_ptr(ndr, "res", r->out.res);
14338                 ndr->depth++;
14339                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14340                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14341                 ndr->depth--;
14342                 ndr_print_WERROR(ndr, "result", r->out.result);
14343                 ndr->depth--;
14344         }
14345         ndr->depth--;
14346 }
14347
14348 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14349 {
14350         if (flags & NDR_IN) {
14351         }
14352         if (flags & NDR_OUT) {
14353                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14354         }
14355         return NDR_ERR_SUCCESS;
14356 }
14357
14358 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14359 {
14360         if (flags & NDR_IN) {
14361         }
14362         if (flags & NDR_OUT) {
14363                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14364         }
14365         return NDR_ERR_SUCCESS;
14366 }
14367
14368 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14369 {
14370         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14371         ndr->depth++;
14372         if (flags & NDR_SET_VALUES) {
14373                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14374         }
14375         if (flags & NDR_IN) {
14376                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14377                 ndr->depth++;
14378                 ndr->depth--;
14379         }
14380         if (flags & NDR_OUT) {
14381                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14382                 ndr->depth++;
14383                 ndr_print_WERROR(ndr, "result", r->out.result);
14384                 ndr->depth--;
14385         }
14386         ndr->depth--;
14387 }
14388
14389 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14390 {
14391         if (flags & NDR_IN) {
14392                 if (r->in.bind_handle == NULL) {
14393                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14394                 }
14395                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14396                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14397                 if (r->in.req == NULL) {
14398                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14399                 }
14400                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14401                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14402         }
14403         if (flags & NDR_OUT) {
14404                 if (r->out.level_out == NULL) {
14405                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14406                 }
14407                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14408                 if (r->out.ctr == NULL) {
14409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14410                 }
14411                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14412                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14413                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14414         }
14415         return NDR_ERR_SUCCESS;
14416 }
14417
14418 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14419 {
14420         TALLOC_CTX *_mem_save_bind_handle_0;
14421         TALLOC_CTX *_mem_save_req_0;
14422         TALLOC_CTX *_mem_save_level_out_0;
14423         TALLOC_CTX *_mem_save_ctr_0;
14424         if (flags & NDR_IN) {
14425                 ZERO_STRUCT(r->out);
14426
14427                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14428                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14429                 }
14430                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14431                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14432                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14433                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14434                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14436                         NDR_PULL_ALLOC(ndr, r->in.req);
14437                 }
14438                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14439                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14440                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14441                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14442                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14443                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14444                 ZERO_STRUCTP(r->out.level_out);
14445                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14446                 ZERO_STRUCTP(r->out.ctr);
14447         }
14448         if (flags & NDR_OUT) {
14449                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14450                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14451                 }
14452                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14453                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14454                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14455                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14456                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14457                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14458                 }
14459                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14460                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14461                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14462                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14463                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14464                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14465         }
14466         return NDR_ERR_SUCCESS;
14467 }
14468
14469 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14470 {
14471         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14472         ndr->depth++;
14473         if (flags & NDR_SET_VALUES) {
14474                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14475         }
14476         if (flags & NDR_IN) {
14477                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14478                 ndr->depth++;
14479                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14480                 ndr->depth++;
14481                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14482                 ndr->depth--;
14483                 ndr_print_int32(ndr, "level", r->in.level);
14484                 ndr_print_ptr(ndr, "req", r->in.req);
14485                 ndr->depth++;
14486                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14487                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14488                 ndr->depth--;
14489                 ndr->depth--;
14490         }
14491         if (flags & NDR_OUT) {
14492                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14493                 ndr->depth++;
14494                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14495                 ndr->depth++;
14496                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14497                 ndr->depth--;
14498                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14499                 ndr->depth++;
14500                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14501                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14502                 ndr->depth--;
14503                 ndr_print_WERROR(ndr, "result", r->out.result);
14504                 ndr->depth--;
14505         }
14506         ndr->depth--;
14507 }
14508
14509 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14510 {
14511         if (flags & NDR_IN) {
14512                 if (r->in.bind_handle == NULL) {
14513                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14514                 }
14515                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14516                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14517                 if (r->in.req == NULL) {
14518                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14519                 }
14520                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14521                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14522         }
14523         if (flags & NDR_OUT) {
14524                 if (r->out.level_out == NULL) {
14525                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14526                 }
14527                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14528                 if (r->out.ctr == NULL) {
14529                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14530                 }
14531                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14532                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14534         }
14535         return NDR_ERR_SUCCESS;
14536 }
14537
14538 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14539 {
14540         TALLOC_CTX *_mem_save_bind_handle_0;
14541         TALLOC_CTX *_mem_save_req_0;
14542         TALLOC_CTX *_mem_save_level_out_0;
14543         TALLOC_CTX *_mem_save_ctr_0;
14544         if (flags & NDR_IN) {
14545                 ZERO_STRUCT(r->out);
14546
14547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14548                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14549                 }
14550                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14551                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14552                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14554                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14555                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14556                         NDR_PULL_ALLOC(ndr, r->in.req);
14557                 }
14558                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14559                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14560                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14561                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14562                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14563                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14564                 ZERO_STRUCTP(r->out.level_out);
14565                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14566                 ZERO_STRUCTP(r->out.ctr);
14567         }
14568         if (flags & NDR_OUT) {
14569                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14570                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14571                 }
14572                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14573                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14574                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14575                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14576                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14577                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14578                 }
14579                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14580                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14581                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14582                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14584                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14585         }
14586         return NDR_ERR_SUCCESS;
14587 }
14588
14589 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14590 {
14591         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14592         ndr->depth++;
14593         if (flags & NDR_SET_VALUES) {
14594                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14595         }
14596         if (flags & NDR_IN) {
14597                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14598                 ndr->depth++;
14599                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14600                 ndr->depth++;
14601                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14602                 ndr->depth--;
14603                 ndr_print_int32(ndr, "level", r->in.level);
14604                 ndr_print_ptr(ndr, "req", r->in.req);
14605                 ndr->depth++;
14606                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14607                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14608                 ndr->depth--;
14609                 ndr->depth--;
14610         }
14611         if (flags & NDR_OUT) {
14612                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14613                 ndr->depth++;
14614                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14615                 ndr->depth++;
14616                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14617                 ndr->depth--;
14618                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14619                 ndr->depth++;
14620                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14621                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14622                 ndr->depth--;
14623                 ndr_print_WERROR(ndr, "result", r->out.result);
14624                 ndr->depth--;
14625         }
14626         ndr->depth--;
14627 }
14628
14629 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
14630 {
14631         if (flags & NDR_IN) {
14632                 if (r->in.bind_handle == NULL) {
14633                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14634                 }
14635                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14637                 if (r->in.req == NULL) {
14638                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14639                 }
14640                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14641                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14642         }
14643         if (flags & NDR_OUT) {
14644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14645         }
14646         return NDR_ERR_SUCCESS;
14647 }
14648
14649 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
14650 {
14651         TALLOC_CTX *_mem_save_bind_handle_0;
14652         TALLOC_CTX *_mem_save_req_0;
14653         if (flags & NDR_IN) {
14654                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14655                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14656                 }
14657                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14658                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14659                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14662                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14663                         NDR_PULL_ALLOC(ndr, r->in.req);
14664                 }
14665                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14666                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14667                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14668                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14669                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14670         }
14671         if (flags & NDR_OUT) {
14672                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14673         }
14674         return NDR_ERR_SUCCESS;
14675 }
14676
14677 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
14678 {
14679         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
14680         ndr->depth++;
14681         if (flags & NDR_SET_VALUES) {
14682                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14683         }
14684         if (flags & NDR_IN) {
14685                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
14686                 ndr->depth++;
14687                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14688                 ndr->depth++;
14689                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14690                 ndr->depth--;
14691                 ndr_print_uint32(ndr, "level", r->in.level);
14692                 ndr_print_ptr(ndr, "req", r->in.req);
14693                 ndr->depth++;
14694                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14695                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
14696                 ndr->depth--;
14697                 ndr->depth--;
14698         }
14699         if (flags & NDR_OUT) {
14700                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
14701                 ndr->depth++;
14702                 ndr_print_WERROR(ndr, "result", r->out.result);
14703                 ndr->depth--;
14704         }
14705         ndr->depth--;
14706 }
14707
14708 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14709 {
14710         if (flags & NDR_IN) {
14711                 if (r->in.bind_handle == NULL) {
14712                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14713                 }
14714                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14715                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14716                 if (r->in.req == NULL) {
14717                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14718                 }
14719                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14720                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14721         }
14722         if (flags & NDR_OUT) {
14723                 if (r->out.info_type == NULL) {
14724                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14725                 }
14726                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14727                 if (r->out.info == NULL) {
14728                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14729                 }
14730                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
14731                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14732                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14733         }
14734         return NDR_ERR_SUCCESS;
14735 }
14736
14737 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14738 {
14739         TALLOC_CTX *_mem_save_bind_handle_0;
14740         TALLOC_CTX *_mem_save_req_0;
14741         TALLOC_CTX *_mem_save_info_type_0;
14742         TALLOC_CTX *_mem_save_info_0;
14743         if (flags & NDR_IN) {
14744                 ZERO_STRUCT(r->out);
14745
14746                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14747                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14748                 }
14749                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14750                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14751                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14752                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14753                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
14754                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14755                         NDR_PULL_ALLOC(ndr, r->in.req);
14756                 }
14757                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14758                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14759                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14760                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14761                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14762                 NDR_PULL_ALLOC(ndr, r->out.info_type);
14763                 ZERO_STRUCTP(r->out.info_type);
14764                 NDR_PULL_ALLOC(ndr, r->out.info);
14765                 ZERO_STRUCTP(r->out.info);
14766         }
14767         if (flags & NDR_OUT) {
14768                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14769                         NDR_PULL_ALLOC(ndr, r->out.info_type);
14770                 }
14771                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
14772                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
14773                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
14774                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
14775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14776                         NDR_PULL_ALLOC(ndr, r->out.info);
14777                 }
14778                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14779                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14780                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
14781                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14783                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14784         }
14785         return NDR_ERR_SUCCESS;
14786 }
14787
14788 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14789 {
14790         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
14791         ndr->depth++;
14792         if (flags & NDR_SET_VALUES) {
14793                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14794         }
14795         if (flags & NDR_IN) {
14796                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
14797                 ndr->depth++;
14798                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14799                 ndr->depth++;
14800                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14801                 ndr->depth--;
14802                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
14803                 ndr_print_ptr(ndr, "req", r->in.req);
14804                 ndr->depth++;
14805                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14806                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
14807                 ndr->depth--;
14808                 ndr->depth--;
14809         }
14810         if (flags & NDR_OUT) {
14811                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
14812                 ndr->depth++;
14813                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
14814                 ndr->depth++;
14815                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
14816                 ndr->depth--;
14817                 ndr_print_ptr(ndr, "info", r->out.info);
14818                 ndr->depth++;
14819                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
14820                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
14821                 ndr->depth--;
14822                 ndr_print_WERROR(ndr, "result", r->out.result);
14823                 ndr->depth--;
14824         }
14825         ndr->depth--;
14826 }
14827
14828 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
14829 {
14830         if (flags & NDR_IN) {
14831         }
14832         if (flags & NDR_OUT) {
14833                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14834         }
14835         return NDR_ERR_SUCCESS;
14836 }
14837
14838 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
14839 {
14840         if (flags & NDR_IN) {
14841         }
14842         if (flags & NDR_OUT) {
14843                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14844         }
14845         return NDR_ERR_SUCCESS;
14846 }
14847
14848 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
14849 {
14850         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
14851         ndr->depth++;
14852         if (flags & NDR_SET_VALUES) {
14853                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14854         }
14855         if (flags & NDR_IN) {
14856                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
14857                 ndr->depth++;
14858                 ndr->depth--;
14859         }
14860         if (flags & NDR_OUT) {
14861                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
14862                 ndr->depth++;
14863                 ndr_print_WERROR(ndr, "result", r->out.result);
14864                 ndr->depth--;
14865         }
14866         ndr->depth--;
14867 }
14868
14869 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
14870 {
14871         if (flags & NDR_IN) {
14872                 if (r->in.bind_handle == NULL) {
14873                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14874                 }
14875                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14876                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14877                 if (r->in.req == NULL) {
14878                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14879                 }
14880                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14881                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14882         }
14883         if (flags & NDR_OUT) {
14884                 if (r->out.level_out == NULL) {
14885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14886                 }
14887                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14888                 if (r->out.ctr == NULL) {
14889                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14890                 }
14891                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14892                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14893                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14894         }
14895         return NDR_ERR_SUCCESS;
14896 }
14897
14898 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
14899 {
14900         TALLOC_CTX *_mem_save_bind_handle_0;
14901         TALLOC_CTX *_mem_save_req_0;
14902         TALLOC_CTX *_mem_save_level_out_0;
14903         TALLOC_CTX *_mem_save_ctr_0;
14904         if (flags & NDR_IN) {
14905                 ZERO_STRUCT(r->out);
14906
14907                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14908                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14909                 }
14910                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14911                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14912                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14913                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14914                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14915                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14916                         NDR_PULL_ALLOC(ndr, r->in.req);
14917                 }
14918                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14919                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14920                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14921                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14922                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14923                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14924                 ZERO_STRUCTP(r->out.level_out);
14925                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14926                 ZERO_STRUCTP(r->out.ctr);
14927         }
14928         if (flags & NDR_OUT) {
14929                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14930                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14931                 }
14932                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14933                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14934                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14935                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14936                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14937                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14938                 }
14939                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14940                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14941                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14942                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14944                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14945         }
14946         return NDR_ERR_SUCCESS;
14947 }
14948
14949 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
14950 {
14951         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
14952         ndr->depth++;
14953         if (flags & NDR_SET_VALUES) {
14954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14955         }
14956         if (flags & NDR_IN) {
14957                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
14958                 ndr->depth++;
14959                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14960                 ndr->depth++;
14961                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14962                 ndr->depth--;
14963                 ndr_print_int32(ndr, "level", r->in.level);
14964                 ndr_print_ptr(ndr, "req", r->in.req);
14965                 ndr->depth++;
14966                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14967                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
14968                 ndr->depth--;
14969                 ndr->depth--;
14970         }
14971         if (flags & NDR_OUT) {
14972                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
14973                 ndr->depth++;
14974                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14975                 ndr->depth++;
14976                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14977                 ndr->depth--;
14978                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14979                 ndr->depth++;
14980                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14981                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
14982                 ndr->depth--;
14983                 ndr_print_WERROR(ndr, "result", r->out.result);
14984                 ndr->depth--;
14985         }
14986         ndr->depth--;
14987 }
14988
14989 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14990 {
14991         if (flags & NDR_IN) {
14992         }
14993         if (flags & NDR_OUT) {
14994                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14995         }
14996         return NDR_ERR_SUCCESS;
14997 }
14998
14999 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15000 {
15001         if (flags & NDR_IN) {
15002         }
15003         if (flags & NDR_OUT) {
15004                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15005         }
15006         return NDR_ERR_SUCCESS;
15007 }
15008
15009 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15010 {
15011         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15012         ndr->depth++;
15013         if (flags & NDR_SET_VALUES) {
15014                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15015         }
15016         if (flags & NDR_IN) {
15017                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15018                 ndr->depth++;
15019                 ndr->depth--;
15020         }
15021         if (flags & NDR_OUT) {
15022                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15023                 ndr->depth++;
15024                 ndr_print_WERROR(ndr, "result", r->out.result);
15025                 ndr->depth--;
15026         }
15027         ndr->depth--;
15028 }
15029
15030 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15031 {
15032         if (flags & NDR_IN) {
15033         }
15034         if (flags & NDR_OUT) {
15035                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15036         }
15037         return NDR_ERR_SUCCESS;
15038 }
15039
15040 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15041 {
15042         if (flags & NDR_IN) {
15043         }
15044         if (flags & NDR_OUT) {
15045                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15046         }
15047         return NDR_ERR_SUCCESS;
15048 }
15049
15050 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15051 {
15052         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15053         ndr->depth++;
15054         if (flags & NDR_SET_VALUES) {
15055                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15056         }
15057         if (flags & NDR_IN) {
15058                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15059                 ndr->depth++;
15060                 ndr->depth--;
15061         }
15062         if (flags & NDR_OUT) {
15063                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15064                 ndr->depth++;
15065                 ndr_print_WERROR(ndr, "result", r->out.result);
15066                 ndr->depth--;
15067         }
15068         ndr->depth--;
15069 }
15070
15071 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15072 {
15073         if (flags & NDR_IN) {
15074                 if (r->in.bind_handle == NULL) {
15075                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15076                 }
15077                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15078                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15079                 if (r->in.req == NULL) {
15080                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15081                 }
15082                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15083                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15084         }
15085         if (flags & NDR_OUT) {
15086                 if (r->out.level_out == NULL) {
15087                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15088                 }
15089                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15090                 if (r->out.ctr == NULL) {
15091                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15092                 }
15093                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15094                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15095                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15096         }
15097         return NDR_ERR_SUCCESS;
15098 }
15099
15100 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15101 {
15102         TALLOC_CTX *_mem_save_bind_handle_0;
15103         TALLOC_CTX *_mem_save_req_0;
15104         TALLOC_CTX *_mem_save_level_out_0;
15105         TALLOC_CTX *_mem_save_ctr_0;
15106         if (flags & NDR_IN) {
15107                 ZERO_STRUCT(r->out);
15108
15109                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15110                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15111                 }
15112                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15113                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15114                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15115                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15116                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15117                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15118                         NDR_PULL_ALLOC(ndr, r->in.req);
15119                 }
15120                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15121                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15122                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15123                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15125                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15126                 ZERO_STRUCTP(r->out.level_out);
15127                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15128                 ZERO_STRUCTP(r->out.ctr);
15129         }
15130         if (flags & NDR_OUT) {
15131                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15132                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15133                 }
15134                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15135                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15136                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15137                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15138                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15139                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15140                 }
15141                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15142                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15143                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15144                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15146                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15147         }
15148         return NDR_ERR_SUCCESS;
15149 }
15150
15151 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15152 {
15153         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15154         ndr->depth++;
15155         if (flags & NDR_SET_VALUES) {
15156                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15157         }
15158         if (flags & NDR_IN) {
15159                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15160                 ndr->depth++;
15161                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15162                 ndr->depth++;
15163                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15164                 ndr->depth--;
15165                 ndr_print_int32(ndr, "level", r->in.level);
15166                 ndr_print_ptr(ndr, "req", r->in.req);
15167                 ndr->depth++;
15168                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15169                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15170                 ndr->depth--;
15171                 ndr->depth--;
15172         }
15173         if (flags & NDR_OUT) {
15174                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15175                 ndr->depth++;
15176                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15177                 ndr->depth++;
15178                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15179                 ndr->depth--;
15180                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15181                 ndr->depth++;
15182                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15183                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15184                 ndr->depth--;
15185                 ndr_print_WERROR(ndr, "result", r->out.result);
15186                 ndr->depth--;
15187         }
15188         ndr->depth--;
15189 }
15190
15191 static const struct ndr_interface_call drsuapi_calls[] = {
15192         {
15193                 "drsuapi_DsBind",
15194                 sizeof(struct drsuapi_DsBind),
15195                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15196                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15197                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15198                 false,
15199         },
15200         {
15201                 "drsuapi_DsUnbind",
15202                 sizeof(struct drsuapi_DsUnbind),
15203                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15204                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15205                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15206                 false,
15207         },
15208         {
15209                 "drsuapi_DsReplicaSync",
15210                 sizeof(struct drsuapi_DsReplicaSync),
15211                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15212                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15213                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15214                 false,
15215         },
15216         {
15217                 "drsuapi_DsGetNCChanges",
15218                 sizeof(struct drsuapi_DsGetNCChanges),
15219                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15220                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15221                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15222                 false,
15223         },
15224         {
15225                 "drsuapi_DsReplicaUpdateRefs",
15226                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15227                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15228                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15229                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15230                 false,
15231         },
15232         {
15233                 "drsuapi_DsReplicaAdd",
15234                 sizeof(struct drsuapi_DsReplicaAdd),
15235                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15236                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15237                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15238                 false,
15239         },
15240         {
15241                 "drsuapi_DsReplicaDel",
15242                 sizeof(struct drsuapi_DsReplicaDel),
15243                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15244                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15245                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15246                 false,
15247         },
15248         {
15249                 "drsuapi_DsReplicaMod",
15250                 sizeof(struct drsuapi_DsReplicaMod),
15251                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15252                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15253                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15254                 false,
15255         },
15256         {
15257                 "DRSUAPI_VERIFY_NAMES",
15258                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15259                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15260                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15261                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15262                 false,
15263         },
15264         {
15265                 "drsuapi_DsGetMemberships",
15266                 sizeof(struct drsuapi_DsGetMemberships),
15267                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15268                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15269                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15270                 false,
15271         },
15272         {
15273                 "DRSUAPI_INTER_DOMAIN_MOVE",
15274                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15275                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15276                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15277                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15278                 false,
15279         },
15280         {
15281                 "drsuapi_DsGetNT4ChangeLog",
15282                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15283                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15284                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15285                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15286                 false,
15287         },
15288         {
15289                 "drsuapi_DsCrackNames",
15290                 sizeof(struct drsuapi_DsCrackNames),
15291                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15292                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15293                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15294                 false,
15295         },
15296         {
15297                 "drsuapi_DsWriteAccountSpn",
15298                 sizeof(struct drsuapi_DsWriteAccountSpn),
15299                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15300                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15301                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15302                 false,
15303         },
15304         {
15305                 "drsuapi_DsRemoveDSServer",
15306                 sizeof(struct drsuapi_DsRemoveDSServer),
15307                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15308                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15309                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15310                 false,
15311         },
15312         {
15313                 "DRSUAPI_REMOVE_DS_DOMAIN",
15314                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15315                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15316                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15317                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15318                 false,
15319         },
15320         {
15321                 "drsuapi_DsGetDomainControllerInfo",
15322                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15323                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15324                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15325                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15326                 false,
15327         },
15328         {
15329                 "drsuapi_DsAddEntry",
15330                 sizeof(struct drsuapi_DsAddEntry),
15331                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15332                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15333                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15334                 false,
15335         },
15336         {
15337                 "drsuapi_DsExecuteKCC",
15338                 sizeof(struct drsuapi_DsExecuteKCC),
15339                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15340                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15341                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15342                 false,
15343         },
15344         {
15345                 "drsuapi_DsReplicaGetInfo",
15346                 sizeof(struct drsuapi_DsReplicaGetInfo),
15347                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15348                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15349                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15350                 false,
15351         },
15352         {
15353                 "DRSUAPI_ADD_SID_HISTORY",
15354                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15355                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15356                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15357                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15358                 false,
15359         },
15360         {
15361                 "drsuapi_DsGetMemberships2",
15362                 sizeof(struct drsuapi_DsGetMemberships2),
15363                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15364                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15365                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15366                 false,
15367         },
15368         {
15369                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15370                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15371                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15372                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15373                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15374                 false,
15375         },
15376         {
15377                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15378                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15379                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15380                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15381                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15382                 false,
15383         },
15384         {
15385                 "drsuapi_QuerySitesByCost",
15386                 sizeof(struct drsuapi_QuerySitesByCost),
15387                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15388                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15389                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15390                 false,
15391         },
15392         { NULL, 0, NULL, NULL, NULL, false }
15393 };
15394
15395 static const char * const drsuapi_endpoint_strings[] = {
15396         "ncacn_np:[\\pipe\\lsass]",
15397         "ncacn_np:[\\pipe\\protected_storage]",
15398         "ncacn_ip_tcp:",
15399         "ncalrpc:",
15400 };
15401
15402 static const struct ndr_interface_string_array drsuapi_endpoints = {
15403         .count  = 4,
15404         .names  = drsuapi_endpoint_strings
15405 };
15406
15407 static const char * const drsuapi_authservice_strings[] = {
15408         "ldap",
15409 };
15410
15411 static const struct ndr_interface_string_array drsuapi_authservices = {
15412         .count  = 1,
15413         .names  = drsuapi_authservice_strings
15414 };
15415
15416
15417 const struct ndr_interface_table ndr_table_drsuapi = {
15418         .name           = "drsuapi",
15419         .syntax_id      = {
15420                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15421                 NDR_DRSUAPI_VERSION
15422         },
15423         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15424         .num_calls      = 25,
15425         .calls          = drsuapi_calls,
15426         .endpoints      = &drsuapi_endpoints,
15427         .authservices   = &drsuapi_authservices
15428 };
15429