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_uint3264(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, 5));
 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, 5));
 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_uint3264(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, 5));
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, 5));
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, 5));
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_uint3264(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, 5));
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_uint3264(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_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1552 {
1553         if (ndr_flags & NDR_SCALARS) {
1554                 NDR_CHECK(ndr_push_align(ndr, 8));
1555                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1556                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1557                 if (r->naming_context == NULL) {
1558                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1559                 }
1560                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1561                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1562                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1563                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1566                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1567                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1568                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1569                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1570                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1572         }
1573         if (ndr_flags & NDR_BUFFERS) {
1574                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1575                 if (r->uptodateness_vector) {
1576                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1577                 }
1578                 if (r->partial_attribute_set) {
1579                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1580                 }
1581                 if (r->partial_attribute_set_ex) {
1582                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1583                 }
1584                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1585         }
1586         return NDR_ERR_SUCCESS;
1587 }
1588
1589 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1590 {
1591         uint32_t _ptr_naming_context;
1592         TALLOC_CTX *_mem_save_naming_context_0;
1593         uint32_t _ptr_uptodateness_vector;
1594         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1595         uint32_t _ptr_partial_attribute_set;
1596         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1597         uint32_t _ptr_partial_attribute_set_ex;
1598         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1599         if (ndr_flags & NDR_SCALARS) {
1600                 NDR_CHECK(ndr_pull_align(ndr, 8));
1601                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1602                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1603                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1604                 if (_ptr_naming_context) {
1605                         NDR_PULL_ALLOC(ndr, r->naming_context);
1606                 } else {
1607                         r->naming_context = NULL;
1608                 }
1609                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1610                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1611                 if (_ptr_uptodateness_vector) {
1612                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1613                 } else {
1614                         r->uptodateness_vector = NULL;
1615                 }
1616                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1619                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1620                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1621                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1622                 if (_ptr_partial_attribute_set) {
1623                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1624                 } else {
1625                         r->partial_attribute_set = NULL;
1626                 }
1627                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1628                 if (_ptr_partial_attribute_set_ex) {
1629                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1630                 } else {
1631                         r->partial_attribute_set_ex = NULL;
1632                 }
1633                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1634                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1635         }
1636         if (ndr_flags & NDR_BUFFERS) {
1637                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1638                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1639                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1641                 if (r->uptodateness_vector) {
1642                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1643                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1644                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1646                 }
1647                 if (r->partial_attribute_set) {
1648                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1649                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1650                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1652                 }
1653                 if (r->partial_attribute_set_ex) {
1654                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1655                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1656                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1658                 }
1659                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1660         }
1661         return NDR_ERR_SUCCESS;
1662 }
1663
1664 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1665 {
1666         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1667         ndr->depth++;
1668         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1669         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1670         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1671         ndr->depth++;
1672         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1673         ndr->depth--;
1674         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1675         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1676         ndr->depth++;
1677         if (r->uptodateness_vector) {
1678                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1679         }
1680         ndr->depth--;
1681         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1682         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1683         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1684         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1685         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1686         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1687         ndr->depth++;
1688         if (r->partial_attribute_set) {
1689                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1690         }
1691         ndr->depth--;
1692         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1693         ndr->depth++;
1694         if (r->partial_attribute_set_ex) {
1695                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1696         }
1697         ndr->depth--;
1698         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1699         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1700         ndr->depth--;
1701 }
1702
1703 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1704 {
1705         if (ndr_flags & NDR_SCALARS) {
1706                 int level = ndr_push_get_switch_value(ndr, r);
1707                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1708                 switch (level) {
1709                         case 5: {
1710                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1711                         break; }
1712
1713                         case 8: {
1714                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1715                         break; }
1716
1717                         case 10: {
1718                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1719                         break; }
1720
1721                         default:
1722                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1723                 }
1724         }
1725         if (ndr_flags & NDR_BUFFERS) {
1726                 int level = ndr_push_get_switch_value(ndr, r);
1727                 switch (level) {
1728                         case 5:
1729                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1730                         break;
1731
1732                         case 8:
1733                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1734                         break;
1735
1736                         case 10:
1737                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1738                         break;
1739
1740                         default:
1741                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1742                 }
1743         }
1744         return NDR_ERR_SUCCESS;
1745 }
1746
1747 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1748 {
1749         int level;
1750         int32_t _level;
1751         level = ndr_pull_get_switch_value(ndr, r);
1752         if (ndr_flags & NDR_SCALARS) {
1753                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1754                 if (_level != level) {
1755                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1756                 }
1757                 switch (level) {
1758                         case 5: {
1759                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1760                         break; }
1761
1762                         case 8: {
1763                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1764                         break; }
1765
1766                         case 10: {
1767                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1768                         break; }
1769
1770                         default:
1771                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1772                 }
1773         }
1774         if (ndr_flags & NDR_BUFFERS) {
1775                 switch (level) {
1776                         case 5:
1777                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1778                         break;
1779
1780                         case 8:
1781                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1782                         break;
1783
1784                         case 10:
1785                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1786                         break;
1787
1788                         default:
1789                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1790                 }
1791         }
1792         return NDR_ERR_SUCCESS;
1793 }
1794
1795 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1796 {
1797         int level;
1798         level = ndr_print_get_switch_value(ndr, r);
1799         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1800         switch (level) {
1801                 case 5:
1802                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1803                 break;
1804
1805                 case 8:
1806                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1807                 break;
1808
1809                 case 10:
1810                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1811                 break;
1812
1813                 default:
1814                         ndr_print_bad_level(ndr, name, level);
1815         }
1816 }
1817
1818 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1819 {
1820         if (ndr_flags & NDR_SCALARS) {
1821                 NDR_CHECK(ndr_push_align(ndr, 8));
1822                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1823                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1824                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1825         }
1826         if (ndr_flags & NDR_BUFFERS) {
1827         }
1828         return NDR_ERR_SUCCESS;
1829 }
1830
1831 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1832 {
1833         if (ndr_flags & NDR_SCALARS) {
1834                 NDR_CHECK(ndr_pull_align(ndr, 8));
1835                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1836                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1837                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1838         }
1839         if (ndr_flags & NDR_BUFFERS) {
1840         }
1841         return NDR_ERR_SUCCESS;
1842 }
1843
1844 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1845 {
1846         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1847         ndr->depth++;
1848         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1849         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1850         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1851         ndr->depth--;
1852 }
1853
1854 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1855 {
1856         uint32_t cntr_cursors_0;
1857         if (ndr_flags & NDR_SCALARS) {
1858                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1859                 NDR_CHECK(ndr_push_align(ndr, 8));
1860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1864                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1865                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1866                 }
1867         }
1868         if (ndr_flags & NDR_BUFFERS) {
1869         }
1870         return NDR_ERR_SUCCESS;
1871 }
1872
1873 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1874 {
1875         uint32_t cntr_cursors_0;
1876         TALLOC_CTX *_mem_save_cursors_0;
1877         if (ndr_flags & NDR_SCALARS) {
1878                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1879                 NDR_CHECK(ndr_pull_align(ndr, 8));
1880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1883                 if (r->count > 0x100000) {
1884                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1885                 }
1886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1887                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1888                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1889                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1890                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1891                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1892                 }
1893                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
1894                 if (r->cursors) {
1895                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
1896                 }
1897         }
1898         if (ndr_flags & NDR_BUFFERS) {
1899         }
1900         return NDR_ERR_SUCCESS;
1901 }
1902
1903 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1904 {
1905         uint32_t cntr_cursors_0;
1906         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
1907         ndr->depth++;
1908         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
1909         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1910         ndr_print_uint32(ndr, "count", r->count);
1911         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
1912         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
1913         ndr->depth++;
1914         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
1915                 char *idx_0=NULL;
1916                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
1917                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
1918                         free(idx_0);
1919                 }
1920         }
1921         ndr->depth--;
1922         ndr->depth--;
1923 }
1924
1925 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
1926 {
1927         if (ndr_flags & NDR_SCALARS) {
1928                 NDR_CHECK(ndr_push_align(ndr, 5));
1929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
1930                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
1931         }
1932         if (ndr_flags & NDR_BUFFERS) {
1933                 if (r->blob) {
1934                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
1935                 }
1936         }
1937         return NDR_ERR_SUCCESS;
1938 }
1939
1940 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
1941 {
1942         uint32_t _ptr_blob;
1943         TALLOC_CTX *_mem_save_blob_0;
1944         if (ndr_flags & NDR_SCALARS) {
1945                 NDR_CHECK(ndr_pull_align(ndr, 5));
1946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1947                 if (r->__ndr_size > 10485760) {
1948                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1949                 }
1950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
1951                 if (_ptr_blob) {
1952                         NDR_PULL_ALLOC(ndr, r->blob);
1953                 } else {
1954                         r->blob = NULL;
1955                 }
1956         }
1957         if (ndr_flags & NDR_BUFFERS) {
1958                 if (r->blob) {
1959                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
1960                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
1961                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
1962                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
1963                 }
1964         }
1965         return NDR_ERR_SUCCESS;
1966 }
1967
1968 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
1969 {
1970         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
1971         ndr->depth++;
1972         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
1973         ndr_print_ptr(ndr, "blob", r->blob);
1974         ndr->depth++;
1975         if (r->blob) {
1976                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
1977         }
1978         ndr->depth--;
1979         ndr->depth--;
1980 }
1981
1982 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
1983 {
1984         uint32_t cntr_values_1;
1985         if (ndr_flags & NDR_SCALARS) {
1986                 NDR_CHECK(ndr_push_align(ndr, 5));
1987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
1988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
1989         }
1990         if (ndr_flags & NDR_BUFFERS) {
1991                 if (r->values) {
1992                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
1993                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1994                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
1995                         }
1996                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1997                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
1998                         }
1999                 }
2000         }
2001         return NDR_ERR_SUCCESS;
2002 }
2003
2004 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2005 {
2006         uint32_t _ptr_values;
2007         uint32_t cntr_values_1;
2008         TALLOC_CTX *_mem_save_values_0;
2009         TALLOC_CTX *_mem_save_values_1;
2010         if (ndr_flags & NDR_SCALARS) {
2011                 NDR_CHECK(ndr_pull_align(ndr, 5));
2012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2013                 if (r->num_values > 10485760) {
2014                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2015                 }
2016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2017                 if (_ptr_values) {
2018                         NDR_PULL_ALLOC(ndr, r->values);
2019                 } else {
2020                         r->values = NULL;
2021                 }
2022         }
2023         if (ndr_flags & NDR_BUFFERS) {
2024                 if (r->values) {
2025                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2026                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2027                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2028                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2029                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2030                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2031                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2032                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2033                         }
2034                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2035                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2036                         }
2037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2039                 }
2040                 if (r->values) {
2041                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2042                 }
2043         }
2044         return NDR_ERR_SUCCESS;
2045 }
2046
2047 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2048 {
2049         uint32_t cntr_values_1;
2050         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2051         ndr->depth++;
2052         ndr_print_uint32(ndr, "num_values", r->num_values);
2053         ndr_print_ptr(ndr, "values", r->values);
2054         ndr->depth++;
2055         if (r->values) {
2056                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2057                 ndr->depth++;
2058                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2059                         char *idx_1=NULL;
2060                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2061                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2062                                 free(idx_1);
2063                         }
2064                 }
2065                 ndr->depth--;
2066         }
2067         ndr->depth--;
2068         ndr->depth--;
2069 }
2070
2071 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2072 {
2073         if (ndr_flags & NDR_SCALARS) {
2074                 NDR_CHECK(ndr_push_align(ndr, 4));
2075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2077                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2078                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2080                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2081         }
2082         if (ndr_flags & NDR_BUFFERS) {
2083                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2084         }
2085         return NDR_ERR_SUCCESS;
2086 }
2087
2088 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2089 {
2090         if (ndr_flags & NDR_SCALARS) {
2091                 NDR_CHECK(ndr_pull_align(ndr, 4));
2092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2094                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2095                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2097                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2098         }
2099         if (ndr_flags & NDR_BUFFERS) {
2100                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2101         }
2102         return NDR_ERR_SUCCESS;
2103 }
2104
2105 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2106 {
2107         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2108         ndr->depth++;
2109         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);
2110         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);
2111         ndr_print_GUID(ndr, "guid", &r->guid);
2112         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2113         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2114         ndr_print_string(ndr, "dn", r->dn);
2115         ndr->depth--;
2116 }
2117
2118 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2119 {
2120         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2121 }
2122
2123 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2124 {
2125         if (ndr_flags & NDR_SCALARS) {
2126                 NDR_CHECK(ndr_push_align(ndr, 4));
2127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(r, ndr->iconv_convenience, ndr->flags)));
2128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2129                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2130                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2132                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2134                 {
2135                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2137                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2138                         ndr->flags = _flags_save_DATA_BLOB;
2139                 }
2140         }
2141         if (ndr_flags & NDR_BUFFERS) {
2142                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2143         }
2144         return NDR_ERR_SUCCESS;
2145 }
2146
2147 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2148 {
2149         if (ndr_flags & NDR_SCALARS) {
2150                 NDR_CHECK(ndr_pull_align(ndr, 4));
2151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2153                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2154                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2156                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2158                 {
2159                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2161                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2162                         ndr->flags = _flags_save_DATA_BLOB;
2163                 }
2164         }
2165         if (ndr_flags & NDR_BUFFERS) {
2166                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2167         }
2168         return NDR_ERR_SUCCESS;
2169 }
2170
2171 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2172 {
2173         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2174         ndr->depth++;
2175         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);
2176         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);
2177         ndr_print_GUID(ndr, "guid", &r->guid);
2178         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2179         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2180         ndr_print_string(ndr, "dn", r->dn);
2181         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2182         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2183         ndr->depth--;
2184 }
2185
2186 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, struct smb_iconv_convenience *ic, int flags)
2187 {
2188         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary, ic);
2189 }
2190
2191 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2192 {
2193         if (ndr_flags & NDR_SCALARS) {
2194                 NDR_CHECK(ndr_push_align(ndr, 5));
2195                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2196                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2197         }
2198         if (ndr_flags & NDR_BUFFERS) {
2199                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2200         }
2201         return NDR_ERR_SUCCESS;
2202 }
2203
2204 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2205 {
2206         if (ndr_flags & NDR_SCALARS) {
2207                 NDR_CHECK(ndr_pull_align(ndr, 5));
2208                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2209                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2210         }
2211         if (ndr_flags & NDR_BUFFERS) {
2212                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2213         }
2214         return NDR_ERR_SUCCESS;
2215 }
2216
2217 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2218 {
2219         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2220         ndr->depth++;
2221         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2222         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2223         ndr->depth--;
2224 }
2225
2226 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2227 {
2228         uint32_t cntr_attributes_1;
2229         if (ndr_flags & NDR_SCALARS) {
2230                 NDR_CHECK(ndr_push_align(ndr, 5));
2231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2232                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2233         }
2234         if (ndr_flags & NDR_BUFFERS) {
2235                 if (r->attributes) {
2236                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2237                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2238                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2239                         }
2240                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2241                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2242                         }
2243                 }
2244         }
2245         return NDR_ERR_SUCCESS;
2246 }
2247
2248 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2249 {
2250         uint32_t _ptr_attributes;
2251         uint32_t cntr_attributes_1;
2252         TALLOC_CTX *_mem_save_attributes_0;
2253         TALLOC_CTX *_mem_save_attributes_1;
2254         if (ndr_flags & NDR_SCALARS) {
2255                 NDR_CHECK(ndr_pull_align(ndr, 5));
2256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2257                 if (r->num_attributes > 1048576) {
2258                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2259                 }
2260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2261                 if (_ptr_attributes) {
2262                         NDR_PULL_ALLOC(ndr, r->attributes);
2263                 } else {
2264                         r->attributes = NULL;
2265                 }
2266         }
2267         if (ndr_flags & NDR_BUFFERS) {
2268                 if (r->attributes) {
2269                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2270                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2271                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2272                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2273                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2274                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2275                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2276                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2277                         }
2278                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2279                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2280                         }
2281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2283                 }
2284                 if (r->attributes) {
2285                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2286                 }
2287         }
2288         return NDR_ERR_SUCCESS;
2289 }
2290
2291 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2292 {
2293         uint32_t cntr_attributes_1;
2294         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2295         ndr->depth++;
2296         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2297         ndr_print_ptr(ndr, "attributes", r->attributes);
2298         ndr->depth++;
2299         if (r->attributes) {
2300                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2301                 ndr->depth++;
2302                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2303                         char *idx_1=NULL;
2304                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2305                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2306                                 free(idx_1);
2307                         }
2308                 }
2309                 ndr->depth--;
2310         }
2311         ndr->depth--;
2312         ndr->depth--;
2313 }
2314
2315 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2316 {
2317         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2318         return NDR_ERR_SUCCESS;
2319 }
2320
2321 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2322 {
2323         uint32_t v;
2324         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2325         *r = v;
2326         return NDR_ERR_SUCCESS;
2327 }
2328
2329 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2330 {
2331         ndr_print_uint32(ndr, name, r);
2332         ndr->depth++;
2333         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2334         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2335         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2336         ndr->depth--;
2337 }
2338
2339 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2340 {
2341         if (ndr_flags & NDR_SCALARS) {
2342                 NDR_CHECK(ndr_push_align(ndr, 5));
2343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2344                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2345                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2346         }
2347         if (ndr_flags & NDR_BUFFERS) {
2348                 if (r->identifier) {
2349                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2350                 }
2351                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2352         }
2353         return NDR_ERR_SUCCESS;
2354 }
2355
2356 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2357 {
2358         uint32_t _ptr_identifier;
2359         TALLOC_CTX *_mem_save_identifier_0;
2360         if (ndr_flags & NDR_SCALARS) {
2361                 NDR_CHECK(ndr_pull_align(ndr, 5));
2362                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2363                 if (_ptr_identifier) {
2364                         NDR_PULL_ALLOC(ndr, r->identifier);
2365                 } else {
2366                         r->identifier = NULL;
2367                 }
2368                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2369                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2370         }
2371         if (ndr_flags & NDR_BUFFERS) {
2372                 if (r->identifier) {
2373                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2374                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2375                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2376                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2377                 }
2378                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2379         }
2380         return NDR_ERR_SUCCESS;
2381 }
2382
2383 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2384 {
2385         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2386         ndr->depth++;
2387         ndr_print_ptr(ndr, "identifier", r->identifier);
2388         ndr->depth++;
2389         if (r->identifier) {
2390                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2391         }
2392         ndr->depth--;
2393         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2394         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2395         ndr->depth--;
2396 }
2397
2398 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2399 {
2400         if (ndr_flags & NDR_SCALARS) {
2401                 NDR_CHECK(ndr_push_align(ndr, 8));
2402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2403                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2404                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2405                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2406         }
2407         if (ndr_flags & NDR_BUFFERS) {
2408         }
2409         return NDR_ERR_SUCCESS;
2410 }
2411
2412 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2413 {
2414         if (ndr_flags & NDR_SCALARS) {
2415                 NDR_CHECK(ndr_pull_align(ndr, 8));
2416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2417                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2418                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2419                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2420         }
2421         if (ndr_flags & NDR_BUFFERS) {
2422         }
2423         return NDR_ERR_SUCCESS;
2424 }
2425
2426 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2427 {
2428         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2429         ndr->depth++;
2430         ndr_print_uint32(ndr, "version", r->version);
2431         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2432         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2433         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2434         ndr->depth--;
2435 }
2436
2437 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2438 {
2439         uint32_t cntr_meta_data_0;
2440         if (ndr_flags & NDR_SCALARS) {
2441                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2442                 NDR_CHECK(ndr_push_align(ndr, 8));
2443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2444                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2445                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2446                 }
2447         }
2448         if (ndr_flags & NDR_BUFFERS) {
2449         }
2450         return NDR_ERR_SUCCESS;
2451 }
2452
2453 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2454 {
2455         uint32_t cntr_meta_data_0;
2456         TALLOC_CTX *_mem_save_meta_data_0;
2457         if (ndr_flags & NDR_SCALARS) {
2458                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2459                 NDR_CHECK(ndr_pull_align(ndr, 8));
2460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2461                 if (r->count > 1048576) {
2462                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2463                 }
2464                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2465                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2466                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2467                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2468                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2469                 }
2470                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2471                 if (r->meta_data) {
2472                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2473                 }
2474         }
2475         if (ndr_flags & NDR_BUFFERS) {
2476         }
2477         return NDR_ERR_SUCCESS;
2478 }
2479
2480 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2481 {
2482         uint32_t cntr_meta_data_0;
2483         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2484         ndr->depth++;
2485         ndr_print_uint32(ndr, "count", r->count);
2486         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2487         ndr->depth++;
2488         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2489                 char *idx_0=NULL;
2490                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2491                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2492                         free(idx_0);
2493                 }
2494         }
2495         ndr->depth--;
2496         ndr->depth--;
2497 }
2498
2499 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2500 {
2501         if (ndr_flags & NDR_SCALARS) {
2502                 NDR_CHECK(ndr_push_align(ndr, 5));
2503                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2504                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2506                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2508         }
2509         if (ndr_flags & NDR_BUFFERS) {
2510                 if (r->next_object) {
2511                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2512                 }
2513                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2514                 if (r->parent_object_guid) {
2515                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2516                 }
2517                 if (r->meta_data_ctr) {
2518                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2519                 }
2520         }
2521         return NDR_ERR_SUCCESS;
2522 }
2523
2524 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2525 {
2526         uint32_t _ptr_next_object;
2527         TALLOC_CTX *_mem_save_next_object_0;
2528         uint32_t _ptr_parent_object_guid;
2529         TALLOC_CTX *_mem_save_parent_object_guid_0;
2530         uint32_t _ptr_meta_data_ctr;
2531         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2532         if (ndr_flags & NDR_SCALARS) {
2533                 NDR_CHECK(ndr_pull_align(ndr, 5));
2534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2535                 if (_ptr_next_object) {
2536                         NDR_PULL_ALLOC(ndr, r->next_object);
2537                 } else {
2538                         r->next_object = NULL;
2539                 }
2540                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2542                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2543                 if (_ptr_parent_object_guid) {
2544                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2545                 } else {
2546                         r->parent_object_guid = NULL;
2547                 }
2548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2549                 if (_ptr_meta_data_ctr) {
2550                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2551                 } else {
2552                         r->meta_data_ctr = NULL;
2553                 }
2554         }
2555         if (ndr_flags & NDR_BUFFERS) {
2556                 if (r->next_object) {
2557                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2558                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2559                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2560                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2561                 }
2562                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2563                 if (r->parent_object_guid) {
2564                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2565                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2566                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2567                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2568                 }
2569                 if (r->meta_data_ctr) {
2570                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2571                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2572                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2573                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2574                 }
2575         }
2576         return NDR_ERR_SUCCESS;
2577 }
2578
2579 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2580 {
2581         if (ndr_flags & NDR_SCALARS) {
2582                 NDR_CHECK(ndr_push_align(ndr, 8));
2583                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2584                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2585                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2586                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2587                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2588                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2589                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2590                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2595         }
2596         if (ndr_flags & NDR_BUFFERS) {
2597                 if (r->naming_context) {
2598                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2599                 }
2600                 if (r->uptodateness_vector) {
2601                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2602                 }
2603                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2604                 if (r->first_object) {
2605                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2606                 }
2607         }
2608         return NDR_ERR_SUCCESS;
2609 }
2610
2611 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2612 {
2613         uint32_t _ptr_naming_context;
2614         TALLOC_CTX *_mem_save_naming_context_0;
2615         uint32_t _ptr_uptodateness_vector;
2616         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2617         uint32_t _ptr_first_object;
2618         TALLOC_CTX *_mem_save_first_object_0;
2619         if (ndr_flags & NDR_SCALARS) {
2620                 NDR_CHECK(ndr_pull_align(ndr, 8));
2621                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2622                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2624                 if (_ptr_naming_context) {
2625                         NDR_PULL_ALLOC(ndr, r->naming_context);
2626                 } else {
2627                         r->naming_context = NULL;
2628                 }
2629                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2630                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2631                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2632                 if (_ptr_uptodateness_vector) {
2633                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2634                 } else {
2635                         r->uptodateness_vector = NULL;
2636                 }
2637                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2638                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2640                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2642                 if (_ptr_first_object) {
2643                         NDR_PULL_ALLOC(ndr, r->first_object);
2644                 } else {
2645                         r->first_object = NULL;
2646                 }
2647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2648         }
2649         if (ndr_flags & NDR_BUFFERS) {
2650                 if (r->naming_context) {
2651                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2652                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2653                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2655                 }
2656                 if (r->uptodateness_vector) {
2657                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2658                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2659                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2661                 }
2662                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2663                 if (r->first_object) {
2664                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2665                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2666                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2667                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2668                 }
2669         }
2670         return NDR_ERR_SUCCESS;
2671 }
2672
2673 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2674 {
2675         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2676         ndr->depth++;
2677         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2678         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2679         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2680         ndr->depth++;
2681         if (r->naming_context) {
2682                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2683         }
2684         ndr->depth--;
2685         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2686         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2687         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2688         ndr->depth++;
2689         if (r->uptodateness_vector) {
2690                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2691         }
2692         ndr->depth--;
2693         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2694         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2695         ndr_print_uint32(ndr, "object_count", r->object_count);
2696         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);
2697         ndr_print_ptr(ndr, "first_object", r->first_object);
2698         ndr->depth++;
2699         if (r->first_object) {
2700                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2701         }
2702         ndr->depth--;
2703         ndr_print_uint32(ndr, "more_data", r->more_data);
2704         ndr->depth--;
2705 }
2706
2707 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2708 {
2709         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2710 }
2711
2712 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2713 {
2714         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2715         return NDR_ERR_SUCCESS;
2716 }
2717
2718 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2719 {
2720         uint32_t v;
2721         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2722         *r = v;
2723         return NDR_ERR_SUCCESS;
2724 }
2725
2726 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2727 {
2728         ndr_print_uint32(ndr, name, r);
2729         ndr->depth++;
2730         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2731         ndr->depth--;
2732 }
2733
2734 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2735 {
2736         if (ndr_flags & NDR_SCALARS) {
2737                 NDR_CHECK(ndr_push_align(ndr, 8));
2738                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2739                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2740                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2741                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2742                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2743                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2744         }
2745         if (ndr_flags & NDR_BUFFERS) {
2746                 if (r->identifier) {
2747                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2748                 }
2749                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2750         }
2751         return NDR_ERR_SUCCESS;
2752 }
2753
2754 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2755 {
2756         uint32_t _ptr_identifier;
2757         TALLOC_CTX *_mem_save_identifier_0;
2758         if (ndr_flags & NDR_SCALARS) {
2759                 NDR_CHECK(ndr_pull_align(ndr, 8));
2760                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2761                 if (_ptr_identifier) {
2762                         NDR_PULL_ALLOC(ndr, r->identifier);
2763                 } else {
2764                         r->identifier = NULL;
2765                 }
2766                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2767                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2768                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2769                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2770                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2771         }
2772         if (ndr_flags & NDR_BUFFERS) {
2773                 if (r->identifier) {
2774                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2775                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2776                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2777                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2778                 }
2779                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2780         }
2781         return NDR_ERR_SUCCESS;
2782 }
2783
2784 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2785 {
2786         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2787         ndr->depth++;
2788         ndr_print_ptr(ndr, "identifier", r->identifier);
2789         ndr->depth++;
2790         if (r->identifier) {
2791                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2792         }
2793         ndr->depth--;
2794         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2795         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2796         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2797         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2798         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2799         ndr->depth--;
2800 }
2801
2802 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2803 {
2804         uint32_t cntr_linked_attributes_1;
2805         if (ndr_flags & NDR_SCALARS) {
2806                 NDR_CHECK(ndr_push_align(ndr, 8));
2807                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2808                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2809                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2810                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2811                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2812                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2813                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2814                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2817                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2823                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2824         }
2825         if (ndr_flags & NDR_BUFFERS) {
2826                 if (r->naming_context) {
2827                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2828                 }
2829                 if (r->uptodateness_vector) {
2830                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2831                 }
2832                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2833                 if (r->first_object) {
2834                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2835                 }
2836                 if (r->linked_attributes) {
2837                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2838                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2839                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2840                         }
2841                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2842                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2843                         }
2844                 }
2845         }
2846         return NDR_ERR_SUCCESS;
2847 }
2848
2849 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2850 {
2851         uint32_t _ptr_naming_context;
2852         TALLOC_CTX *_mem_save_naming_context_0;
2853         uint32_t _ptr_uptodateness_vector;
2854         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2855         uint32_t _ptr_first_object;
2856         TALLOC_CTX *_mem_save_first_object_0;
2857         uint32_t _ptr_linked_attributes;
2858         uint32_t cntr_linked_attributes_1;
2859         TALLOC_CTX *_mem_save_linked_attributes_0;
2860         TALLOC_CTX *_mem_save_linked_attributes_1;
2861         if (ndr_flags & NDR_SCALARS) {
2862                 NDR_CHECK(ndr_pull_align(ndr, 8));
2863                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2864                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2866                 if (_ptr_naming_context) {
2867                         NDR_PULL_ALLOC(ndr, r->naming_context);
2868                 } else {
2869                         r->naming_context = NULL;
2870                 }
2871                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2872                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2874                 if (_ptr_uptodateness_vector) {
2875                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2876                 } else {
2877                         r->uptodateness_vector = NULL;
2878                 }
2879                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2880                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2884                 if (_ptr_first_object) {
2885                         NDR_PULL_ALLOC(ndr, r->first_object);
2886                 } else {
2887                         r->first_object = NULL;
2888                 }
2889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
2891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
2892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
2893                 if (r->linked_attributes_count > 1048576) {
2894                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2895                 }
2896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
2897                 if (_ptr_linked_attributes) {
2898                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
2899                 } else {
2900                         r->linked_attributes = NULL;
2901                 }
2902                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
2903         }
2904         if (ndr_flags & NDR_BUFFERS) {
2905                 if (r->naming_context) {
2906                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2907                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2908                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2909                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2910                 }
2911                 if (r->uptodateness_vector) {
2912                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2913                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2914                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2916                 }
2917                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2918                 if (r->first_object) {
2919                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2920                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2921                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2923                 }
2924                 if (r->linked_attributes) {
2925                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2926                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
2928                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
2929                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2930                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2931                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2932                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2933                         }
2934                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2935                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2936                         }
2937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
2938                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
2939                 }
2940                 if (r->linked_attributes) {
2941                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
2942                 }
2943         }
2944         return NDR_ERR_SUCCESS;
2945 }
2946
2947 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
2948 {
2949         uint32_t cntr_linked_attributes_1;
2950         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
2951         ndr->depth++;
2952         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2953         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2954         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2955         ndr->depth++;
2956         if (r->naming_context) {
2957                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2958         }
2959         ndr->depth--;
2960         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2961         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2962         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2963         ndr->depth++;
2964         if (r->uptodateness_vector) {
2965                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2966         }
2967         ndr->depth--;
2968         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2969         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2970         ndr_print_uint32(ndr, "object_count", r->object_count);
2971         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);
2972         ndr_print_ptr(ndr, "first_object", r->first_object);
2973         ndr->depth++;
2974         if (r->first_object) {
2975                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2976         }
2977         ndr->depth--;
2978         ndr_print_uint32(ndr, "more_data", r->more_data);
2979         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
2980         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
2981         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
2982         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
2983         ndr->depth++;
2984         if (r->linked_attributes) {
2985                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
2986                 ndr->depth++;
2987                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
2988                         char *idx_1=NULL;
2989                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
2990                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
2991                                 free(idx_1);
2992                         }
2993                 }
2994                 ndr->depth--;
2995         }
2996         ndr->depth--;
2997         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
2998         ndr->depth--;
2999 }
3000
3001 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3002 {
3003         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3004 }
3005
3006 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3007 {
3008         if (ndr_flags & NDR_SCALARS) {
3009                 NDR_CHECK(ndr_push_align(ndr, 1));
3010                 {
3011                         struct ndr_push *_ndr_ctr1;
3012                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3013                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3014                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3015                 }
3016         }
3017         if (ndr_flags & NDR_BUFFERS) {
3018         }
3019         return NDR_ERR_SUCCESS;
3020 }
3021
3022 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3023 {
3024         if (ndr_flags & NDR_SCALARS) {
3025                 NDR_CHECK(ndr_pull_align(ndr, 1));
3026                 {
3027                         struct ndr_pull *_ndr_ctr1;
3028                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3029                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3030                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3031                 }
3032         }
3033         if (ndr_flags & NDR_BUFFERS) {
3034         }
3035         return NDR_ERR_SUCCESS;
3036 }
3037
3038 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3039 {
3040         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3041         ndr->depth++;
3042         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3043         ndr->depth--;
3044 }
3045
3046 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3047 {
3048         if (ndr_flags & NDR_SCALARS) {
3049                 NDR_CHECK(ndr_push_align(ndr, 1));
3050                 {
3051                         struct ndr_push *_ndr_ctr6;
3052                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3053                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3054                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3055                 }
3056         }
3057         if (ndr_flags & NDR_BUFFERS) {
3058         }
3059         return NDR_ERR_SUCCESS;
3060 }
3061
3062 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3063 {
3064         if (ndr_flags & NDR_SCALARS) {
3065                 NDR_CHECK(ndr_pull_align(ndr, 1));
3066                 {
3067                         struct ndr_pull *_ndr_ctr6;
3068                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3069                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3070                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3071                 }
3072         }
3073         if (ndr_flags & NDR_BUFFERS) {
3074         }
3075         return NDR_ERR_SUCCESS;
3076 }
3077
3078 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3079 {
3080         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3081         ndr->depth++;
3082         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3083         ndr->depth--;
3084 }
3085
3086 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3087 {
3088         uint32_t _ptr_ts;
3089         TALLOC_CTX *_mem_save_ts_0;
3090         if (ndr_flags & NDR_SCALARS) {
3091                 NDR_CHECK(ndr_pull_align(ndr, 5));
3092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3095                 if (_ptr_ts) {
3096                         NDR_PULL_ALLOC(ndr, r->ts);
3097                 } else {
3098                         r->ts = NULL;
3099                 }
3100         }
3101         if (ndr_flags & NDR_BUFFERS) {
3102                 if (r->ts) {
3103                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3104                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3105                         {
3106                                 struct ndr_pull *_ndr_ts;
3107                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3108                                 {
3109                                         struct ndr_pull *_ndr_ts_compressed;
3110                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3111                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3112                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3113                                 }
3114                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3115                         }
3116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3117                 }
3118         }
3119         return NDR_ERR_SUCCESS;
3120 }
3121
3122 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3123 {
3124         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3125         ndr->depth++;
3126         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3127         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3128         ndr_print_ptr(ndr, "ts", r->ts);
3129         ndr->depth++;
3130         if (r->ts) {
3131                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3132         }
3133         ndr->depth--;
3134         ndr->depth--;
3135 }
3136
3137 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3138 {
3139         uint32_t _ptr_ts;
3140         TALLOC_CTX *_mem_save_ts_0;
3141         if (ndr_flags & NDR_SCALARS) {
3142                 NDR_CHECK(ndr_pull_align(ndr, 5));
3143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3146                 if (_ptr_ts) {
3147                         NDR_PULL_ALLOC(ndr, r->ts);
3148                 } else {
3149                         r->ts = NULL;
3150                 }
3151         }
3152         if (ndr_flags & NDR_BUFFERS) {
3153                 if (r->ts) {
3154                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3155                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3156                         {
3157                                 struct ndr_pull *_ndr_ts;
3158                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3159                                 {
3160                                         struct ndr_pull *_ndr_ts_compressed;
3161                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3162                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3163                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3164                                 }
3165                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3166                         }
3167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3168                 }
3169         }
3170         return NDR_ERR_SUCCESS;
3171 }
3172
3173 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3174 {
3175         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3176         ndr->depth++;
3177         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3178         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3179         ndr_print_ptr(ndr, "ts", r->ts);
3180         ndr->depth++;
3181         if (r->ts) {
3182                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3183         }
3184         ndr->depth--;
3185         ndr->depth--;
3186 }
3187
3188 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3189 {
3190         uint32_t _ptr_ts;
3191         TALLOC_CTX *_mem_save_ts_0;
3192         if (ndr_flags & NDR_SCALARS) {
3193                 NDR_CHECK(ndr_pull_align(ndr, 5));
3194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3196                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3197                 if (_ptr_ts) {
3198                         NDR_PULL_ALLOC(ndr, r->ts);
3199                 } else {
3200                         r->ts = NULL;
3201                 }
3202         }
3203         if (ndr_flags & NDR_BUFFERS) {
3204                 if (r->ts) {
3205                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3206                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3207                         {
3208                                 struct ndr_pull *_ndr_ts;
3209                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3210                                 {
3211                                         struct ndr_pull *_ndr_ts_compressed;
3212                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3213                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3214                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3215                                 }
3216                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3217                         }
3218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3219                 }
3220         }
3221         return NDR_ERR_SUCCESS;
3222 }
3223
3224 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3225 {
3226         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3227         ndr->depth++;
3228         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3229         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3230         ndr_print_ptr(ndr, "ts", r->ts);
3231         ndr->depth++;
3232         if (r->ts) {
3233                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3234         }
3235         ndr->depth--;
3236         ndr->depth--;
3237 }
3238
3239 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3240 {
3241         uint32_t _ptr_ts;
3242         TALLOC_CTX *_mem_save_ts_0;
3243         if (ndr_flags & NDR_SCALARS) {
3244                 NDR_CHECK(ndr_pull_align(ndr, 5));
3245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3247                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3248                 if (_ptr_ts) {
3249                         NDR_PULL_ALLOC(ndr, r->ts);
3250                 } else {
3251                         r->ts = NULL;
3252                 }
3253         }
3254         if (ndr_flags & NDR_BUFFERS) {
3255                 if (r->ts) {
3256                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3257                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3258                         {
3259                                 struct ndr_pull *_ndr_ts;
3260                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3261                                 {
3262                                         struct ndr_pull *_ndr_ts_compressed;
3263                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3264                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3265                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3266                                 }
3267                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3268                         }
3269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3270                 }
3271         }
3272         return NDR_ERR_SUCCESS;
3273 }
3274
3275 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3276 {
3277         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3278         ndr->depth++;
3279         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3280         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3281         ndr_print_ptr(ndr, "ts", r->ts);
3282         ndr->depth++;
3283         if (r->ts) {
3284                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3285         }
3286         ndr->depth--;
3287         ndr->depth--;
3288 }
3289
3290 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3291 {
3292         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
3293         return NDR_ERR_SUCCESS;
3294 }
3295
3296 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3297 {
3298         uint16_t v;
3299         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
3300         *r = v;
3301         return NDR_ERR_SUCCESS;
3302 }
3303
3304 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3305 {
3306         const char *val = NULL;
3307
3308         switch (r) {
3309                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3310                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3311         }
3312         ndr_print_enum(ndr, name, "ENUM", val, r);
3313 }
3314
3315 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3316 {
3317         {
3318                 uint32_t _flags_save_UNION = ndr->flags;
3319                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3320                 if (ndr_flags & NDR_SCALARS) {
3321                         int level = ndr_push_get_switch_value(ndr, r);
3322                         switch (level) {
3323                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3324                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3325                                 break; }
3326
3327                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3328                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3329                                 break; }
3330
3331                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3332                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3333                                 break; }
3334
3335                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3336                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3337                                 break; }
3338
3339                                 default:
3340                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3341                         }
3342                 }
3343                 if (ndr_flags & NDR_BUFFERS) {
3344                         int level = ndr_push_get_switch_value(ndr, r);
3345                         switch (level) {
3346                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3347                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3348                                 break;
3349
3350                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3351                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3352                                 break;
3353
3354                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3355                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3356                                 break;
3357
3358                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3359                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3360                                 break;
3361
3362                                 default:
3363                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3364                         }
3365                 }
3366                 ndr->flags = _flags_save_UNION;
3367         }
3368         return NDR_ERR_SUCCESS;
3369 }
3370
3371 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3372 {
3373         int level;
3374         {
3375                 uint32_t _flags_save_UNION = ndr->flags;
3376                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3377                 level = ndr_pull_get_switch_value(ndr, r);
3378                 if (ndr_flags & NDR_SCALARS) {
3379                         switch (level) {
3380                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3381                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3382                                 break; }
3383
3384                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3385                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3386                                 break; }
3387
3388                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3389                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3390                                 break; }
3391
3392                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3393                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3394                                 break; }
3395
3396                                 default:
3397                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3398                         }
3399                 }
3400                 if (ndr_flags & NDR_BUFFERS) {
3401                         switch (level) {
3402                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3403                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3404                                 break;
3405
3406                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3407                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3408                                 break;
3409
3410                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3411                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3412                                 break;
3413
3414                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3415                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3416                                 break;
3417
3418                                 default:
3419                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3420                         }
3421                 }
3422                 ndr->flags = _flags_save_UNION;
3423         }
3424         return NDR_ERR_SUCCESS;
3425 }
3426
3427 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3428 {
3429         int level;
3430         {
3431                 uint32_t _flags_save_UNION = ndr->flags;
3432                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3433                 level = ndr_print_get_switch_value(ndr, r);
3434                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3435                 switch (level) {
3436                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3437                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3438                         break;
3439
3440                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3441                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3442                         break;
3443
3444                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3445                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3446                         break;
3447
3448                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3449                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3450                         break;
3451
3452                         default:
3453                                 ndr_print_bad_level(ndr, name, level);
3454                 }
3455                 ndr->flags = _flags_save_UNION;
3456         }
3457 }
3458
3459 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3460 {
3461         if (ndr_flags & NDR_SCALARS) {
3462                 NDR_CHECK(ndr_push_align(ndr, 5));
3463                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3464         }
3465         if (ndr_flags & NDR_BUFFERS) {
3466                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3467         }
3468         return NDR_ERR_SUCCESS;
3469 }
3470
3471 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3472 {
3473         if (ndr_flags & NDR_SCALARS) {
3474                 NDR_CHECK(ndr_pull_align(ndr, 5));
3475                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3476         }
3477         if (ndr_flags & NDR_BUFFERS) {
3478                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3479         }
3480         return NDR_ERR_SUCCESS;
3481 }
3482
3483 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3484 {
3485         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3486         ndr->depth++;
3487         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3488         ndr->depth--;
3489 }
3490
3491 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3492 {
3493         if (ndr_flags & NDR_SCALARS) {
3494                 NDR_CHECK(ndr_push_align(ndr, 5));
3495                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3496                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3497                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3498                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3499         }
3500         if (ndr_flags & NDR_BUFFERS) {
3501                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3502         }
3503         return NDR_ERR_SUCCESS;
3504 }
3505
3506 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3507 {
3508         if (ndr_flags & NDR_SCALARS) {
3509                 NDR_CHECK(ndr_pull_align(ndr, 5));
3510                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3511                 if (r->level < 0 || r->level > 6) {
3512                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3513                 }
3514                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3515                 if (r->type < 2 || r->type > 3) {
3516                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3517                 }
3518                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3519                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3520         }
3521         if (ndr_flags & NDR_BUFFERS) {
3522                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3523         }
3524         return NDR_ERR_SUCCESS;
3525 }
3526
3527 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3528 {
3529         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3530         ndr->depth++;
3531         ndr_print_int32(ndr, "level", r->level);
3532         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3533         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3534         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3535         ndr->depth--;
3536 }
3537
3538 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3539 {
3540         if (ndr_flags & NDR_SCALARS) {
3541                 int level = ndr_push_get_switch_value(ndr, r);
3542                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3543                 switch (level) {
3544                         case 1: {
3545                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3546                         break; }
3547
3548                         case 2: {
3549                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3550                         break; }
3551
3552                         case 6: {
3553                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3554                         break; }
3555
3556                         case 7: {
3557                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3558                         break; }
3559
3560                         default:
3561                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3562                 }
3563         }
3564         if (ndr_flags & NDR_BUFFERS) {
3565                 int level = ndr_push_get_switch_value(ndr, r);
3566                 switch (level) {
3567                         case 1:
3568                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3569                         break;
3570
3571                         case 2:
3572                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3573                         break;
3574
3575                         case 6:
3576                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3577                         break;
3578
3579                         case 7:
3580                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3581                         break;
3582
3583                         default:
3584                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3585                 }
3586         }
3587         return NDR_ERR_SUCCESS;
3588 }
3589
3590 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3591 {
3592         int level;
3593         int32_t _level;
3594         level = ndr_pull_get_switch_value(ndr, r);
3595         if (ndr_flags & NDR_SCALARS) {
3596                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3597                 if (_level != level) {
3598                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3599                 }
3600                 switch (level) {
3601                         case 1: {
3602                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3603                         break; }
3604
3605                         case 2: {
3606                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3607                         break; }
3608
3609                         case 6: {
3610                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3611                         break; }
3612
3613                         case 7: {
3614                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3615                         break; }
3616
3617                         default:
3618                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3619                 }
3620         }
3621         if (ndr_flags & NDR_BUFFERS) {
3622                 switch (level) {
3623                         case 1:
3624                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3625                         break;
3626
3627                         case 2:
3628                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3629                         break;
3630
3631                         case 6:
3632                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3633                         break;
3634
3635                         case 7:
3636                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3637                         break;
3638
3639                         default:
3640                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3641                 }
3642         }
3643         return NDR_ERR_SUCCESS;
3644 }
3645
3646 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3647 {
3648         int level;
3649         level = ndr_print_get_switch_value(ndr, r);
3650         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3651         switch (level) {
3652                 case 1:
3653                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3654                 break;
3655
3656                 case 2:
3657                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3658                 break;
3659
3660                 case 6:
3661                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3662                 break;
3663
3664                 case 7:
3665                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3666                 break;
3667
3668                 default:
3669                         ndr_print_bad_level(ndr, name, level);
3670         }
3671 }
3672
3673 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3674 {
3675         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3676         return NDR_ERR_SUCCESS;
3677 }
3678
3679 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3680 {
3681         uint32_t v;
3682         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3683         *r = v;
3684         return NDR_ERR_SUCCESS;
3685 }
3686
3687 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3688 {
3689         ndr_print_uint32(ndr, name, r);
3690         ndr->depth++;
3691         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION, r);
3692         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK", DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK, r);
3693         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE, r);
3694         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE, r);
3695         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE", DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE, r);
3696         ndr->depth--;
3697 }
3698
3699 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3700 {
3701         if (ndr_flags & NDR_SCALARS) {
3702                 NDR_CHECK(ndr_push_align(ndr, 5));
3703                 if (r->naming_context == NULL) {
3704                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3705                 }
3706                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3707                 if (r->dest_dsa_dns_name == NULL) {
3708                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3709                 }
3710                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3711                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3712                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
3713         }
3714         if (ndr_flags & NDR_BUFFERS) {
3715                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3716                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3717                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3718                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3719                 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));
3720         }
3721         return NDR_ERR_SUCCESS;
3722 }
3723
3724 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3725 {
3726         uint32_t _ptr_naming_context;
3727         TALLOC_CTX *_mem_save_naming_context_0;
3728         uint32_t _ptr_dest_dsa_dns_name;
3729         if (ndr_flags & NDR_SCALARS) {
3730                 NDR_CHECK(ndr_pull_align(ndr, 5));
3731                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3732                 if (_ptr_naming_context) {
3733                         NDR_PULL_ALLOC(ndr, r->naming_context);
3734                 } else {
3735                         r->naming_context = NULL;
3736                 }
3737                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3738                 if (_ptr_dest_dsa_dns_name) {
3739                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3740                 } else {
3741                         r->dest_dsa_dns_name = NULL;
3742                 }
3743                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3744                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
3745         }
3746         if (ndr_flags & NDR_BUFFERS) {
3747                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3748                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3749                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3750                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3751                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3752                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3753                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3754                         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));
3755                 }
3756                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3757                 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));
3758         }
3759         return NDR_ERR_SUCCESS;
3760 }
3761
3762 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3763 {
3764         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3765         ndr->depth++;
3766         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3767         ndr->depth++;
3768         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3769         ndr->depth--;
3770         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3771         ndr->depth++;
3772         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3773         ndr->depth--;
3774         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3775         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "options", r->options);
3776         ndr->depth--;
3777 }
3778
3779 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3780 {
3781         if (ndr_flags & NDR_SCALARS) {
3782                 int level = ndr_push_get_switch_value(ndr, r);
3783                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3784                 switch (level) {
3785                         case 1: {
3786                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3787                         break; }
3788
3789                         default:
3790                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3791                 }
3792         }
3793         if (ndr_flags & NDR_BUFFERS) {
3794                 int level = ndr_push_get_switch_value(ndr, r);
3795                 switch (level) {
3796                         case 1:
3797                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3798                         break;
3799
3800                         default:
3801                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3802                 }
3803         }
3804         return NDR_ERR_SUCCESS;
3805 }
3806
3807 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3808 {
3809         int level;
3810         int32_t _level;
3811         level = ndr_pull_get_switch_value(ndr, r);
3812         if (ndr_flags & NDR_SCALARS) {
3813                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3814                 if (_level != level) {
3815                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3816                 }
3817                 switch (level) {
3818                         case 1: {
3819                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3820                         break; }
3821
3822                         default:
3823                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3824                 }
3825         }
3826         if (ndr_flags & NDR_BUFFERS) {
3827                 switch (level) {
3828                         case 1:
3829                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3830                         break;
3831
3832                         default:
3833                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3834                 }
3835         }
3836         return NDR_ERR_SUCCESS;
3837 }
3838
3839 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3840 {
3841         int level;
3842         level = ndr_print_get_switch_value(ndr, r);
3843         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3844         switch (level) {
3845                 case 1:
3846                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3847                 break;
3848
3849                 default:
3850                         ndr_print_bad_level(ndr, name, level);
3851         }
3852 }
3853
3854 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3855 {
3856         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3857         return NDR_ERR_SUCCESS;
3858 }
3859
3860 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3861 {
3862         uint32_t v;
3863         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3864         *r = v;
3865         return NDR_ERR_SUCCESS;
3866 }
3867
3868 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3869 {
3870         ndr_print_uint32(ndr, name, r);
3871         ndr->depth++;
3872         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
3873         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
3874         ndr->depth--;
3875 }
3876
3877 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
3878 {
3879         if (ndr_flags & NDR_SCALARS) {
3880                 NDR_CHECK(ndr_push_align(ndr, 5));
3881                 if (r->naming_context == NULL) {
3882                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3883                 }
3884                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3886                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3887                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
3888         }
3889         if (ndr_flags & NDR_BUFFERS) {
3890                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3891                 if (r->source_dsa_address) {
3892                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3893                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3894                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3895                         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));
3896                 }
3897         }
3898         return NDR_ERR_SUCCESS;
3899 }
3900
3901 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
3902 {
3903         uint32_t _ptr_naming_context;
3904         TALLOC_CTX *_mem_save_naming_context_0;
3905         uint32_t _ptr_source_dsa_address;
3906         TALLOC_CTX *_mem_save_source_dsa_address_0;
3907         if (ndr_flags & NDR_SCALARS) {
3908                 NDR_CHECK(ndr_pull_align(ndr, 5));
3909                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3910                 if (_ptr_naming_context) {
3911                         NDR_PULL_ALLOC(ndr, r->naming_context);
3912                 } else {
3913                         r->naming_context = NULL;
3914                 }
3915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
3916                 if (_ptr_source_dsa_address) {
3917                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
3918                 } else {
3919                         r->source_dsa_address = NULL;
3920                 }
3921                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3922                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
3923         }
3924         if (ndr_flags & NDR_BUFFERS) {
3925                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3926                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3927                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3928                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3929                 if (r->source_dsa_address) {
3930                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
3931                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
3932                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
3933                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
3934                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
3935                                 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));
3936                         }
3937                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
3938                         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));
3939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
3940                 }
3941         }
3942         return NDR_ERR_SUCCESS;
3943 }
3944
3945 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
3946 {
3947         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
3948         ndr->depth++;
3949         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3950         ndr->depth++;
3951         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3952         ndr->depth--;
3953         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
3954         ndr->depth++;
3955         if (r->source_dsa_address) {
3956                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
3957         }
3958         ndr->depth--;
3959         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
3960         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
3961         ndr->depth--;
3962 }
3963
3964 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
3965 {
3966         if (ndr_flags & NDR_SCALARS) {
3967                 NDR_CHECK(ndr_push_align(ndr, 5));
3968                 if (r->naming_context == NULL) {
3969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3970                 }
3971                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3972                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
3973                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
3974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3975                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3976                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
3977         }
3978         if (ndr_flags & NDR_BUFFERS) {
3979                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3980                 if (r->source_dsa_dn) {
3981                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
3982                 }
3983                 if (r->transport_dn) {
3984                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
3985                 }
3986                 if (r->source_dsa_address) {
3987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3988                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3989                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3990                         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));
3991                 }
3992         }
3993         return NDR_ERR_SUCCESS;
3994 }
3995
3996 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
3997 {
3998         uint32_t _ptr_naming_context;
3999         TALLOC_CTX *_mem_save_naming_context_0;
4000         uint32_t _ptr_source_dsa_dn;
4001         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4002         uint32_t _ptr_transport_dn;
4003         TALLOC_CTX *_mem_save_transport_dn_0;
4004         uint32_t _ptr_source_dsa_address;
4005         TALLOC_CTX *_mem_save_source_dsa_address_0;
4006         if (ndr_flags & NDR_SCALARS) {
4007                 NDR_CHECK(ndr_pull_align(ndr, 5));
4008                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4009                 if (_ptr_naming_context) {
4010                         NDR_PULL_ALLOC(ndr, r->naming_context);
4011                 } else {
4012                         r->naming_context = NULL;
4013                 }
4014                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4015                 if (_ptr_source_dsa_dn) {
4016                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4017                 } else {
4018                         r->source_dsa_dn = NULL;
4019                 }
4020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4021                 if (_ptr_transport_dn) {
4022                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4023                 } else {
4024                         r->transport_dn = NULL;
4025                 }
4026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4027                 if (_ptr_source_dsa_address) {
4028                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4029                 } else {
4030                         r->source_dsa_address = NULL;
4031                 }
4032                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4033                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4034         }
4035         if (ndr_flags & NDR_BUFFERS) {
4036                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4037                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4038                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4039                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4040                 if (r->source_dsa_dn) {
4041                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4042                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4043                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4045                 }
4046                 if (r->transport_dn) {
4047                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4048                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4049                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4051                 }
4052                 if (r->source_dsa_address) {
4053                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4054                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4057                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4058                                 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));
4059                         }
4060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4061                         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));
4062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4063                 }
4064         }
4065         return NDR_ERR_SUCCESS;
4066 }
4067
4068 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4069 {
4070         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4071         ndr->depth++;
4072         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4073         ndr->depth++;
4074         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4075         ndr->depth--;
4076         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4077         ndr->depth++;
4078         if (r->source_dsa_dn) {
4079                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4080         }
4081         ndr->depth--;
4082         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4083         ndr->depth++;
4084         if (r->transport_dn) {
4085                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4086         }
4087         ndr->depth--;
4088         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4089         ndr->depth++;
4090         if (r->source_dsa_address) {
4091                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4092         }
4093         ndr->depth--;
4094         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4095         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
4096         ndr->depth--;
4097 }
4098
4099 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4100 {
4101         if (ndr_flags & NDR_SCALARS) {
4102                 int level = ndr_push_get_switch_value(ndr, r);
4103                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4104                 switch (level) {
4105                         case 1: {
4106                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4107                         break; }
4108
4109                         case 2: {
4110                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4111                         break; }
4112
4113                         default:
4114                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4115                 }
4116         }
4117         if (ndr_flags & NDR_BUFFERS) {
4118                 int level = ndr_push_get_switch_value(ndr, r);
4119                 switch (level) {
4120                         case 1:
4121                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4122                         break;
4123
4124                         case 2:
4125                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4126                         break;
4127
4128                         default:
4129                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4130                 }
4131         }
4132         return NDR_ERR_SUCCESS;
4133 }
4134
4135 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4136 {
4137         int level;
4138         int32_t _level;
4139         level = ndr_pull_get_switch_value(ndr, r);
4140         if (ndr_flags & NDR_SCALARS) {
4141                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4142                 if (_level != level) {
4143                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4144                 }
4145                 switch (level) {
4146                         case 1: {
4147                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4148                         break; }
4149
4150                         case 2: {
4151                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4152                         break; }
4153
4154                         default:
4155                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4156                 }
4157         }
4158         if (ndr_flags & NDR_BUFFERS) {
4159                 switch (level) {
4160                         case 1:
4161                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4162                         break;
4163
4164                         case 2:
4165                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4166                         break;
4167
4168                         default:
4169                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4170                 }
4171         }
4172         return NDR_ERR_SUCCESS;
4173 }
4174
4175 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4176 {
4177         int level;
4178         level = ndr_print_get_switch_value(ndr, r);
4179         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4180         switch (level) {
4181                 case 1:
4182                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4183                 break;
4184
4185                 case 2:
4186                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4187                 break;
4188
4189                 default:
4190                         ndr_print_bad_level(ndr, name, level);
4191         }
4192 }
4193
4194 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4195 {
4196         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4197         return NDR_ERR_SUCCESS;
4198 }
4199
4200 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4201 {
4202         uint32_t v;
4203         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4204         *r = v;
4205         return NDR_ERR_SUCCESS;
4206 }
4207
4208 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4209 {
4210         ndr_print_uint32(ndr, name, r);
4211         ndr->depth++;
4212         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4213         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4214         ndr->depth--;
4215 }
4216
4217 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4218 {
4219         if (ndr_flags & NDR_SCALARS) {
4220                 NDR_CHECK(ndr_push_align(ndr, 5));
4221                 if (r->naming_context == NULL) {
4222                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4223                 }
4224                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4225                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4226                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->options));
4227         }
4228         if (ndr_flags & NDR_BUFFERS) {
4229                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4230                 if (r->source_dsa_address) {
4231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4234                         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));
4235                 }
4236         }
4237         return NDR_ERR_SUCCESS;
4238 }
4239
4240 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4241 {
4242         uint32_t _ptr_naming_context;
4243         TALLOC_CTX *_mem_save_naming_context_0;
4244         uint32_t _ptr_source_dsa_address;
4245         TALLOC_CTX *_mem_save_source_dsa_address_0;
4246         if (ndr_flags & NDR_SCALARS) {
4247                 NDR_CHECK(ndr_pull_align(ndr, 5));
4248                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4249                 if (_ptr_naming_context) {
4250                         NDR_PULL_ALLOC(ndr, r->naming_context);
4251                 } else {
4252                         r->naming_context = NULL;
4253                 }
4254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4255                 if (_ptr_source_dsa_address) {
4256                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4257                 } else {
4258                         r->source_dsa_address = NULL;
4259                 }
4260                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->options));
4261         }
4262         if (ndr_flags & NDR_BUFFERS) {
4263                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4264                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4265                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4266                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4267                 if (r->source_dsa_address) {
4268                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4269                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4270                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4271                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4272                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4273                                 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));
4274                         }
4275                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4276                         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));
4277                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4278                 }
4279         }
4280         return NDR_ERR_SUCCESS;
4281 }
4282
4283 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4284 {
4285         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4286         ndr->depth++;
4287         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4288         ndr->depth++;
4289         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4290         ndr->depth--;
4291         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4292         ndr->depth++;
4293         if (r->source_dsa_address) {
4294                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4295         }
4296         ndr->depth--;
4297         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "options", r->options);
4298         ndr->depth--;
4299 }
4300
4301 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4302 {
4303         if (ndr_flags & NDR_SCALARS) {
4304                 int level = ndr_push_get_switch_value(ndr, r);
4305                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4306                 switch (level) {
4307                         case 1: {
4308                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4309                         break; }
4310
4311                         default:
4312                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4313                 }
4314         }
4315         if (ndr_flags & NDR_BUFFERS) {
4316                 int level = ndr_push_get_switch_value(ndr, r);
4317                 switch (level) {
4318                         case 1:
4319                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4320                         break;
4321
4322                         default:
4323                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4324                 }
4325         }
4326         return NDR_ERR_SUCCESS;
4327 }
4328
4329 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4330 {
4331         int level;
4332         int32_t _level;
4333         level = ndr_pull_get_switch_value(ndr, r);
4334         if (ndr_flags & NDR_SCALARS) {
4335                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4336                 if (_level != level) {
4337                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4338                 }
4339                 switch (level) {
4340                         case 1: {
4341                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4342                         break; }
4343
4344                         default:
4345                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4346                 }
4347         }
4348         if (ndr_flags & NDR_BUFFERS) {
4349                 switch (level) {
4350                         case 1:
4351                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4352                         break;
4353
4354                         default:
4355                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4356                 }
4357         }
4358         return NDR_ERR_SUCCESS;
4359 }
4360
4361 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4362 {
4363         int level;
4364         level = ndr_print_get_switch_value(ndr, r);
4365         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4366         switch (level) {
4367                 case 1:
4368                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4369                 break;
4370
4371                 default:
4372                         ndr_print_bad_level(ndr, name, level);
4373         }
4374 }
4375
4376 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4377 {
4378         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4379         return NDR_ERR_SUCCESS;
4380 }
4381
4382 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModifyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4383 {
4384         uint32_t v;
4385         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4386         *r = v;
4387         return NDR_ERR_SUCCESS;
4388 }
4389
4390 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4391 {
4392         ndr_print_uint32(ndr, name, r);
4393         ndr->depth++;
4394         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4395         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4396         ndr->depth--;
4397 }
4398
4399 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4400 {
4401         if (ndr_flags & NDR_SCALARS) {
4402                 NDR_CHECK(ndr_push_align(ndr, 5));
4403                 if (r->naming_context == NULL) {
4404                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4405                 }
4406                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4407                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4408                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4409                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4412                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->options));
4413         }
4414         if (ndr_flags & NDR_BUFFERS) {
4415                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4416                 if (r->source_dra_address) {
4417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4419                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4420                         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));
4421                 }
4422         }
4423         return NDR_ERR_SUCCESS;
4424 }
4425
4426 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4427 {
4428         uint32_t _ptr_naming_context;
4429         TALLOC_CTX *_mem_save_naming_context_0;
4430         uint32_t _ptr_source_dra_address;
4431         TALLOC_CTX *_mem_save_source_dra_address_0;
4432         if (ndr_flags & NDR_SCALARS) {
4433                 NDR_CHECK(ndr_pull_align(ndr, 5));
4434                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4435                 if (_ptr_naming_context) {
4436                         NDR_PULL_ALLOC(ndr, r->naming_context);
4437                 } else {
4438                         r->naming_context = NULL;
4439                 }
4440                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4442                 if (_ptr_source_dra_address) {
4443                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4444                 } else {
4445                         r->source_dra_address = NULL;
4446                 }
4447                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4450                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->options));
4451         }
4452         if (ndr_flags & NDR_BUFFERS) {
4453                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4454                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4455                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4457                 if (r->source_dra_address) {
4458                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4459                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4460                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4461                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4462                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4463                                 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));
4464                         }
4465                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4466                         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));
4467                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4468                 }
4469         }
4470         return NDR_ERR_SUCCESS;
4471 }
4472
4473 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4474 {
4475         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4476         ndr->depth++;
4477         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4478         ndr->depth++;
4479         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4480         ndr->depth--;
4481         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4482         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4483         ndr->depth++;
4484         if (r->source_dra_address) {
4485                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4486         }
4487         ndr->depth--;
4488         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4489         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4490         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4491         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "options", r->options);
4492         ndr->depth--;
4493 }
4494
4495 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4496 {
4497         if (ndr_flags & NDR_SCALARS) {
4498                 int level = ndr_push_get_switch_value(ndr, r);
4499                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4500                 switch (level) {
4501                         case 1: {
4502                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4503                         break; }
4504
4505                         default:
4506                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4507                 }
4508         }
4509         if (ndr_flags & NDR_BUFFERS) {
4510                 int level = ndr_push_get_switch_value(ndr, r);
4511                 switch (level) {
4512                         case 1:
4513                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4514                         break;
4515
4516                         default:
4517                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4518                 }
4519         }
4520         return NDR_ERR_SUCCESS;
4521 }
4522
4523 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4524 {
4525         int level;
4526         int32_t _level;
4527         level = ndr_pull_get_switch_value(ndr, r);
4528         if (ndr_flags & NDR_SCALARS) {
4529                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4530                 if (_level != level) {
4531                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4532                 }
4533                 switch (level) {
4534                         case 1: {
4535                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4536                         break; }
4537
4538                         default:
4539                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4540                 }
4541         }
4542         if (ndr_flags & NDR_BUFFERS) {
4543                 switch (level) {
4544                         case 1:
4545                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4546                         break;
4547
4548                         default:
4549                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4550                 }
4551         }
4552         return NDR_ERR_SUCCESS;
4553 }
4554
4555 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4556 {
4557         int level;
4558         level = ndr_print_get_switch_value(ndr, r);
4559         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4560         switch (level) {
4561                 case 1:
4562                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4563                 break;
4564
4565                 default:
4566                         ndr_print_bad_level(ndr, name, level);
4567         }
4568 }
4569
4570 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4571 {
4572         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4573         return NDR_ERR_SUCCESS;
4574 }
4575
4576 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4577 {
4578         uint32_t v;
4579         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4580         *r = v;
4581         return NDR_ERR_SUCCESS;
4582 }
4583
4584 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4585 {
4586         const char *val = NULL;
4587
4588         switch (r) {
4589                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4590                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4591                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4592                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4593                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4594                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4595                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4596         }
4597         ndr_print_enum(ndr, name, "ENUM", val, r);
4598 }
4599
4600 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, 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         if (ndr_flags & NDR_SCALARS) {
4606                 NDR_CHECK(ndr_push_align(ndr, 5));
4607                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4610                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4612                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4613         }
4614         if (ndr_flags & NDR_BUFFERS) {
4615                 if (r->info_array) {
4616                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4617                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4618                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4619                         }
4620                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4621                                 if (r->info_array[cntr_info_array_1]) {
4622                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4623                                 }
4624                         }
4625                 }
4626                 if (r->group_attrs) {
4627                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4628                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4629                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4630                         }
4631                 }
4632                 if (r->sids) {
4633                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4634                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4635                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4636                         }
4637                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4638                                 if (r->sids[cntr_sids_1]) {
4639                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4640                                 }
4641                         }
4642                 }
4643         }
4644         return NDR_ERR_SUCCESS;
4645 }
4646
4647 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4648 {
4649         uint32_t _ptr_info_array;
4650         uint32_t cntr_info_array_1;
4651         TALLOC_CTX *_mem_save_info_array_0;
4652         TALLOC_CTX *_mem_save_info_array_1;
4653         TALLOC_CTX *_mem_save_info_array_2;
4654         uint32_t _ptr_group_attrs;
4655         uint32_t cntr_group_attrs_1;
4656         TALLOC_CTX *_mem_save_group_attrs_0;
4657         TALLOC_CTX *_mem_save_group_attrs_1;
4658         uint32_t _ptr_sids;
4659         uint32_t cntr_sids_1;
4660         TALLOC_CTX *_mem_save_sids_0;
4661         TALLOC_CTX *_mem_save_sids_1;
4662         TALLOC_CTX *_mem_save_sids_2;
4663         if (ndr_flags & NDR_SCALARS) {
4664                 NDR_CHECK(ndr_pull_align(ndr, 5));
4665                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4666                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4667                 if (r->num_memberships > 10000) {
4668                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4669                 }
4670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4671                 if (r->num_sids > 10000) {
4672                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4673                 }
4674                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4675                 if (_ptr_info_array) {
4676                         NDR_PULL_ALLOC(ndr, r->info_array);
4677                 } else {
4678                         r->info_array = NULL;
4679                 }
4680                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4681                 if (_ptr_group_attrs) {
4682                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4683                 } else {
4684                         r->group_attrs = NULL;
4685                 }
4686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4687                 if (_ptr_sids) {
4688                         NDR_PULL_ALLOC(ndr, r->sids);
4689                 } else {
4690                         r->sids = NULL;
4691                 }
4692         }
4693         if (ndr_flags & NDR_BUFFERS) {
4694                 if (r->info_array) {
4695                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4696                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4697                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4698                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4699                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4700                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4701                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4702                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4703                                 if (_ptr_info_array) {
4704                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4705                                 } else {
4706                                         r->info_array[cntr_info_array_1] = NULL;
4707                                 }
4708                         }
4709                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4710                                 if (r->info_array[cntr_info_array_1]) {
4711                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4712                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4713                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4714                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4715                                 }
4716                         }
4717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4718                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4719                 }
4720                 if (r->group_attrs) {
4721                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4722                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4723                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4724                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4725                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4726                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4727                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4728                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4729                         }
4730                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4731                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4732                 }
4733                 if (r->sids) {
4734                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4735                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4736                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4737                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4738                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4739                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4740                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4741                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4742                                 if (_ptr_sids) {
4743                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4744                                 } else {
4745                                         r->sids[cntr_sids_1] = NULL;
4746                                 }
4747                         }
4748                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4749                                 if (r->sids[cntr_sids_1]) {
4750                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4751                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4752                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4753                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4754                                 }
4755                         }
4756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4757                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4758                 }
4759                 if (r->info_array) {
4760                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4761                 }
4762                 if (r->group_attrs) {
4763                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4764                 }
4765                 if (r->sids) {
4766                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4767                 }
4768         }
4769         return NDR_ERR_SUCCESS;
4770 }
4771
4772 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4773 {
4774         uint32_t cntr_info_array_1;
4775         uint32_t cntr_group_attrs_1;
4776         uint32_t cntr_sids_1;
4777         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4778         ndr->depth++;
4779         ndr_print_NTSTATUS(ndr, "status", r->status);
4780         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4781         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4782         ndr_print_ptr(ndr, "info_array", r->info_array);
4783         ndr->depth++;
4784         if (r->info_array) {
4785                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4786                 ndr->depth++;
4787                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4788                         char *idx_1=NULL;
4789                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4790                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4791                                 ndr->depth++;
4792                                 if (r->info_array[cntr_info_array_1]) {
4793                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4794                                 }
4795                                 ndr->depth--;
4796                                 free(idx_1);
4797                         }
4798                 }
4799                 ndr->depth--;
4800         }
4801         ndr->depth--;
4802         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4803         ndr->depth++;
4804         if (r->group_attrs) {
4805                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4806                 ndr->depth++;
4807                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4808                         char *idx_1=NULL;
4809                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4810                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4811                                 free(idx_1);
4812                         }
4813                 }
4814                 ndr->depth--;
4815         }
4816         ndr->depth--;
4817         ndr_print_ptr(ndr, "sids", r->sids);
4818         ndr->depth++;
4819         if (r->sids) {
4820                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4821                 ndr->depth++;
4822                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4823                         char *idx_1=NULL;
4824                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4825                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4826                                 ndr->depth++;
4827                                 if (r->sids[cntr_sids_1]) {
4828                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4829                                 }
4830                                 ndr->depth--;
4831                                 free(idx_1);
4832                         }
4833                 }
4834                 ndr->depth--;
4835         }
4836         ndr->depth--;
4837         ndr->depth--;
4838 }
4839
4840 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4841 {
4842         if (ndr_flags & NDR_SCALARS) {
4843                 int level = ndr_push_get_switch_value(ndr, r);
4844                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4845                 switch (level) {
4846                         case 1: {
4847                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4848                         break; }
4849
4850                         default:
4851                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4852                 }
4853         }
4854         if (ndr_flags & NDR_BUFFERS) {
4855                 int level = ndr_push_get_switch_value(ndr, r);
4856                 switch (level) {
4857                         case 1:
4858                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4859                         break;
4860
4861                         default:
4862                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4863                 }
4864         }
4865         return NDR_ERR_SUCCESS;
4866 }
4867
4868 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4869 {
4870         int level;
4871         int32_t _level;
4872         level = ndr_pull_get_switch_value(ndr, r);
4873         if (ndr_flags & NDR_SCALARS) {
4874                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4875                 if (_level != level) {
4876                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4877                 }
4878                 switch (level) {
4879                         case 1: {
4880                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4881                         break; }
4882
4883                         default:
4884                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4885                 }
4886         }
4887         if (ndr_flags & NDR_BUFFERS) {
4888                 switch (level) {
4889                         case 1:
4890                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4891                         break;
4892
4893                         default:
4894                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4895                 }
4896         }
4897         return NDR_ERR_SUCCESS;
4898 }
4899
4900 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
4901 {
4902         int level;
4903         level = ndr_print_get_switch_value(ndr, r);
4904         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
4905         switch (level) {
4906                 case 1:
4907                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
4908                 break;
4909
4910                 default:
4911                         ndr_print_bad_level(ndr, name, level);
4912         }
4913 }
4914
4915 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
4916 {
4917         uint32_t cntr_info_array_1;
4918         if (ndr_flags & NDR_SCALARS) {
4919                 NDR_CHECK(ndr_push_align(ndr, 5));
4920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4921                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4923                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
4924                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
4925         }
4926         if (ndr_flags & NDR_BUFFERS) {
4927                 if (r->info_array) {
4928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4929                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4930                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4931                         }
4932                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4933                                 if (r->info_array[cntr_info_array_1]) {
4934                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4935                                 }
4936                         }
4937                 }
4938                 if (r->domain) {
4939                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
4940                 }
4941         }
4942         return NDR_ERR_SUCCESS;
4943 }
4944
4945 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
4946 {
4947         uint32_t _ptr_info_array;
4948         uint32_t cntr_info_array_1;
4949         TALLOC_CTX *_mem_save_info_array_0;
4950         TALLOC_CTX *_mem_save_info_array_1;
4951         TALLOC_CTX *_mem_save_info_array_2;
4952         uint32_t _ptr_domain;
4953         TALLOC_CTX *_mem_save_domain_0;
4954         if (ndr_flags & NDR_SCALARS) {
4955                 NDR_CHECK(ndr_pull_align(ndr, 5));
4956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4957                 if (r->count < 1 || r->count > 10000) {
4958                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4959                 }
4960                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4961                 if (_ptr_info_array) {
4962                         NDR_PULL_ALLOC(ndr, r->info_array);
4963                 } else {
4964                         r->info_array = NULL;
4965                 }
4966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4967                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
4968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
4969                 if (_ptr_domain) {
4970                         NDR_PULL_ALLOC(ndr, r->domain);
4971                 } else {
4972                         r->domain = NULL;
4973                 }
4974         }
4975         if (ndr_flags & NDR_BUFFERS) {
4976                 if (r->info_array) {
4977                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4978                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4979                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4980                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4981                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4982                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4983                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4984                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4985                                 if (_ptr_info_array) {
4986                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4987                                 } else {
4988                                         r->info_array[cntr_info_array_1] = NULL;
4989                                 }
4990                         }
4991                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4992                                 if (r->info_array[cntr_info_array_1]) {
4993                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4994                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4995                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4996                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4997                                 }
4998                         }
4999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5000                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5001                 }
5002                 if (r->domain) {
5003                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5004                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5005                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5006                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5007                 }
5008                 if (r->info_array) {
5009                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5010                 }
5011         }
5012         return NDR_ERR_SUCCESS;
5013 }
5014
5015 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5016 {
5017         uint32_t cntr_info_array_1;
5018         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5019         ndr->depth++;
5020         ndr_print_uint32(ndr, "count", r->count);
5021         ndr_print_ptr(ndr, "info_array", r->info_array);
5022         ndr->depth++;
5023         if (r->info_array) {
5024                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5025                 ndr->depth++;
5026                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5027                         char *idx_1=NULL;
5028                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5029                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5030                                 ndr->depth++;
5031                                 if (r->info_array[cntr_info_array_1]) {
5032                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5033                                 }
5034                                 ndr->depth--;
5035                                 free(idx_1);
5036                         }
5037                 }
5038                 ndr->depth--;
5039         }
5040         ndr->depth--;
5041         ndr_print_uint32(ndr, "flags", r->flags);
5042         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5043         ndr_print_ptr(ndr, "domain", r->domain);
5044         ndr->depth++;
5045         if (r->domain) {
5046                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5047         }
5048         ndr->depth--;
5049         ndr->depth--;
5050 }
5051
5052 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5053 {
5054         if (ndr_flags & NDR_SCALARS) {
5055                 int level = ndr_push_get_switch_value(ndr, r);
5056                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5057                 switch (level) {
5058                         case 1: {
5059                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5060                         break; }
5061
5062                         default:
5063                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5064                 }
5065         }
5066         if (ndr_flags & NDR_BUFFERS) {
5067                 int level = ndr_push_get_switch_value(ndr, r);
5068                 switch (level) {
5069                         case 1:
5070                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5071                         break;
5072
5073                         default:
5074                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5075                 }
5076         }
5077         return NDR_ERR_SUCCESS;
5078 }
5079
5080 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5081 {
5082         int level;
5083         int32_t _level;
5084         level = ndr_pull_get_switch_value(ndr, r);
5085         if (ndr_flags & NDR_SCALARS) {
5086                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5087                 if (_level != level) {
5088                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5089                 }
5090                 switch (level) {
5091                         case 1: {
5092                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5093                         break; }
5094
5095                         default:
5096                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5097                 }
5098         }
5099         if (ndr_flags & NDR_BUFFERS) {
5100                 switch (level) {
5101                         case 1:
5102                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5103                         break;
5104
5105                         default:
5106                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5107                 }
5108         }
5109         return NDR_ERR_SUCCESS;
5110 }
5111
5112 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5113 {
5114         int level;
5115         level = ndr_print_get_switch_value(ndr, r);
5116         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5117         switch (level) {
5118                 case 1:
5119                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5120                 break;
5121
5122                 default:
5123                         ndr_print_bad_level(ndr, name, level);
5124         }
5125 }
5126
5127 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5128 {
5129         if (ndr_flags & NDR_SCALARS) {
5130                 NDR_CHECK(ndr_push_align(ndr, 5));
5131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5134                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5135         }
5136         if (ndr_flags & NDR_BUFFERS) {
5137                 if (r->data) {
5138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5139                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5140                 }
5141         }
5142         return NDR_ERR_SUCCESS;
5143 }
5144
5145 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5146 {
5147         uint32_t _ptr_data;
5148         TALLOC_CTX *_mem_save_data_0;
5149         if (ndr_flags & NDR_SCALARS) {
5150                 NDR_CHECK(ndr_pull_align(ndr, 5));
5151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5154                 if (r->length > 0x00A00000) {
5155                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5156                 }
5157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5158                 if (_ptr_data) {
5159                         NDR_PULL_ALLOC(ndr, r->data);
5160                 } else {
5161                         r->data = NULL;
5162                 }
5163         }
5164         if (ndr_flags & NDR_BUFFERS) {
5165                 if (r->data) {
5166                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5167                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5168                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5169                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5170                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5172                 }
5173                 if (r->data) {
5174                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5175                 }
5176         }
5177         return NDR_ERR_SUCCESS;
5178 }
5179
5180 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5181 {
5182         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5183         ndr->depth++;
5184         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5185         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5186         ndr_print_uint32(ndr, "length", r->length);
5187         ndr_print_ptr(ndr, "data", r->data);
5188         ndr->depth++;
5189         if (r->data) {
5190                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5191         }
5192         ndr->depth--;
5193         ndr->depth--;
5194 }
5195
5196 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5197 {
5198         if (ndr_flags & NDR_SCALARS) {
5199                 int level = ndr_push_get_switch_value(ndr, r);
5200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5201                 switch (level) {
5202                         case 1: {
5203                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5204                         break; }
5205
5206                         default:
5207                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5208                 }
5209         }
5210         if (ndr_flags & NDR_BUFFERS) {
5211                 int level = ndr_push_get_switch_value(ndr, r);
5212                 switch (level) {
5213                         case 1:
5214                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5215                         break;
5216
5217                         default:
5218                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5219                 }
5220         }
5221         return NDR_ERR_SUCCESS;
5222 }
5223
5224 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5225 {
5226         int level;
5227         uint32_t _level;
5228         level = ndr_pull_get_switch_value(ndr, r);
5229         if (ndr_flags & NDR_SCALARS) {
5230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5231                 if (_level != level) {
5232                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5233                 }
5234                 switch (level) {
5235                         case 1: {
5236                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5237                         break; }
5238
5239                         default:
5240                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5241                 }
5242         }
5243         if (ndr_flags & NDR_BUFFERS) {
5244                 switch (level) {
5245                         case 1:
5246                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5247                         break;
5248
5249                         default:
5250                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5251                 }
5252         }
5253         return NDR_ERR_SUCCESS;
5254 }
5255
5256 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5257 {
5258         int level;
5259         level = ndr_print_get_switch_value(ndr, r);
5260         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5261         switch (level) {
5262                 case 1:
5263                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5264                 break;
5265
5266                 default:
5267                         ndr_print_bad_level(ndr, name, level);
5268         }
5269 }
5270
5271 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5272 {
5273         if (ndr_flags & NDR_SCALARS) {
5274                 NDR_CHECK(ndr_push_align(ndr, 8));
5275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5277                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5278                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5279                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5280                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5281                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5282                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5283                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5284                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5285                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5286         }
5287         if (ndr_flags & NDR_BUFFERS) {
5288                 if (r->data1) {
5289                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5290                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5291                 }
5292                 if (r->data2) {
5293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5294                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5295                 }
5296         }
5297         return NDR_ERR_SUCCESS;
5298 }
5299
5300 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5301 {
5302         uint32_t _ptr_data1;
5303         TALLOC_CTX *_mem_save_data1_0;
5304         uint32_t _ptr_data2;
5305         TALLOC_CTX *_mem_save_data2_0;
5306         if (ndr_flags & NDR_SCALARS) {
5307                 NDR_CHECK(ndr_pull_align(ndr, 8));
5308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5309                 if (r->length1 > 0x00A00000) {
5310                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5311                 }
5312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5313                 if (r->length2 > 0x00A00000) {
5314                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5315                 }
5316                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5317                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5318                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5319                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5320                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5321                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5322                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5323                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5324                 if (_ptr_data1) {
5325                         NDR_PULL_ALLOC(ndr, r->data1);
5326                 } else {
5327                         r->data1 = NULL;
5328                 }
5329                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5330                 if (_ptr_data2) {
5331                         NDR_PULL_ALLOC(ndr, r->data2);
5332                 } else {
5333                         r->data2 = NULL;
5334                 }
5335         }
5336         if (ndr_flags & NDR_BUFFERS) {
5337                 if (r->data1) {
5338                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5339                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5341                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5342                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5344                 }
5345                 if (r->data2) {
5346                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5347                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5349                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5350                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5352                 }
5353                 if (r->data1) {
5354                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5355                 }
5356                 if (r->data2) {
5357                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5358                 }
5359         }
5360         return NDR_ERR_SUCCESS;
5361 }
5362
5363 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5364 {
5365         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5366         ndr->depth++;
5367         ndr_print_uint32(ndr, "length1", r->length1);
5368         ndr_print_uint32(ndr, "length2", r->length2);
5369         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5370         ndr_print_NTTIME(ndr, "time2", r->time2);
5371         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5372         ndr_print_NTTIME(ndr, "time4", r->time4);
5373         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5374         ndr_print_NTTIME(ndr, "time6", r->time6);
5375         ndr_print_NTSTATUS(ndr, "status", r->status);
5376         ndr_print_ptr(ndr, "data1", r->data1);
5377         ndr->depth++;
5378         if (r->data1) {
5379                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5380         }
5381         ndr->depth--;
5382         ndr_print_ptr(ndr, "data2", r->data2);
5383         ndr->depth++;
5384         if (r->data2) {
5385                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5386         }
5387         ndr->depth--;
5388         ndr->depth--;
5389 }
5390
5391 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5392 {
5393         if (ndr_flags & NDR_SCALARS) {
5394                 int level = ndr_push_get_switch_value(ndr, r);
5395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5396                 switch (level) {
5397                         case 1: {
5398                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5399                         break; }
5400
5401                         default:
5402                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5403                 }
5404         }
5405         if (ndr_flags & NDR_BUFFERS) {
5406                 int level = ndr_push_get_switch_value(ndr, r);
5407                 switch (level) {
5408                         case 1:
5409                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5410                         break;
5411
5412                         default:
5413                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5414                 }
5415         }
5416         return NDR_ERR_SUCCESS;
5417 }
5418
5419 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5420 {
5421         int level;
5422         uint32_t _level;
5423         level = ndr_pull_get_switch_value(ndr, r);
5424         if (ndr_flags & NDR_SCALARS) {
5425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5426                 if (_level != level) {
5427                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5428                 }
5429                 switch (level) {
5430                         case 1: {
5431                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5432                         break; }
5433
5434                         default:
5435                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5436                 }
5437         }
5438         if (ndr_flags & NDR_BUFFERS) {
5439                 switch (level) {
5440                         case 1:
5441                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5442                         break;
5443
5444                         default:
5445                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5446                 }
5447         }
5448         return NDR_ERR_SUCCESS;
5449 }
5450
5451 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5452 {
5453         int level;
5454         level = ndr_print_get_switch_value(ndr, r);
5455         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5456         switch (level) {
5457                 case 1:
5458                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5459                 break;
5460
5461                 default:
5462                         ndr_print_bad_level(ndr, name, level);
5463         }
5464 }
5465
5466 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5467 {
5468         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5469         return NDR_ERR_SUCCESS;
5470 }
5471
5472 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5473 {
5474         uint32_t v;
5475         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5476         *r = v;
5477         return NDR_ERR_SUCCESS;
5478 }
5479
5480 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5481 {
5482         const char *val = NULL;
5483
5484         switch (r) {
5485                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5486                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5487                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5488                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5489                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5490                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5491                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5492                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5493         }
5494         ndr_print_enum(ndr, name, "ENUM", val, r);
5495 }
5496
5497 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5498 {
5499         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5500         return NDR_ERR_SUCCESS;
5501 }
5502
5503 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5504 {
5505         uint32_t v;
5506         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5507         *r = v;
5508         return NDR_ERR_SUCCESS;
5509 }
5510
5511 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5512 {
5513         const char *val = NULL;
5514
5515         switch (r) {
5516                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5517                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5518                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5519                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5520                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5521         }
5522         ndr_print_enum(ndr, name, "ENUM", val, r);
5523 }
5524
5525 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5526 {
5527         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5528         return NDR_ERR_SUCCESS;
5529 }
5530
5531 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5532 {
5533         uint32_t v;
5534         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5535         *r = v;
5536         return NDR_ERR_SUCCESS;
5537 }
5538
5539 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5540 {
5541         const char *val = NULL;
5542
5543         switch (r) {
5544                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5545                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5546                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5547                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5548                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5549                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5550                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5551                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5552                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5553                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5554                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5555         }
5556         ndr_print_enum(ndr, name, "ENUM", val, r);
5557 }
5558
5559 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5560 {
5561         if (ndr_flags & NDR_SCALARS) {
5562                 NDR_CHECK(ndr_push_align(ndr, 5));
5563                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5564         }
5565         if (ndr_flags & NDR_BUFFERS) {
5566                 if (r->str) {
5567                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5569                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5570                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5571                 }
5572         }
5573         return NDR_ERR_SUCCESS;
5574 }
5575
5576 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5577 {
5578         uint32_t _ptr_str;
5579         TALLOC_CTX *_mem_save_str_0;
5580         if (ndr_flags & NDR_SCALARS) {
5581                 NDR_CHECK(ndr_pull_align(ndr, 5));
5582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5583                 if (_ptr_str) {
5584                         NDR_PULL_ALLOC(ndr, r->str);
5585                 } else {
5586                         r->str = NULL;
5587                 }
5588         }
5589         if (ndr_flags & NDR_BUFFERS) {
5590                 if (r->str) {
5591                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5592                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5593                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5594                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5595                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5596                                 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));
5597                         }
5598                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5599                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5600                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5601                 }
5602         }
5603         return NDR_ERR_SUCCESS;
5604 }
5605
5606 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5607 {
5608         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5609         ndr->depth++;
5610         ndr_print_ptr(ndr, "str", r->str);
5611         ndr->depth++;
5612         if (r->str) {
5613                 ndr_print_string(ndr, "str", r->str);
5614         }
5615         ndr->depth--;
5616         ndr->depth--;
5617 }
5618
5619 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5620 {
5621         uint32_t cntr_names_1;
5622         if (ndr_flags & NDR_SCALARS) {
5623                 NDR_CHECK(ndr_push_align(ndr, 5));
5624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5626                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5627                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5628                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5630                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5631         }
5632         if (ndr_flags & NDR_BUFFERS) {
5633                 if (r->names) {
5634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5635                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5636                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5637                         }
5638                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5639                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5640                         }
5641                 }
5642         }
5643         return NDR_ERR_SUCCESS;
5644 }
5645
5646 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5647 {
5648         uint32_t _ptr_names;
5649         uint32_t cntr_names_1;
5650         TALLOC_CTX *_mem_save_names_0;
5651         TALLOC_CTX *_mem_save_names_1;
5652         if (ndr_flags & NDR_SCALARS) {
5653                 NDR_CHECK(ndr_pull_align(ndr, 5));
5654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5656                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5657                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5658                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5660                 if (r->count < 1 || r->count > 10000) {
5661                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5662                 }
5663                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5664                 if (_ptr_names) {
5665                         NDR_PULL_ALLOC(ndr, r->names);
5666                 } else {
5667                         r->names = NULL;
5668                 }
5669         }
5670         if (ndr_flags & NDR_BUFFERS) {
5671                 if (r->names) {
5672                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5673                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5674                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5675                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5676                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5677                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5678                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5679                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5680                         }
5681                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5682                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5683                         }
5684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5686                 }
5687                 if (r->names) {
5688                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5689                 }
5690         }
5691         return NDR_ERR_SUCCESS;
5692 }
5693
5694 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5695 {
5696         uint32_t cntr_names_1;
5697         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5698         ndr->depth++;
5699         ndr_print_uint32(ndr, "codepage", r->codepage);
5700         ndr_print_uint32(ndr, "language", r->language);
5701         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5702         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5703         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5704         ndr_print_uint32(ndr, "count", r->count);
5705         ndr_print_ptr(ndr, "names", r->names);
5706         ndr->depth++;
5707         if (r->names) {
5708                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5709                 ndr->depth++;
5710                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5711                         char *idx_1=NULL;
5712                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5713                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5714                                 free(idx_1);
5715                         }
5716                 }
5717                 ndr->depth--;
5718         }
5719         ndr->depth--;
5720         ndr->depth--;
5721 }
5722
5723 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5724 {
5725         if (ndr_flags & NDR_SCALARS) {
5726                 int level = ndr_push_get_switch_value(ndr, r);
5727                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5728                 switch (level) {
5729                         case 1: {
5730                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5731                         break; }
5732
5733                         default:
5734                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5735                 }
5736         }
5737         if (ndr_flags & NDR_BUFFERS) {
5738                 int level = ndr_push_get_switch_value(ndr, r);
5739                 switch (level) {
5740                         case 1:
5741                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5742                         break;
5743
5744                         default:
5745                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5746                 }
5747         }
5748         return NDR_ERR_SUCCESS;
5749 }
5750
5751 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5752 {
5753         int level;
5754         int32_t _level;
5755         level = ndr_pull_get_switch_value(ndr, r);
5756         if (ndr_flags & NDR_SCALARS) {
5757                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5758                 if (_level != level) {
5759                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5760                 }
5761                 switch (level) {
5762                         case 1: {
5763                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5764                         break; }
5765
5766                         default:
5767                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5768                 }
5769         }
5770         if (ndr_flags & NDR_BUFFERS) {
5771                 switch (level) {
5772                         case 1:
5773                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5774                         break;
5775
5776                         default:
5777                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5778                 }
5779         }
5780         return NDR_ERR_SUCCESS;
5781 }
5782
5783 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5784 {
5785         int level;
5786         level = ndr_print_get_switch_value(ndr, r);
5787         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5788         switch (level) {
5789                 case 1:
5790                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5791                 break;
5792
5793                 default:
5794                         ndr_print_bad_level(ndr, name, level);
5795         }
5796 }
5797
5798 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5799 {
5800         if (ndr_flags & NDR_SCALARS) {
5801                 NDR_CHECK(ndr_push_align(ndr, 5));
5802                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5805         }
5806         if (ndr_flags & NDR_BUFFERS) {
5807                 if (r->dns_domain_name) {
5808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5811                         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));
5812                 }
5813                 if (r->result_name) {
5814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5816                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5817                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5818                 }
5819         }
5820         return NDR_ERR_SUCCESS;
5821 }
5822
5823 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5824 {
5825         uint32_t _ptr_dns_domain_name;
5826         TALLOC_CTX *_mem_save_dns_domain_name_0;
5827         uint32_t _ptr_result_name;
5828         TALLOC_CTX *_mem_save_result_name_0;
5829         if (ndr_flags & NDR_SCALARS) {
5830                 NDR_CHECK(ndr_pull_align(ndr, 5));
5831                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5832                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5833                 if (_ptr_dns_domain_name) {
5834                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5835                 } else {
5836                         r->dns_domain_name = NULL;
5837                 }
5838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5839                 if (_ptr_result_name) {
5840                         NDR_PULL_ALLOC(ndr, r->result_name);
5841                 } else {
5842                         r->result_name = NULL;
5843                 }
5844         }
5845         if (ndr_flags & NDR_BUFFERS) {
5846                 if (r->dns_domain_name) {
5847                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5848                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5851                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5852                                 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));
5853                         }
5854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5855                         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));
5856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5857                 }
5858                 if (r->result_name) {
5859                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5860                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5863                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5864                                 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));
5865                         }
5866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5869                 }
5870         }
5871         return NDR_ERR_SUCCESS;
5872 }
5873
5874 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5875 {
5876         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5877         ndr->depth++;
5878         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5879         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5880         ndr->depth++;
5881         if (r->dns_domain_name) {
5882                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5883         }
5884         ndr->depth--;
5885         ndr_print_ptr(ndr, "result_name", r->result_name);
5886         ndr->depth++;
5887         if (r->result_name) {
5888                 ndr_print_string(ndr, "result_name", r->result_name);
5889         }
5890         ndr->depth--;
5891         ndr->depth--;
5892 }
5893
5894 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5895 {
5896         uint32_t cntr_array_1;
5897         if (ndr_flags & NDR_SCALARS) {
5898                 NDR_CHECK(ndr_push_align(ndr, 5));
5899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5901         }
5902         if (ndr_flags & NDR_BUFFERS) {
5903                 if (r->array) {
5904                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5905                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5906                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5907                         }
5908                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5909                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5910                         }
5911                 }
5912         }
5913         return NDR_ERR_SUCCESS;
5914 }
5915
5916 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
5917 {
5918         uint32_t _ptr_array;
5919         uint32_t cntr_array_1;
5920         TALLOC_CTX *_mem_save_array_0;
5921         TALLOC_CTX *_mem_save_array_1;
5922         if (ndr_flags & NDR_SCALARS) {
5923                 NDR_CHECK(ndr_pull_align(ndr, 5));
5924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5926                 if (_ptr_array) {
5927                         NDR_PULL_ALLOC(ndr, r->array);
5928                 } else {
5929                         r->array = NULL;
5930                 }
5931         }
5932         if (ndr_flags & NDR_BUFFERS) {
5933                 if (r->array) {
5934                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5935                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5936                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5937                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5938                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5939                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5940                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5941                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5942                         }
5943                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5944                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5945                         }
5946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5948                 }
5949                 if (r->array) {
5950                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5951                 }
5952         }
5953         return NDR_ERR_SUCCESS;
5954 }
5955
5956 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
5957 {
5958         uint32_t cntr_array_1;
5959         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
5960         ndr->depth++;
5961         ndr_print_uint32(ndr, "count", r->count);
5962         ndr_print_ptr(ndr, "array", r->array);
5963         ndr->depth++;
5964         if (r->array) {
5965                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5966                 ndr->depth++;
5967                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5968                         char *idx_1=NULL;
5969                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5970                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
5971                                 free(idx_1);
5972                         }
5973                 }
5974                 ndr->depth--;
5975         }
5976         ndr->depth--;
5977         ndr->depth--;
5978 }
5979
5980 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
5981 {
5982         if (ndr_flags & NDR_SCALARS) {
5983                 int level = ndr_push_get_switch_value(ndr, r);
5984                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5985                 switch (level) {
5986                         case 1: {
5987                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5988                         break; }
5989
5990                         default:
5991                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5992                 }
5993         }
5994         if (ndr_flags & NDR_BUFFERS) {
5995                 int level = ndr_push_get_switch_value(ndr, r);
5996                 switch (level) {
5997                         case 1:
5998                                 if (r->ctr1) {
5999                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6000                                 }
6001                         break;
6002
6003                         default:
6004                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6005                 }
6006         }
6007         return NDR_ERR_SUCCESS;
6008 }
6009
6010 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6011 {
6012         int level;
6013         int32_t _level;
6014         TALLOC_CTX *_mem_save_ctr1_0;
6015         level = ndr_pull_get_switch_value(ndr, r);
6016         if (ndr_flags & NDR_SCALARS) {
6017                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6018                 if (_level != level) {
6019                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6020                 }
6021                 switch (level) {
6022                         case 1: {
6023                                 uint32_t _ptr_ctr1;
6024                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6025                                 if (_ptr_ctr1) {
6026                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6027                                 } else {
6028                                         r->ctr1 = NULL;
6029                                 }
6030                         break; }
6031
6032                         default:
6033                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6034                 }
6035         }
6036         if (ndr_flags & NDR_BUFFERS) {
6037                 switch (level) {
6038                         case 1:
6039                                 if (r->ctr1) {
6040                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6041                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6042                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6043                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6044                                 }
6045                         break;
6046
6047                         default:
6048                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6049                 }
6050         }
6051         return NDR_ERR_SUCCESS;
6052 }
6053
6054 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6055 {
6056         int level;
6057         level = ndr_print_get_switch_value(ndr, r);
6058         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6059         switch (level) {
6060                 case 1:
6061                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6062                         ndr->depth++;
6063                         if (r->ctr1) {
6064                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6065                         }
6066                         ndr->depth--;
6067                 break;
6068
6069                 default:
6070                         ndr_print_bad_level(ndr, name, level);
6071         }
6072 }
6073
6074 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6075 {
6076         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6077         return NDR_ERR_SUCCESS;
6078 }
6079
6080 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6081 {
6082         uint32_t v;
6083         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6084         *r = v;
6085         return NDR_ERR_SUCCESS;
6086 }
6087
6088 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6089 {
6090         const char *val = NULL;
6091
6092         switch (r) {
6093                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6094                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6095                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6096         }
6097         ndr_print_enum(ndr, name, "ENUM", val, r);
6098 }
6099
6100 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6101 {
6102         uint32_t cntr_spn_names_1;
6103         if (ndr_flags & NDR_SCALARS) {
6104                 NDR_CHECK(ndr_push_align(ndr, 5));
6105                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6110         }
6111         if (ndr_flags & NDR_BUFFERS) {
6112                 if (r->object_dn) {
6113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6115                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6116                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6117                 }
6118                 if (r->spn_names) {
6119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6120                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6121                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6122                         }
6123                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6124                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6125                         }
6126                 }
6127         }
6128         return NDR_ERR_SUCCESS;
6129 }
6130
6131 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6132 {
6133         uint32_t _ptr_object_dn;
6134         TALLOC_CTX *_mem_save_object_dn_0;
6135         uint32_t _ptr_spn_names;
6136         uint32_t cntr_spn_names_1;
6137         TALLOC_CTX *_mem_save_spn_names_0;
6138         TALLOC_CTX *_mem_save_spn_names_1;
6139         if (ndr_flags & NDR_SCALARS) {
6140                 NDR_CHECK(ndr_pull_align(ndr, 5));
6141                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6143                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6144                 if (_ptr_object_dn) {
6145                         NDR_PULL_ALLOC(ndr, r->object_dn);
6146                 } else {
6147                         r->object_dn = NULL;
6148                 }
6149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6150                 if (r->count > 10000) {
6151                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6152                 }
6153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6154                 if (_ptr_spn_names) {
6155                         NDR_PULL_ALLOC(ndr, r->spn_names);
6156                 } else {
6157                         r->spn_names = NULL;
6158                 }
6159         }
6160         if (ndr_flags & NDR_BUFFERS) {
6161                 if (r->object_dn) {
6162                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6163                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6166                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6167                                 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));
6168                         }
6169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6172                 }
6173                 if (r->spn_names) {
6174                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6175                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6177                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6178                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6179                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6180                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6181                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6182                         }
6183                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6184                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6185                         }
6186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6188                 }
6189                 if (r->spn_names) {
6190                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6191                 }
6192         }
6193         return NDR_ERR_SUCCESS;
6194 }
6195
6196 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6197 {
6198         uint32_t cntr_spn_names_1;
6199         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6200         ndr->depth++;
6201         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6202         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6203         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6204         ndr->depth++;
6205         if (r->object_dn) {
6206                 ndr_print_string(ndr, "object_dn", r->object_dn);
6207         }
6208         ndr->depth--;
6209         ndr_print_uint32(ndr, "count", r->count);
6210         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6211         ndr->depth++;
6212         if (r->spn_names) {
6213                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6214                 ndr->depth++;
6215                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6216                         char *idx_1=NULL;
6217                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6218                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6219                                 free(idx_1);
6220                         }
6221                 }
6222                 ndr->depth--;
6223         }
6224         ndr->depth--;
6225         ndr->depth--;
6226 }
6227
6228 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6229 {
6230         if (ndr_flags & NDR_SCALARS) {
6231                 int level = ndr_push_get_switch_value(ndr, r);
6232                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6233                 switch (level) {
6234                         case 1: {
6235                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6236                         break; }
6237
6238                         default:
6239                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6240                 }
6241         }
6242         if (ndr_flags & NDR_BUFFERS) {
6243                 int level = ndr_push_get_switch_value(ndr, r);
6244                 switch (level) {
6245                         case 1:
6246                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6247                         break;
6248
6249                         default:
6250                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6251                 }
6252         }
6253         return NDR_ERR_SUCCESS;
6254 }
6255
6256 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6257 {
6258         int level;
6259         int32_t _level;
6260         level = ndr_pull_get_switch_value(ndr, r);
6261         if (ndr_flags & NDR_SCALARS) {
6262                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6263                 if (_level != level) {
6264                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6265                 }
6266                 switch (level) {
6267                         case 1: {
6268                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6269                         break; }
6270
6271                         default:
6272                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6273                 }
6274         }
6275         if (ndr_flags & NDR_BUFFERS) {
6276                 switch (level) {
6277                         case 1:
6278                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6279                         break;
6280
6281                         default:
6282                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6283                 }
6284         }
6285         return NDR_ERR_SUCCESS;
6286 }
6287
6288 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6289 {
6290         int level;
6291         level = ndr_print_get_switch_value(ndr, r);
6292         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6293         switch (level) {
6294                 case 1:
6295                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6296                 break;
6297
6298                 default:
6299                         ndr_print_bad_level(ndr, name, level);
6300         }
6301 }
6302
6303 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6304 {
6305         if (ndr_flags & NDR_SCALARS) {
6306                 NDR_CHECK(ndr_push_align(ndr, 4));
6307                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6308         }
6309         if (ndr_flags & NDR_BUFFERS) {
6310         }
6311         return NDR_ERR_SUCCESS;
6312 }
6313
6314 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6315 {
6316         if (ndr_flags & NDR_SCALARS) {
6317                 NDR_CHECK(ndr_pull_align(ndr, 4));
6318                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6319         }
6320         if (ndr_flags & NDR_BUFFERS) {
6321         }
6322         return NDR_ERR_SUCCESS;
6323 }
6324
6325 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6326 {
6327         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6328         ndr->depth++;
6329         ndr_print_WERROR(ndr, "status", r->status);
6330         ndr->depth--;
6331 }
6332
6333 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6334 {
6335         if (ndr_flags & NDR_SCALARS) {
6336                 int level = ndr_push_get_switch_value(ndr, r);
6337                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6338                 switch (level) {
6339                         case 1: {
6340                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6341                         break; }
6342
6343                         default:
6344                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6345                 }
6346         }
6347         if (ndr_flags & NDR_BUFFERS) {
6348                 int level = ndr_push_get_switch_value(ndr, r);
6349                 switch (level) {
6350                         case 1:
6351                         break;
6352
6353                         default:
6354                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6355                 }
6356         }
6357         return NDR_ERR_SUCCESS;
6358 }
6359
6360 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6361 {
6362         int level;
6363         int32_t _level;
6364         level = ndr_pull_get_switch_value(ndr, r);
6365         if (ndr_flags & NDR_SCALARS) {
6366                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6367                 if (_level != level) {
6368                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6369                 }
6370                 switch (level) {
6371                         case 1: {
6372                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6373                         break; }
6374
6375                         default:
6376                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6377                 }
6378         }
6379         if (ndr_flags & NDR_BUFFERS) {
6380                 switch (level) {
6381                         case 1:
6382                         break;
6383
6384                         default:
6385                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6386                 }
6387         }
6388         return NDR_ERR_SUCCESS;
6389 }
6390
6391 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6392 {
6393         int level;
6394         level = ndr_print_get_switch_value(ndr, r);
6395         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6396         switch (level) {
6397                 case 1:
6398                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6399                 break;
6400
6401                 default:
6402                         ndr_print_bad_level(ndr, name, level);
6403         }
6404 }
6405
6406 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6407 {
6408         if (ndr_flags & NDR_SCALARS) {
6409                 NDR_CHECK(ndr_push_align(ndr, 5));
6410                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6413         }
6414         if (ndr_flags & NDR_BUFFERS) {
6415                 if (r->server_dn) {
6416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6419                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6420                 }
6421                 if (r->domain_dn) {
6422                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6425                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6426                 }
6427         }
6428         return NDR_ERR_SUCCESS;
6429 }
6430
6431 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6432 {
6433         uint32_t _ptr_server_dn;
6434         TALLOC_CTX *_mem_save_server_dn_0;
6435         uint32_t _ptr_domain_dn;
6436         TALLOC_CTX *_mem_save_domain_dn_0;
6437         if (ndr_flags & NDR_SCALARS) {
6438                 NDR_CHECK(ndr_pull_align(ndr, 5));
6439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6440                 if (_ptr_server_dn) {
6441                         NDR_PULL_ALLOC(ndr, r->server_dn);
6442                 } else {
6443                         r->server_dn = NULL;
6444                 }
6445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6446                 if (_ptr_domain_dn) {
6447                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6448                 } else {
6449                         r->domain_dn = NULL;
6450                 }
6451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6452         }
6453         if (ndr_flags & NDR_BUFFERS) {
6454                 if (r->server_dn) {
6455                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6456                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6457                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6458                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6459                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6460                                 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));
6461                         }
6462                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6463                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6464                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6465                 }
6466                 if (r->domain_dn) {
6467                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6468                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6469                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6470                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6471                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6472                                 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));
6473                         }
6474                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6475                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6477                 }
6478         }
6479         return NDR_ERR_SUCCESS;
6480 }
6481
6482 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6483 {
6484         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6485         ndr->depth++;
6486         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6487         ndr->depth++;
6488         if (r->server_dn) {
6489                 ndr_print_string(ndr, "server_dn", r->server_dn);
6490         }
6491         ndr->depth--;
6492         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6493         ndr->depth++;
6494         if (r->domain_dn) {
6495                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6496         }
6497         ndr->depth--;
6498         ndr_print_uint32(ndr, "commit", r->commit);
6499         ndr->depth--;
6500 }
6501
6502 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6503 {
6504         if (ndr_flags & NDR_SCALARS) {
6505                 int level = ndr_push_get_switch_value(ndr, r);
6506                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6507                 switch (level) {
6508                         case 1: {
6509                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6510                         break; }
6511
6512                         default:
6513                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6514                 }
6515         }
6516         if (ndr_flags & NDR_BUFFERS) {
6517                 int level = ndr_push_get_switch_value(ndr, r);
6518                 switch (level) {
6519                         case 1:
6520                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6521                         break;
6522
6523                         default:
6524                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6525                 }
6526         }
6527         return NDR_ERR_SUCCESS;
6528 }
6529
6530 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6531 {
6532         int level;
6533         int32_t _level;
6534         level = ndr_pull_get_switch_value(ndr, r);
6535         if (ndr_flags & NDR_SCALARS) {
6536                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6537                 if (_level != level) {
6538                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6539                 }
6540                 switch (level) {
6541                         case 1: {
6542                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6543                         break; }
6544
6545                         default:
6546                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6547                 }
6548         }
6549         if (ndr_flags & NDR_BUFFERS) {
6550                 switch (level) {
6551                         case 1:
6552                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6553                         break;
6554
6555                         default:
6556                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6557                 }
6558         }
6559         return NDR_ERR_SUCCESS;
6560 }
6561
6562 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6563 {
6564         int level;
6565         level = ndr_print_get_switch_value(ndr, r);
6566         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6567         switch (level) {
6568                 case 1:
6569                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6570                 break;
6571
6572                 default:
6573                         ndr_print_bad_level(ndr, name, level);
6574         }
6575 }
6576
6577 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6578 {
6579         if (ndr_flags & NDR_SCALARS) {
6580                 NDR_CHECK(ndr_push_align(ndr, 4));
6581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6582         }
6583         if (ndr_flags & NDR_BUFFERS) {
6584         }
6585         return NDR_ERR_SUCCESS;
6586 }
6587
6588 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6589 {
6590         if (ndr_flags & NDR_SCALARS) {
6591                 NDR_CHECK(ndr_pull_align(ndr, 4));
6592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6593         }
6594         if (ndr_flags & NDR_BUFFERS) {
6595         }
6596         return NDR_ERR_SUCCESS;
6597 }
6598
6599 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6600 {
6601         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6602         ndr->depth++;
6603         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6604         ndr->depth--;
6605 }
6606
6607 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6608 {
6609         if (ndr_flags & NDR_SCALARS) {
6610                 int level = ndr_push_get_switch_value(ndr, r);
6611                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6612                 switch (level) {
6613                         case 1: {
6614                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6615                         break; }
6616
6617                         default:
6618                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6619                 }
6620         }
6621         if (ndr_flags & NDR_BUFFERS) {
6622                 int level = ndr_push_get_switch_value(ndr, r);
6623                 switch (level) {
6624                         case 1:
6625                         break;
6626
6627                         default:
6628                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6629                 }
6630         }
6631         return NDR_ERR_SUCCESS;
6632 }
6633
6634 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6635 {
6636         int level;
6637         int32_t _level;
6638         level = ndr_pull_get_switch_value(ndr, r);
6639         if (ndr_flags & NDR_SCALARS) {
6640                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6641                 if (_level != level) {
6642                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6643                 }
6644                 switch (level) {
6645                         case 1: {
6646                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6647                         break; }
6648
6649                         default:
6650                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6651                 }
6652         }
6653         if (ndr_flags & NDR_BUFFERS) {
6654                 switch (level) {
6655                         case 1:
6656                         break;
6657
6658                         default:
6659                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6660                 }
6661         }
6662         return NDR_ERR_SUCCESS;
6663 }
6664
6665 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6666 {
6667         int level;
6668         level = ndr_print_get_switch_value(ndr, r);
6669         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6670         switch (level) {
6671                 case 1:
6672                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6673                 break;
6674
6675                 default:
6676                         ndr_print_bad_level(ndr, name, level);
6677         }
6678 }
6679
6680 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6681 {
6682         if (ndr_flags & NDR_SCALARS) {
6683                 NDR_CHECK(ndr_push_align(ndr, 5));
6684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6685                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6686         }
6687         if (ndr_flags & NDR_BUFFERS) {
6688                 if (r->domain_name) {
6689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6691                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6692                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6693                 }
6694         }
6695         return NDR_ERR_SUCCESS;
6696 }
6697
6698 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6699 {
6700         uint32_t _ptr_domain_name;
6701         TALLOC_CTX *_mem_save_domain_name_0;
6702         if (ndr_flags & NDR_SCALARS) {
6703                 NDR_CHECK(ndr_pull_align(ndr, 5));
6704                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6705                 if (_ptr_domain_name) {
6706                         NDR_PULL_ALLOC(ndr, r->domain_name);
6707                 } else {
6708                         r->domain_name = NULL;
6709                 }
6710                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6711         }
6712         if (ndr_flags & NDR_BUFFERS) {
6713                 if (r->domain_name) {
6714                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6715                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6717                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6718                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6719                                 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));
6720                         }
6721                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6722                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6723                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6724                 }
6725         }
6726         return NDR_ERR_SUCCESS;
6727 }
6728
6729 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6730 {
6731         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6732         ndr->depth++;
6733         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6734         ndr->depth++;
6735         if (r->domain_name) {
6736                 ndr_print_string(ndr, "domain_name", r->domain_name);
6737         }
6738         ndr->depth--;
6739         ndr_print_int32(ndr, "level", r->level);
6740         ndr->depth--;
6741 }
6742
6743 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6744 {
6745         if (ndr_flags & NDR_SCALARS) {
6746                 int level = ndr_push_get_switch_value(ndr, r);
6747                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6748                 switch (level) {
6749                         case 1: {
6750                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6751                         break; }
6752
6753                         default:
6754                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6755                 }
6756         }
6757         if (ndr_flags & NDR_BUFFERS) {
6758                 int level = ndr_push_get_switch_value(ndr, r);
6759                 switch (level) {
6760                         case 1:
6761                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6762                         break;
6763
6764                         default:
6765                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6766                 }
6767         }
6768         return NDR_ERR_SUCCESS;
6769 }
6770
6771 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6772 {
6773         int level;
6774         int32_t _level;
6775         level = ndr_pull_get_switch_value(ndr, r);
6776         if (ndr_flags & NDR_SCALARS) {
6777                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6778                 if (_level != level) {
6779                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6780                 }
6781                 switch (level) {
6782                         case 1: {
6783                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6784                         break; }
6785
6786                         default:
6787                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6788                 }
6789         }
6790         if (ndr_flags & NDR_BUFFERS) {
6791                 switch (level) {
6792                         case 1:
6793                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6794                         break;
6795
6796                         default:
6797                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6798                 }
6799         }
6800         return NDR_ERR_SUCCESS;
6801 }
6802
6803 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6804 {
6805         int level;
6806         level = ndr_print_get_switch_value(ndr, r);
6807         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6808         switch (level) {
6809                 case 1:
6810                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6811                 break;
6812
6813                 default:
6814                         ndr_print_bad_level(ndr, name, level);
6815         }
6816 }
6817
6818 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6819 {
6820         if (ndr_flags & NDR_SCALARS) {
6821                 NDR_CHECK(ndr_push_align(ndr, 5));
6822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6823                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6824                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6825                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6826                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6827                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6829         }
6830         if (ndr_flags & NDR_BUFFERS) {
6831                 if (r->netbios_name) {
6832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6835                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6836                 }
6837                 if (r->dns_name) {
6838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6841                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6842                 }
6843                 if (r->site_name) {
6844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6848                 }
6849                 if (r->computer_dn) {
6850                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6853                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6854                 }
6855                 if (r->server_dn) {
6856                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6857                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6859                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6860                 }
6861         }
6862         return NDR_ERR_SUCCESS;
6863 }
6864
6865 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6866 {
6867         uint32_t _ptr_netbios_name;
6868         TALLOC_CTX *_mem_save_netbios_name_0;
6869         uint32_t _ptr_dns_name;
6870         TALLOC_CTX *_mem_save_dns_name_0;
6871         uint32_t _ptr_site_name;
6872         TALLOC_CTX *_mem_save_site_name_0;
6873         uint32_t _ptr_computer_dn;
6874         TALLOC_CTX *_mem_save_computer_dn_0;
6875         uint32_t _ptr_server_dn;
6876         TALLOC_CTX *_mem_save_server_dn_0;
6877         if (ndr_flags & NDR_SCALARS) {
6878                 NDR_CHECK(ndr_pull_align(ndr, 5));
6879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6880                 if (_ptr_netbios_name) {
6881                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6882                 } else {
6883                         r->netbios_name = NULL;
6884                 }
6885                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6886                 if (_ptr_dns_name) {
6887                         NDR_PULL_ALLOC(ndr, r->dns_name);
6888                 } else {
6889                         r->dns_name = NULL;
6890                 }
6891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6892                 if (_ptr_site_name) {
6893                         NDR_PULL_ALLOC(ndr, r->site_name);
6894                 } else {
6895                         r->site_name = NULL;
6896                 }
6897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6898                 if (_ptr_computer_dn) {
6899                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6900                 } else {
6901                         r->computer_dn = NULL;
6902                 }
6903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6904                 if (_ptr_server_dn) {
6905                         NDR_PULL_ALLOC(ndr, r->server_dn);
6906                 } else {
6907                         r->server_dn = NULL;
6908                 }
6909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
6910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
6911         }
6912         if (ndr_flags & NDR_BUFFERS) {
6913                 if (r->netbios_name) {
6914                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6915                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
6916                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
6917                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
6918                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
6919                                 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));
6920                         }
6921                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
6922                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
6923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
6924                 }
6925                 if (r->dns_name) {
6926                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6927                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
6928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
6929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
6930                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
6931                                 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));
6932                         }
6933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
6934                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
6935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
6936                 }
6937                 if (r->site_name) {
6938                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6939                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
6940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
6941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
6942                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
6943                                 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));
6944                         }
6945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
6946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
6947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
6948                 }
6949                 if (r->computer_dn) {
6950                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6951                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
6952                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
6953                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
6954                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
6955                                 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));
6956                         }
6957                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
6958                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
6959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
6960                 }
6961                 if (r->server_dn) {
6962                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6963                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6965                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6966                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6967                                 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));
6968                         }
6969                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6970                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6972                 }
6973         }
6974         return NDR_ERR_SUCCESS;
6975 }
6976
6977 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
6978 {
6979         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
6980         ndr->depth++;
6981         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
6982         ndr->depth++;
6983         if (r->netbios_name) {
6984                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
6985         }
6986         ndr->depth--;
6987         ndr_print_ptr(ndr, "dns_name", r->dns_name);
6988         ndr->depth++;
6989         if (r->dns_name) {
6990                 ndr_print_string(ndr, "dns_name", r->dns_name);
6991         }
6992         ndr->depth--;
6993         ndr_print_ptr(ndr, "site_name", r->site_name);
6994         ndr->depth++;
6995         if (r->site_name) {
6996                 ndr_print_string(ndr, "site_name", r->site_name);
6997         }
6998         ndr->depth--;
6999         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7000         ndr->depth++;
7001         if (r->computer_dn) {
7002                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7003         }
7004         ndr->depth--;
7005         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7006         ndr->depth++;
7007         if (r->server_dn) {
7008                 ndr_print_string(ndr, "server_dn", r->server_dn);
7009         }
7010         ndr->depth--;
7011         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7012         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7013         ndr->depth--;
7014 }
7015
7016 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7017 {
7018         uint32_t cntr_array_1;
7019         if (ndr_flags & NDR_SCALARS) {
7020                 NDR_CHECK(ndr_push_align(ndr, 5));
7021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7023         }
7024         if (ndr_flags & NDR_BUFFERS) {
7025                 if (r->array) {
7026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7027                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7028                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7029                         }
7030                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7031                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7032                         }
7033                 }
7034         }
7035         return NDR_ERR_SUCCESS;
7036 }
7037
7038 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7039 {
7040         uint32_t _ptr_array;
7041         uint32_t cntr_array_1;
7042         TALLOC_CTX *_mem_save_array_0;
7043         TALLOC_CTX *_mem_save_array_1;
7044         if (ndr_flags & NDR_SCALARS) {
7045                 NDR_CHECK(ndr_pull_align(ndr, 5));
7046                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7047                 if (r->count > 10000) {
7048                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7049                 }
7050                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7051                 if (_ptr_array) {
7052                         NDR_PULL_ALLOC(ndr, r->array);
7053                 } else {
7054                         r->array = NULL;
7055                 }
7056         }
7057         if (ndr_flags & NDR_BUFFERS) {
7058                 if (r->array) {
7059                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7060                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7062                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7063                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7064                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7065                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7066                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7067                         }
7068                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7069                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7070                         }
7071                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7073                 }
7074                 if (r->array) {
7075                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7076                 }
7077         }
7078         return NDR_ERR_SUCCESS;
7079 }
7080
7081 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7082 {
7083         uint32_t cntr_array_1;
7084         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7085         ndr->depth++;
7086         ndr_print_uint32(ndr, "count", r->count);
7087         ndr_print_ptr(ndr, "array", r->array);
7088         ndr->depth++;
7089         if (r->array) {
7090                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7091                 ndr->depth++;
7092                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7093                         char *idx_1=NULL;
7094                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7095                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7096                                 free(idx_1);
7097                         }
7098                 }
7099                 ndr->depth--;
7100         }
7101         ndr->depth--;
7102         ndr->depth--;
7103 }
7104
7105 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7106 {
7107         if (ndr_flags & NDR_SCALARS) {
7108                 NDR_CHECK(ndr_push_align(ndr, 5));
7109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7110                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7111                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7113                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7114                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7115                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7119                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7120                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7121                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7122                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7123         }
7124         if (ndr_flags & NDR_BUFFERS) {
7125                 if (r->netbios_name) {
7126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7128                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7129                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7130                 }
7131                 if (r->dns_name) {
7132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7134                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7135                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7136                 }
7137                 if (r->site_name) {
7138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7141                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7142                 }
7143                 if (r->site_dn) {
7144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7147                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7148                 }
7149                 if (r->computer_dn) {
7150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7151                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7152                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7153                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7154                 }
7155                 if (r->server_dn) {
7156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7158                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7159                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7160                 }
7161                 if (r->ntds_dn) {
7162                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7163                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7164                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7165                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7166                 }
7167         }
7168         return NDR_ERR_SUCCESS;
7169 }
7170
7171 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7172 {
7173         uint32_t _ptr_netbios_name;
7174         TALLOC_CTX *_mem_save_netbios_name_0;
7175         uint32_t _ptr_dns_name;
7176         TALLOC_CTX *_mem_save_dns_name_0;
7177         uint32_t _ptr_site_name;
7178         TALLOC_CTX *_mem_save_site_name_0;
7179         uint32_t _ptr_site_dn;
7180         TALLOC_CTX *_mem_save_site_dn_0;
7181         uint32_t _ptr_computer_dn;
7182         TALLOC_CTX *_mem_save_computer_dn_0;
7183         uint32_t _ptr_server_dn;
7184         TALLOC_CTX *_mem_save_server_dn_0;
7185         uint32_t _ptr_ntds_dn;
7186         TALLOC_CTX *_mem_save_ntds_dn_0;
7187         if (ndr_flags & NDR_SCALARS) {
7188                 NDR_CHECK(ndr_pull_align(ndr, 5));
7189                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7190                 if (_ptr_netbios_name) {
7191                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7192                 } else {
7193                         r->netbios_name = NULL;
7194                 }
7195                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7196                 if (_ptr_dns_name) {
7197                         NDR_PULL_ALLOC(ndr, r->dns_name);
7198                 } else {
7199                         r->dns_name = NULL;
7200                 }
7201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7202                 if (_ptr_site_name) {
7203                         NDR_PULL_ALLOC(ndr, r->site_name);
7204                 } else {
7205                         r->site_name = NULL;
7206                 }
7207                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7208                 if (_ptr_site_dn) {
7209                         NDR_PULL_ALLOC(ndr, r->site_dn);
7210                 } else {
7211                         r->site_dn = NULL;
7212                 }
7213                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7214                 if (_ptr_computer_dn) {
7215                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7216                 } else {
7217                         r->computer_dn = NULL;
7218                 }
7219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7220                 if (_ptr_server_dn) {
7221                         NDR_PULL_ALLOC(ndr, r->server_dn);
7222                 } else {
7223                         r->server_dn = NULL;
7224                 }
7225                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7226                 if (_ptr_ntds_dn) {
7227                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7228                 } else {
7229                         r->ntds_dn = NULL;
7230                 }
7231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7234                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7235                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7236                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7237                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7238         }
7239         if (ndr_flags & NDR_BUFFERS) {
7240                 if (r->netbios_name) {
7241                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7242                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7243                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7244                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7245                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7246                                 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));
7247                         }
7248                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7249                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7251                 }
7252                 if (r->dns_name) {
7253                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7254                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7255                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7256                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7257                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7258                                 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));
7259                         }
7260                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7261                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7263                 }
7264                 if (r->site_name) {
7265                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7266                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7267                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7268                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7269                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7270                                 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));
7271                         }
7272                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7273                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7275                 }
7276                 if (r->site_dn) {
7277                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7278                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7279                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7280                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7281                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7282                                 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));
7283                         }
7284                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7285                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7287                 }
7288                 if (r->computer_dn) {
7289                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7290                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7291                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7292                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7293                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7294                                 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));
7295                         }
7296                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7297                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7299                 }
7300                 if (r->server_dn) {
7301                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7302                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7303                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7304                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7305                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7306                                 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));
7307                         }
7308                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7309                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7311                 }
7312                 if (r->ntds_dn) {
7313                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7314                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7317                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7318                                 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));
7319                         }
7320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7323                 }
7324         }
7325         return NDR_ERR_SUCCESS;
7326 }
7327
7328 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7329 {
7330         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7331         ndr->depth++;
7332         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7333         ndr->depth++;
7334         if (r->netbios_name) {
7335                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7336         }
7337         ndr->depth--;
7338         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7339         ndr->depth++;
7340         if (r->dns_name) {
7341                 ndr_print_string(ndr, "dns_name", r->dns_name);
7342         }
7343         ndr->depth--;
7344         ndr_print_ptr(ndr, "site_name", r->site_name);
7345         ndr->depth++;
7346         if (r->site_name) {
7347                 ndr_print_string(ndr, "site_name", r->site_name);
7348         }
7349         ndr->depth--;
7350         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7351         ndr->depth++;
7352         if (r->site_dn) {
7353                 ndr_print_string(ndr, "site_dn", r->site_dn);
7354         }
7355         ndr->depth--;
7356         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7357         ndr->depth++;
7358         if (r->computer_dn) {
7359                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7360         }
7361         ndr->depth--;
7362         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7363         ndr->depth++;
7364         if (r->server_dn) {
7365                 ndr_print_string(ndr, "server_dn", r->server_dn);
7366         }
7367         ndr->depth--;
7368         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7369         ndr->depth++;
7370         if (r->ntds_dn) {
7371                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7372         }
7373         ndr->depth--;
7374         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7375         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7376         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7377         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7378         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7379         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7380         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7381         ndr->depth--;
7382 }
7383
7384 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7385 {
7386         uint32_t cntr_array_1;
7387         if (ndr_flags & NDR_SCALARS) {
7388                 NDR_CHECK(ndr_push_align(ndr, 5));
7389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7391         }
7392         if (ndr_flags & NDR_BUFFERS) {
7393                 if (r->array) {
7394                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7395                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7396                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7397                         }
7398                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7399                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7400                         }
7401                 }
7402         }
7403         return NDR_ERR_SUCCESS;
7404 }
7405
7406 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7407 {
7408         uint32_t _ptr_array;
7409         uint32_t cntr_array_1;
7410         TALLOC_CTX *_mem_save_array_0;
7411         TALLOC_CTX *_mem_save_array_1;
7412         if (ndr_flags & NDR_SCALARS) {
7413                 NDR_CHECK(ndr_pull_align(ndr, 5));
7414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7415                 if (r->count > 10000) {
7416                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7417                 }
7418                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7419                 if (_ptr_array) {
7420                         NDR_PULL_ALLOC(ndr, r->array);
7421                 } else {
7422                         r->array = NULL;
7423                 }
7424         }
7425         if (ndr_flags & NDR_BUFFERS) {
7426                 if (r->array) {
7427                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7428                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7429                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7430                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7431                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7432                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7433                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7434                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7435                         }
7436                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7437                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7438                         }
7439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7440                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7441                 }
7442                 if (r->array) {
7443                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7444                 }
7445         }
7446         return NDR_ERR_SUCCESS;
7447 }
7448
7449 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7450 {
7451         uint32_t cntr_array_1;
7452         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7453         ndr->depth++;
7454         ndr_print_uint32(ndr, "count", r->count);
7455         ndr_print_ptr(ndr, "array", r->array);
7456         ndr->depth++;
7457         if (r->array) {
7458                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7459                 ndr->depth++;
7460                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7461                         char *idx_1=NULL;
7462                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7463                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7464                                 free(idx_1);
7465                         }
7466                 }
7467                 ndr->depth--;
7468         }
7469         ndr->depth--;
7470         ndr->depth--;
7471 }
7472
7473 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7474 {
7475         if (ndr_flags & NDR_SCALARS) {
7476                 NDR_CHECK(ndr_push_align(ndr, 5));
7477                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7478                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7479                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7480                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7482                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7483                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7488                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7489                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7490                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7491                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7492         }
7493         if (ndr_flags & NDR_BUFFERS) {
7494                 if (r->netbios_name) {
7495                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7496                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7497                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7498                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7499                 }
7500                 if (r->dns_name) {
7501                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7502                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7503                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7504                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7505                 }
7506                 if (r->site_name) {
7507                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7508                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7510                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7511                 }
7512                 if (r->site_dn) {
7513                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7514                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7515                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7516                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7517                 }
7518                 if (r->computer_dn) {
7519                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7520                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7522                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7523                 }
7524                 if (r->server_dn) {
7525                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7526                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7527                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7528                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7529                 }
7530                 if (r->ntds_dn) {
7531                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7532                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7533                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7534                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7535                 }
7536         }
7537         return NDR_ERR_SUCCESS;
7538 }
7539
7540 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7541 {
7542         uint32_t _ptr_netbios_name;
7543         TALLOC_CTX *_mem_save_netbios_name_0;
7544         uint32_t _ptr_dns_name;
7545         TALLOC_CTX *_mem_save_dns_name_0;
7546         uint32_t _ptr_site_name;
7547         TALLOC_CTX *_mem_save_site_name_0;
7548         uint32_t _ptr_site_dn;
7549         TALLOC_CTX *_mem_save_site_dn_0;
7550         uint32_t _ptr_computer_dn;
7551         TALLOC_CTX *_mem_save_computer_dn_0;
7552         uint32_t _ptr_server_dn;
7553         TALLOC_CTX *_mem_save_server_dn_0;
7554         uint32_t _ptr_ntds_dn;
7555         TALLOC_CTX *_mem_save_ntds_dn_0;
7556         if (ndr_flags & NDR_SCALARS) {
7557                 NDR_CHECK(ndr_pull_align(ndr, 5));
7558                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7559                 if (_ptr_netbios_name) {
7560                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7561                 } else {
7562                         r->netbios_name = NULL;
7563                 }
7564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7565                 if (_ptr_dns_name) {
7566                         NDR_PULL_ALLOC(ndr, r->dns_name);
7567                 } else {
7568                         r->dns_name = NULL;
7569                 }
7570                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7571                 if (_ptr_site_name) {
7572                         NDR_PULL_ALLOC(ndr, r->site_name);
7573                 } else {
7574                         r->site_name = NULL;
7575                 }
7576                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7577                 if (_ptr_site_dn) {
7578                         NDR_PULL_ALLOC(ndr, r->site_dn);
7579                 } else {
7580                         r->site_dn = NULL;
7581                 }
7582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7583                 if (_ptr_computer_dn) {
7584                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7585                 } else {
7586                         r->computer_dn = NULL;
7587                 }
7588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7589                 if (_ptr_server_dn) {
7590                         NDR_PULL_ALLOC(ndr, r->server_dn);
7591                 } else {
7592                         r->server_dn = NULL;
7593                 }
7594                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7595                 if (_ptr_ntds_dn) {
7596                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7597                 } else {
7598                         r->ntds_dn = NULL;
7599                 }
7600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7604                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7605                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7606                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7607                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7608         }
7609         if (ndr_flags & NDR_BUFFERS) {
7610                 if (r->netbios_name) {
7611                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7612                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7613                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7614                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7615                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7616                                 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));
7617                         }
7618                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7619                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7621                 }
7622                 if (r->dns_name) {
7623                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7624                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7625                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7626                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7627                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7628                                 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));
7629                         }
7630                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7631                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7633                 }
7634                 if (r->site_name) {
7635                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7636                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7637                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7638                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7639                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7640                                 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));
7641                         }
7642                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7643                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7644                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7645                 }
7646                 if (r->site_dn) {
7647                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7648                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7649                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7650                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7651                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7652                                 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));
7653                         }
7654                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7655                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7656                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7657                 }
7658                 if (r->computer_dn) {
7659                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7660                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7661                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7662                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7663                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7664                                 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));
7665                         }
7666                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7667                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7669                 }
7670                 if (r->server_dn) {
7671                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7672                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7673                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7674                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7675                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7676                                 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));
7677                         }
7678                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7679                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7680                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7681                 }
7682                 if (r->ntds_dn) {
7683                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7684                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7685                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7686                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7687                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7688                                 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));
7689                         }
7690                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7691                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7693                 }
7694         }
7695         return NDR_ERR_SUCCESS;
7696 }
7697
7698 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7699 {
7700         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7701         ndr->depth++;
7702         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7703         ndr->depth++;
7704         if (r->netbios_name) {
7705                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7706         }
7707         ndr->depth--;
7708         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7709         ndr->depth++;
7710         if (r->dns_name) {
7711                 ndr_print_string(ndr, "dns_name", r->dns_name);
7712         }
7713         ndr->depth--;
7714         ndr_print_ptr(ndr, "site_name", r->site_name);
7715         ndr->depth++;
7716         if (r->site_name) {
7717                 ndr_print_string(ndr, "site_name", r->site_name);
7718         }
7719         ndr->depth--;
7720         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7721         ndr->depth++;
7722         if (r->site_dn) {
7723                 ndr_print_string(ndr, "site_dn", r->site_dn);
7724         }
7725         ndr->depth--;
7726         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7727         ndr->depth++;
7728         if (r->computer_dn) {
7729                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7730         }
7731         ndr->depth--;
7732         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7733         ndr->depth++;
7734         if (r->server_dn) {
7735                 ndr_print_string(ndr, "server_dn", r->server_dn);
7736         }
7737         ndr->depth--;
7738         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7739         ndr->depth++;
7740         if (r->ntds_dn) {
7741                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7742         }
7743         ndr->depth--;
7744         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7745         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7746         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7747         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7748         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7749         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7750         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7751         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7752         ndr->depth--;
7753 }
7754
7755 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7756 {
7757         uint32_t cntr_array_1;
7758         if (ndr_flags & NDR_SCALARS) {
7759                 NDR_CHECK(ndr_push_align(ndr, 5));
7760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7761                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7762         }
7763         if (ndr_flags & NDR_BUFFERS) {
7764                 if (r->array) {
7765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7766                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7767                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7768                         }
7769                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7770                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7771                         }
7772                 }
7773         }
7774         return NDR_ERR_SUCCESS;
7775 }
7776
7777 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7778 {
7779         uint32_t _ptr_array;
7780         uint32_t cntr_array_1;
7781         TALLOC_CTX *_mem_save_array_0;
7782         TALLOC_CTX *_mem_save_array_1;
7783         if (ndr_flags & NDR_SCALARS) {
7784                 NDR_CHECK(ndr_pull_align(ndr, 5));
7785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7786                 if (r->count > 10000) {
7787                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7788                 }
7789                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7790                 if (_ptr_array) {
7791                         NDR_PULL_ALLOC(ndr, r->array);
7792                 } else {
7793                         r->array = NULL;
7794                 }
7795         }
7796         if (ndr_flags & NDR_BUFFERS) {
7797                 if (r->array) {
7798                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7799                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7801                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7802                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7803                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7804                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7805                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7806                         }
7807                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7808                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7809                         }
7810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7812                 }
7813                 if (r->array) {
7814                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7815                 }
7816         }
7817         return NDR_ERR_SUCCESS;
7818 }
7819
7820 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7821 {
7822         uint32_t cntr_array_1;
7823         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7824         ndr->depth++;
7825         ndr_print_uint32(ndr, "count", r->count);
7826         ndr_print_ptr(ndr, "array", r->array);
7827         ndr->depth++;
7828         if (r->array) {
7829                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7830                 ndr->depth++;
7831                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7832                         char *idx_1=NULL;
7833                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7834                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7835                                 free(idx_1);
7836                         }
7837                 }
7838                 ndr->depth--;
7839         }
7840         ndr->depth--;
7841         ndr->depth--;
7842 }
7843
7844 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7845 {
7846         if (ndr_flags & NDR_SCALARS) {
7847                 NDR_CHECK(ndr_push_align(ndr, 5));
7848                 {
7849                         uint32_t _flags_save_ipv4address = ndr->flags;
7850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7851                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7852                         ndr->flags = _flags_save_ipv4address;
7853                 }
7854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7859                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7860         }
7861         if (ndr_flags & NDR_BUFFERS) {
7862                 if (r->client_account) {
7863                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7866                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7867                 }
7868         }
7869         return NDR_ERR_SUCCESS;
7870 }
7871
7872 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
7873 {
7874         uint32_t _ptr_client_account;
7875         TALLOC_CTX *_mem_save_client_account_0;
7876         if (ndr_flags & NDR_SCALARS) {
7877                 NDR_CHECK(ndr_pull_align(ndr, 5));
7878                 {
7879                         uint32_t _flags_save_ipv4address = ndr->flags;
7880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7881                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
7882                         ndr->flags = _flags_save_ipv4address;
7883                 }
7884                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
7886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
7887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
7888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
7889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
7890                 if (_ptr_client_account) {
7891                         NDR_PULL_ALLOC(ndr, r->client_account);
7892                 } else {
7893                         r->client_account = NULL;
7894                 }
7895         }
7896         if (ndr_flags & NDR_BUFFERS) {
7897                 if (r->client_account) {
7898                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7899                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
7900                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
7901                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
7902                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
7903                                 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));
7904                         }
7905                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
7906                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
7907                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
7908                 }
7909         }
7910         return NDR_ERR_SUCCESS;
7911 }
7912
7913 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
7914 {
7915         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
7916         ndr->depth++;
7917         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
7918         ndr_print_uint32(ndr, "unknown2", r->unknown2);
7919         ndr_print_uint32(ndr, "connection_time", r->connection_time);
7920         ndr_print_uint32(ndr, "unknown4", r->unknown4);
7921         ndr_print_uint32(ndr, "unknown5", r->unknown5);
7922         ndr_print_uint32(ndr, "unknown6", r->unknown6);
7923         ndr_print_ptr(ndr, "client_account", r->client_account);
7924         ndr->depth++;
7925         if (r->client_account) {
7926                 ndr_print_string(ndr, "client_account", r->client_account);
7927         }
7928         ndr->depth--;
7929         ndr->depth--;
7930 }
7931
7932 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
7933 {
7934         uint32_t cntr_array_1;
7935         if (ndr_flags & NDR_SCALARS) {
7936                 NDR_CHECK(ndr_push_align(ndr, 5));
7937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7939         }
7940         if (ndr_flags & NDR_BUFFERS) {
7941                 if (r->array) {
7942                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7943                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7944                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7945                         }
7946                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7947                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7948                         }
7949                 }
7950         }
7951         return NDR_ERR_SUCCESS;
7952 }
7953
7954 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
7955 {
7956         uint32_t _ptr_array;
7957         uint32_t cntr_array_1;
7958         TALLOC_CTX *_mem_save_array_0;
7959         TALLOC_CTX *_mem_save_array_1;
7960         if (ndr_flags & NDR_SCALARS) {
7961                 NDR_CHECK(ndr_pull_align(ndr, 5));
7962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7963                 if (r->count > 10000) {
7964                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7965                 }
7966                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7967                 if (_ptr_array) {
7968                         NDR_PULL_ALLOC(ndr, r->array);
7969                 } else {
7970                         r->array = NULL;
7971                 }
7972         }
7973         if (ndr_flags & NDR_BUFFERS) {
7974                 if (r->array) {
7975                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7976                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7977                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7978                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7979                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7980                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7981                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7982                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7983                         }
7984                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7985                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7986                         }
7987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7988                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7989                 }
7990                 if (r->array) {
7991                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7992                 }
7993         }
7994         return NDR_ERR_SUCCESS;
7995 }
7996
7997 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
7998 {
7999         uint32_t cntr_array_1;
8000         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8001         ndr->depth++;
8002         ndr_print_uint32(ndr, "count", r->count);
8003         ndr_print_ptr(ndr, "array", r->array);
8004         ndr->depth++;
8005         if (r->array) {
8006                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8007                 ndr->depth++;
8008                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8009                         char *idx_1=NULL;
8010                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8011                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8012                                 free(idx_1);
8013                         }
8014                 }
8015                 ndr->depth--;
8016         }
8017         ndr->depth--;
8018         ndr->depth--;
8019 }
8020
8021 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8022 {
8023         if (ndr_flags & NDR_SCALARS) {
8024                 int level = ndr_push_get_switch_value(ndr, r);
8025                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8026                 switch (level) {
8027                         case DRSUAPI_DC_INFO_CTR_1: {
8028                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8029                         break; }
8030
8031                         case DRSUAPI_DC_INFO_CTR_2: {
8032                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8033                         break; }
8034
8035                         case DRSUAPI_DC_INFO_CTR_3: {
8036                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8037                         break; }
8038
8039                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8040                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8041                         break; }
8042
8043                         default:
8044                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8045                 }
8046         }
8047         if (ndr_flags & NDR_BUFFERS) {
8048                 int level = ndr_push_get_switch_value(ndr, r);
8049                 switch (level) {
8050                         case DRSUAPI_DC_INFO_CTR_1:
8051                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8052                         break;
8053
8054                         case DRSUAPI_DC_INFO_CTR_2:
8055                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8056                         break;
8057
8058                         case DRSUAPI_DC_INFO_CTR_3:
8059                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8060                         break;
8061
8062                         case DRSUAPI_DC_CONNECTION_CTR_01:
8063                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8064                         break;
8065
8066                         default:
8067                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8068                 }
8069         }
8070         return NDR_ERR_SUCCESS;
8071 }
8072
8073 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8074 {
8075         int level;
8076         int32_t _level;
8077         level = ndr_pull_get_switch_value(ndr, r);
8078         if (ndr_flags & NDR_SCALARS) {
8079                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8080                 if (_level != level) {
8081                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8082                 }
8083                 switch (level) {
8084                         case DRSUAPI_DC_INFO_CTR_1: {
8085                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8086                         break; }
8087
8088                         case DRSUAPI_DC_INFO_CTR_2: {
8089                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8090                         break; }
8091
8092                         case DRSUAPI_DC_INFO_CTR_3: {
8093                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8094                         break; }
8095
8096                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8097                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8098                         break; }
8099
8100                         default:
8101                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8102                 }
8103         }
8104         if (ndr_flags & NDR_BUFFERS) {
8105                 switch (level) {
8106                         case DRSUAPI_DC_INFO_CTR_1:
8107                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8108                         break;
8109
8110                         case DRSUAPI_DC_INFO_CTR_2:
8111                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8112                         break;
8113
8114                         case DRSUAPI_DC_INFO_CTR_3:
8115                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8116                         break;
8117
8118                         case DRSUAPI_DC_CONNECTION_CTR_01:
8119                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8120                         break;
8121
8122                         default:
8123                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8124                 }
8125         }
8126         return NDR_ERR_SUCCESS;
8127 }
8128
8129 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8130 {
8131         int level;
8132         level = ndr_print_get_switch_value(ndr, r);
8133         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8134         switch (level) {
8135                 case DRSUAPI_DC_INFO_CTR_1:
8136                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8137                 break;
8138
8139                 case DRSUAPI_DC_INFO_CTR_2:
8140                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8141                 break;
8142
8143                 case DRSUAPI_DC_INFO_CTR_3:
8144                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8145                 break;
8146
8147                 case DRSUAPI_DC_CONNECTION_CTR_01:
8148                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8149                 break;
8150
8151                 default:
8152                         ndr_print_bad_level(ndr, name, level);
8153         }
8154 }
8155
8156 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8157 {
8158         if (ndr_flags & NDR_SCALARS) {
8159                 NDR_CHECK(ndr_push_align(ndr, 5));
8160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8161                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8162         }
8163         if (ndr_flags & NDR_BUFFERS) {
8164                 if (r->next_object) {
8165                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8166                 }
8167                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8168         }
8169         return NDR_ERR_SUCCESS;
8170 }
8171
8172 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8173 {
8174         uint32_t _ptr_next_object;
8175         TALLOC_CTX *_mem_save_next_object_0;
8176         if (ndr_flags & NDR_SCALARS) {
8177                 NDR_CHECK(ndr_pull_align(ndr, 5));
8178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8179                 if (_ptr_next_object) {
8180                         NDR_PULL_ALLOC(ndr, r->next_object);
8181                 } else {
8182                         r->next_object = NULL;
8183                 }
8184                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8185         }
8186         if (ndr_flags & NDR_BUFFERS) {
8187                 if (r->next_object) {
8188                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8189                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8190                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8192                 }
8193                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8194         }
8195         return NDR_ERR_SUCCESS;
8196 }
8197
8198 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8199 {
8200         if (ndr_flags & NDR_SCALARS) {
8201                 NDR_CHECK(ndr_push_align(ndr, 5));
8202                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8203         }
8204         if (ndr_flags & NDR_BUFFERS) {
8205                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8206         }
8207         return NDR_ERR_SUCCESS;
8208 }
8209
8210 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8211 {
8212         if (ndr_flags & NDR_SCALARS) {
8213                 NDR_CHECK(ndr_pull_align(ndr, 5));
8214                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8215         }
8216         if (ndr_flags & NDR_BUFFERS) {
8217                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8218         }
8219         return NDR_ERR_SUCCESS;
8220 }
8221
8222 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8223 {
8224         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8225         ndr->depth++;
8226         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8227         ndr->depth--;
8228 }
8229
8230 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8231 {
8232         if (ndr_flags & NDR_SCALARS) {
8233                 int level = ndr_push_get_switch_value(ndr, r);
8234                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8235                 switch (level) {
8236                         case 2: {
8237                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8238                         break; }
8239
8240                         default:
8241                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8242                 }
8243         }
8244         if (ndr_flags & NDR_BUFFERS) {
8245                 int level = ndr_push_get_switch_value(ndr, r);
8246                 switch (level) {
8247                         case 2:
8248                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8249                         break;
8250
8251                         default:
8252                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8253                 }
8254         }
8255         return NDR_ERR_SUCCESS;
8256 }
8257
8258 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8259 {
8260         int level;
8261         int32_t _level;
8262         level = ndr_pull_get_switch_value(ndr, r);
8263         if (ndr_flags & NDR_SCALARS) {
8264                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8265                 if (_level != level) {
8266                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8267                 }
8268                 switch (level) {
8269                         case 2: {
8270                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8271                         break; }
8272
8273                         default:
8274                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8275                 }
8276         }
8277         if (ndr_flags & NDR_BUFFERS) {
8278                 switch (level) {
8279                         case 2:
8280                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8281                         break;
8282
8283                         default:
8284                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8285                 }
8286         }
8287         return NDR_ERR_SUCCESS;
8288 }
8289
8290 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8291 {
8292         int level;
8293         level = ndr_print_get_switch_value(ndr, r);
8294         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8295         switch (level) {
8296                 case 2:
8297                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8298                 break;
8299
8300                 default:
8301                         ndr_print_bad_level(ndr, name, level);
8302         }
8303 }
8304
8305 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8306 {
8307         if (ndr_flags & NDR_SCALARS) {
8308                 NDR_CHECK(ndr_push_align(ndr, 4));
8309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8310                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8312                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8313         }
8314         if (ndr_flags & NDR_BUFFERS) {
8315         }
8316         return NDR_ERR_SUCCESS;
8317 }
8318
8319 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8320 {
8321         if (ndr_flags & NDR_SCALARS) {
8322                 NDR_CHECK(ndr_pull_align(ndr, 4));
8323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8324                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8326                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8327         }
8328         if (ndr_flags & NDR_BUFFERS) {
8329         }
8330         return NDR_ERR_SUCCESS;
8331 }
8332
8333 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8334 {
8335         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8336         ndr->depth++;
8337         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8338         ndr_print_WERROR(ndr, "status", r->status);
8339         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8340         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8341         ndr->depth--;
8342 }
8343
8344 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8345 {
8346         if (ndr_flags & NDR_SCALARS) {
8347                 NDR_CHECK(ndr_push_align(ndr, 5));
8348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8350         }
8351         if (ndr_flags & NDR_BUFFERS) {
8352                 if (r->data) {
8353                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8354                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8355                 }
8356         }
8357         return NDR_ERR_SUCCESS;
8358 }
8359
8360 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8361 {
8362         uint32_t _ptr_data;
8363         TALLOC_CTX *_mem_save_data_0;
8364         if (ndr_flags & NDR_SCALARS) {
8365                 NDR_CHECK(ndr_pull_align(ndr, 5));
8366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8367                 if (r->size > 10485760) {
8368                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8369                 }
8370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8371                 if (_ptr_data) {
8372                         NDR_PULL_ALLOC(ndr, r->data);
8373                 } else {
8374                         r->data = NULL;
8375                 }
8376         }
8377         if (ndr_flags & NDR_BUFFERS) {
8378                 if (r->data) {
8379                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8380                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8381                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8382                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8383                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8385                 }
8386                 if (r->data) {
8387                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8388                 }
8389         }
8390         return NDR_ERR_SUCCESS;
8391 }
8392
8393 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8394 {
8395         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8396         ndr->depth++;
8397         ndr_print_uint32(ndr, "size", r->size);
8398         ndr_print_ptr(ndr, "data", r->data);
8399         ndr->depth++;
8400         if (r->data) {
8401                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8402         }
8403         ndr->depth--;
8404         ndr->depth--;
8405 }
8406
8407 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8408 {
8409         if (ndr_flags & NDR_SCALARS) {
8410                 NDR_CHECK(ndr_push_align(ndr, 5));
8411                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8412                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8414                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8415         }
8416         if (ndr_flags & NDR_BUFFERS) {
8417                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8418         }
8419         return NDR_ERR_SUCCESS;
8420 }
8421
8422 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8423 {
8424         if (ndr_flags & NDR_SCALARS) {
8425                 NDR_CHECK(ndr_pull_align(ndr, 5));
8426                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8427                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8429                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8430         }
8431         if (ndr_flags & NDR_BUFFERS) {
8432                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8433         }
8434         return NDR_ERR_SUCCESS;
8435 }
8436
8437 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8438 {
8439         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8440         ndr->depth++;
8441         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8442         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8443         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8444         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8445         ndr->depth--;
8446 }
8447
8448 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8449 {
8450         if (ndr_flags & NDR_SCALARS) {
8451                 NDR_CHECK(ndr_push_align(ndr, 5));
8452                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8453                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8454         }
8455         if (ndr_flags & NDR_BUFFERS) {
8456                 if (r->next) {
8457                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8458                 }
8459                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8460         }
8461         return NDR_ERR_SUCCESS;
8462 }
8463
8464 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8465 {
8466         uint32_t _ptr_next;
8467         TALLOC_CTX *_mem_save_next_0;
8468         if (ndr_flags & NDR_SCALARS) {
8469                 NDR_CHECK(ndr_pull_align(ndr, 5));
8470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8471                 if (_ptr_next) {
8472                         NDR_PULL_ALLOC(ndr, r->next);
8473                 } else {
8474                         r->next = NULL;
8475                 }
8476                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8477         }
8478         if (ndr_flags & NDR_BUFFERS) {
8479                 if (r->next) {
8480                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8481                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8482                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8484                 }
8485                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8486         }
8487         return NDR_ERR_SUCCESS;
8488 }
8489
8490 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8491 {
8492         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8493         ndr->depth++;
8494         ndr_print_ptr(ndr, "next", r->next);
8495         ndr->depth++;
8496         if (r->next) {
8497                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8498         }
8499         ndr->depth--;
8500         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8501         ndr->depth--;
8502 }
8503
8504 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8505 {
8506         if (ndr_flags & NDR_SCALARS) {
8507                 NDR_CHECK(ndr_push_align(ndr, 5));
8508                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8509                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8510                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8511         }
8512         if (ndr_flags & NDR_BUFFERS) {
8513                 if (r->id) {
8514                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8515                 }
8516                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8517         }
8518         return NDR_ERR_SUCCESS;
8519 }
8520
8521 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8522 {
8523         uint32_t _ptr_id;
8524         TALLOC_CTX *_mem_save_id_0;
8525         if (ndr_flags & NDR_SCALARS) {
8526                 NDR_CHECK(ndr_pull_align(ndr, 5));
8527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8528                 if (_ptr_id) {
8529                         NDR_PULL_ALLOC(ndr, r->id);
8530                 } else {
8531                         r->id = NULL;
8532                 }
8533                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8534                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8535         }
8536         if (ndr_flags & NDR_BUFFERS) {
8537                 if (r->id) {
8538                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8539                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8540                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8541                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8542                 }
8543                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8544         }
8545         return NDR_ERR_SUCCESS;
8546 }
8547
8548 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8549 {
8550         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8551         ndr->depth++;
8552         ndr_print_ptr(ndr, "id", r->id);
8553         ndr->depth++;
8554         if (r->id) {
8555                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8556         }
8557         ndr->depth--;
8558         ndr_print_WERROR(ndr, "status", r->status);
8559         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8560         ndr->depth--;
8561 }
8562
8563 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8564 {
8565         if (ndr_flags & NDR_SCALARS) {
8566                 int level = ndr_push_get_switch_value(ndr, r);
8567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8568                 switch (level) {
8569                         case 1: {
8570                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8571                         break; }
8572
8573                         case 4: {
8574                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8575                         break; }
8576
8577                         case 5: {
8578                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8579                         break; }
8580
8581                         case 6: {
8582                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8583                         break; }
8584
8585                         case 7: {
8586                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8587                         break; }
8588
8589                         default:
8590                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8591                 }
8592         }
8593         if (ndr_flags & NDR_BUFFERS) {
8594                 int level = ndr_push_get_switch_value(ndr, r);
8595                 switch (level) {
8596                         case 1:
8597                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8598                         break;
8599
8600                         case 4:
8601                         break;
8602
8603                         case 5:
8604                         break;
8605
8606                         case 6:
8607                         break;
8608
8609                         case 7:
8610                         break;
8611
8612                         default:
8613                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8614                 }
8615         }
8616         return NDR_ERR_SUCCESS;
8617 }
8618
8619 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8620 {
8621         int level;
8622         uint32_t _level;
8623         level = ndr_pull_get_switch_value(ndr, r);
8624         if (ndr_flags & NDR_SCALARS) {
8625                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8626                 if (_level != level) {
8627                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8628                 }
8629                 switch (level) {
8630                         case 1: {
8631                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8632                         break; }
8633
8634                         case 4: {
8635                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8636                         break; }
8637
8638                         case 5: {
8639                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8640                         break; }
8641
8642                         case 6: {
8643                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8644                         break; }
8645
8646                         case 7: {
8647                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8648                         break; }
8649
8650                         default:
8651                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8652                 }
8653         }
8654         if (ndr_flags & NDR_BUFFERS) {
8655                 switch (level) {
8656                         case 1:
8657                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8658                         break;
8659
8660                         case 4:
8661                         break;
8662
8663                         case 5:
8664                         break;
8665
8666                         case 6:
8667                         break;
8668
8669                         case 7:
8670                         break;
8671
8672                         default:
8673                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8674                 }
8675         }
8676         return NDR_ERR_SUCCESS;
8677 }
8678
8679 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8680 {
8681         int level;
8682         level = ndr_print_get_switch_value(ndr, r);
8683         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8684         switch (level) {
8685                 case 1:
8686                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8687                 break;
8688
8689                 case 4:
8690                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8691                 break;
8692
8693                 case 5:
8694                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8695                 break;
8696
8697                 case 6:
8698                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8699                 break;
8700
8701                 case 7:
8702                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8703                 break;
8704
8705                 default:
8706                         ndr_print_bad_level(ndr, name, level);
8707         }
8708 }
8709
8710 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8711 {
8712         if (ndr_flags & NDR_SCALARS) {
8713                 NDR_CHECK(ndr_push_align(ndr, 5));
8714                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8717         }
8718         if (ndr_flags & NDR_BUFFERS) {
8719                 if (r->info) {
8720                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8721                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8722                 }
8723         }
8724         return NDR_ERR_SUCCESS;
8725 }
8726
8727 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8728 {
8729         uint32_t _ptr_info;
8730         TALLOC_CTX *_mem_save_info_0;
8731         if (ndr_flags & NDR_SCALARS) {
8732                 NDR_CHECK(ndr_pull_align(ndr, 5));
8733                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8735                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8736                 if (_ptr_info) {
8737                         NDR_PULL_ALLOC(ndr, r->info);
8738                 } else {
8739                         r->info = NULL;
8740                 }
8741         }
8742         if (ndr_flags & NDR_BUFFERS) {
8743                 if (r->info) {
8744                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8745                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8746                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8747                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8749                 }
8750         }
8751         return NDR_ERR_SUCCESS;
8752 }
8753
8754 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8755 {
8756         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8757         ndr->depth++;
8758         ndr_print_WERROR(ndr, "status", r->status);
8759         ndr_print_uint32(ndr, "level", r->level);
8760         ndr_print_ptr(ndr, "info", r->info);
8761         ndr->depth++;
8762         if (r->info) {
8763                 ndr_print_set_switch_value(ndr, r->info, r->level);
8764                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8765         }
8766         ndr->depth--;
8767         ndr->depth--;
8768 }
8769
8770 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8771 {
8772         if (ndr_flags & NDR_SCALARS) {
8773                 int level = ndr_push_get_switch_value(ndr, r);
8774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8775                 switch (level) {
8776                         case 1: {
8777                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8778                         break; }
8779
8780                         default:
8781                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8782                 }
8783         }
8784         if (ndr_flags & NDR_BUFFERS) {
8785                 int level = ndr_push_get_switch_value(ndr, r);
8786                 switch (level) {
8787                         case 1:
8788                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8789                         break;
8790
8791                         default:
8792                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8793                 }
8794         }
8795         return NDR_ERR_SUCCESS;
8796 }
8797
8798 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8799 {
8800         int level;
8801         uint32_t _level;
8802         level = ndr_pull_get_switch_value(ndr, r);
8803         if (ndr_flags & NDR_SCALARS) {
8804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8805                 if (_level != level) {
8806                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8807                 }
8808                 switch (level) {
8809                         case 1: {
8810                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8811                         break; }
8812
8813                         default:
8814                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8815                 }
8816         }
8817         if (ndr_flags & NDR_BUFFERS) {
8818                 switch (level) {
8819                         case 1:
8820                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8821                         break;
8822
8823                         default:
8824                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8825                 }
8826         }
8827         return NDR_ERR_SUCCESS;
8828 }
8829
8830 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8831 {
8832         int level;
8833         level = ndr_print_get_switch_value(ndr, r);
8834         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8835         switch (level) {
8836                 case 1:
8837                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8838                 break;
8839
8840                 default:
8841                         ndr_print_bad_level(ndr, name, level);
8842         }
8843 }
8844
8845 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8846 {
8847         if (ndr_flags & NDR_SCALARS) {
8848                 NDR_CHECK(ndr_push_align(ndr, 4));
8849                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
8850                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8851         }
8852         if (ndr_flags & NDR_BUFFERS) {
8853                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8854         }
8855         return NDR_ERR_SUCCESS;
8856 }
8857
8858 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
8859 {
8860         if (ndr_flags & NDR_SCALARS) {
8861                 NDR_CHECK(ndr_pull_align(ndr, 4));
8862                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
8863                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8864         }
8865         if (ndr_flags & NDR_BUFFERS) {
8866                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8867         }
8868         return NDR_ERR_SUCCESS;
8869 }
8870
8871 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8872 {
8873         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
8874         ndr->depth++;
8875         ndr_print_GUID(ndr, "guid", &r->guid);
8876         ndr_print_dom_sid28(ndr, "sid", &r->sid);
8877         ndr->depth--;
8878 }
8879
8880 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
8881 {
8882         uint32_t cntr_objects_1;
8883         if (ndr_flags & NDR_SCALARS) {
8884                 NDR_CHECK(ndr_push_align(ndr, 5));
8885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8887                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8889                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
8890         }
8891         if (ndr_flags & NDR_BUFFERS) {
8892                 if (r->id) {
8893                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8894                 }
8895                 if (r->objects) {
8896                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8897                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8898                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8899                         }
8900                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8901                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8902                         }
8903                 }
8904         }
8905         return NDR_ERR_SUCCESS;
8906 }
8907
8908 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
8909 {
8910         uint32_t _ptr_id;
8911         TALLOC_CTX *_mem_save_id_0;
8912         uint32_t _ptr_objects;
8913         uint32_t cntr_objects_1;
8914         TALLOC_CTX *_mem_save_objects_0;
8915         TALLOC_CTX *_mem_save_objects_1;
8916         if (ndr_flags & NDR_SCALARS) {
8917                 NDR_CHECK(ndr_pull_align(ndr, 5));
8918                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8919                 if (_ptr_id) {
8920                         NDR_PULL_ALLOC(ndr, r->id);
8921                 } else {
8922                         r->id = NULL;
8923                 }
8924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8925                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8927                 if (r->count > 10000) {
8928                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8929                 }
8930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
8931                 if (_ptr_objects) {
8932                         NDR_PULL_ALLOC(ndr, r->objects);
8933                 } else {
8934                         r->objects = NULL;
8935                 }
8936         }
8937         if (ndr_flags & NDR_BUFFERS) {
8938                 if (r->id) {
8939                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8940                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8941                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8943                 }
8944                 if (r->objects) {
8945                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
8946                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8947                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
8948                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
8949                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
8950                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8951                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8952                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8953                         }
8954                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8955                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8956                         }
8957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
8958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
8959                 }
8960                 if (r->objects) {
8961                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
8962                 }
8963         }
8964         return NDR_ERR_SUCCESS;
8965 }
8966
8967 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
8968 {
8969         uint32_t cntr_objects_1;
8970         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
8971         ndr->depth++;
8972         ndr_print_ptr(ndr, "id", r->id);
8973         ndr->depth++;
8974         if (r->id) {
8975                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8976         }
8977         ndr->depth--;
8978         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8979         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8980         ndr_print_uint32(ndr, "count", r->count);
8981         ndr_print_ptr(ndr, "objects", r->objects);
8982         ndr->depth++;
8983         if (r->objects) {
8984                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
8985                 ndr->depth++;
8986                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
8987                         char *idx_1=NULL;
8988                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
8989                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
8990                                 free(idx_1);
8991                         }
8992                 }
8993                 ndr->depth--;
8994         }
8995         ndr->depth--;
8996         ndr->depth--;
8997 }
8998
8999 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9000 {
9001         uint32_t cntr_objects_1;
9002         if (ndr_flags & NDR_SCALARS) {
9003                 NDR_CHECK(ndr_push_align(ndr, 5));
9004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9006                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9009         }
9010         if (ndr_flags & NDR_BUFFERS) {
9011                 if (r->id) {
9012                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9013                 }
9014                 if (r->error) {
9015                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9016                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9017                 }
9018                 if (r->objects) {
9019                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9020                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9021                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9022                         }
9023                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9024                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9025                         }
9026                 }
9027         }
9028         return NDR_ERR_SUCCESS;
9029 }
9030
9031 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9032 {
9033         uint32_t _ptr_id;
9034         TALLOC_CTX *_mem_save_id_0;
9035         uint32_t _ptr_error;
9036         TALLOC_CTX *_mem_save_error_0;
9037         uint32_t _ptr_objects;
9038         uint32_t cntr_objects_1;
9039         TALLOC_CTX *_mem_save_objects_0;
9040         TALLOC_CTX *_mem_save_objects_1;
9041         if (ndr_flags & NDR_SCALARS) {
9042                 NDR_CHECK(ndr_pull_align(ndr, 5));
9043                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9044                 if (_ptr_id) {
9045                         NDR_PULL_ALLOC(ndr, r->id);
9046                 } else {
9047                         r->id = NULL;
9048                 }
9049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9050                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9051                 if (_ptr_error) {
9052                         NDR_PULL_ALLOC(ndr, r->error);
9053                 } else {
9054                         r->error = NULL;
9055                 }
9056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9057                 if (r->count > 10000) {
9058                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9059                 }
9060                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9061                 if (_ptr_objects) {
9062                         NDR_PULL_ALLOC(ndr, r->objects);
9063                 } else {
9064                         r->objects = NULL;
9065                 }
9066         }
9067         if (ndr_flags & NDR_BUFFERS) {
9068                 if (r->id) {
9069                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9070                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9071                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9073                 }
9074                 if (r->error) {
9075                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9076                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9077                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9078                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9080                 }
9081                 if (r->objects) {
9082                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9083                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9085                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9086                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9087                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9088                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9089                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9090                         }
9091                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9092                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9093                         }
9094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9096                 }
9097                 if (r->objects) {
9098                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9099                 }
9100         }
9101         return NDR_ERR_SUCCESS;
9102 }
9103
9104 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9105 {
9106         uint32_t cntr_objects_1;
9107         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9108         ndr->depth++;
9109         ndr_print_ptr(ndr, "id", r->id);
9110         ndr->depth++;
9111         if (r->id) {
9112                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9113         }
9114         ndr->depth--;
9115         ndr_print_uint32(ndr, "level", r->level);
9116         ndr_print_ptr(ndr, "error", r->error);
9117         ndr->depth++;
9118         if (r->error) {
9119                 ndr_print_set_switch_value(ndr, r->error, r->level);
9120                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9121         }
9122         ndr->depth--;
9123         ndr_print_uint32(ndr, "count", r->count);
9124         ndr_print_ptr(ndr, "objects", r->objects);
9125         ndr->depth++;
9126         if (r->objects) {
9127                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9128                 ndr->depth++;
9129                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9130                         char *idx_1=NULL;
9131                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9132                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9133                                 free(idx_1);
9134                         }
9135                 }
9136                 ndr->depth--;
9137         }
9138         ndr->depth--;
9139         ndr->depth--;
9140 }
9141
9142 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9143 {
9144         if (ndr_flags & NDR_SCALARS) {
9145                 int level = ndr_push_get_switch_value(ndr, r);
9146                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9147                 switch (level) {
9148                         case 2: {
9149                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9150                         break; }
9151
9152                         case 3: {
9153                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9154                         break; }
9155
9156                         default:
9157                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9158                 }
9159         }
9160         if (ndr_flags & NDR_BUFFERS) {
9161                 int level = ndr_push_get_switch_value(ndr, r);
9162                 switch (level) {
9163                         case 2:
9164                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9165                         break;
9166
9167                         case 3:
9168                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9169                         break;
9170
9171                         default:
9172                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9173                 }
9174         }
9175         return NDR_ERR_SUCCESS;
9176 }
9177
9178 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9179 {
9180         int level;
9181         int32_t _level;
9182         level = ndr_pull_get_switch_value(ndr, r);
9183         if (ndr_flags & NDR_SCALARS) {
9184                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9185                 if (_level != level) {
9186                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9187                 }
9188                 switch (level) {
9189                         case 2: {
9190                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9191                         break; }
9192
9193                         case 3: {
9194                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9195                         break; }
9196
9197                         default:
9198                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9199                 }
9200         }
9201         if (ndr_flags & NDR_BUFFERS) {
9202                 switch (level) {
9203                         case 2:
9204                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9205                         break;
9206
9207                         case 3:
9208                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9209                         break;
9210
9211                         default:
9212                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9213                 }
9214         }
9215         return NDR_ERR_SUCCESS;
9216 }
9217
9218 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9219 {
9220         int level;
9221         level = ndr_print_get_switch_value(ndr, r);
9222         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9223         switch (level) {
9224                 case 2:
9225                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9226                 break;
9227
9228                 case 3:
9229                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9230                 break;
9231
9232                 default:
9233                         ndr_print_bad_level(ndr, name, level);
9234         }
9235 }
9236
9237 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9238 {
9239         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9240         return NDR_ERR_SUCCESS;
9241 }
9242
9243 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9244 {
9245         uint32_t v;
9246         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9247         *r = v;
9248         return NDR_ERR_SUCCESS;
9249 }
9250
9251 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9252 {
9253         ndr_print_uint32(ndr, name, r);
9254         ndr->depth++;
9255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9257         ndr->depth--;
9258 }
9259
9260 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9261 {
9262         if (ndr_flags & NDR_SCALARS) {
9263                 NDR_CHECK(ndr_push_align(ndr, 4));
9264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9265                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9266         }
9267         if (ndr_flags & NDR_BUFFERS) {
9268         }
9269         return NDR_ERR_SUCCESS;
9270 }
9271
9272 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9273 {
9274         if (ndr_flags & NDR_SCALARS) {
9275                 NDR_CHECK(ndr_pull_align(ndr, 4));
9276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9277                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9278         }
9279         if (ndr_flags & NDR_BUFFERS) {
9280         }
9281         return NDR_ERR_SUCCESS;
9282 }
9283
9284 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9285 {
9286         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9287         ndr->depth++;
9288         ndr_print_uint32(ndr, "taskID", r->taskID);
9289         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9290         ndr->depth--;
9291 }
9292
9293 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9294 {
9295         if (ndr_flags & NDR_SCALARS) {
9296                 int level = ndr_push_get_switch_value(ndr, r);
9297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9298                 switch (level) {
9299                         case 1: {
9300                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9301                         break; }
9302
9303                         default:
9304                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9305                 }
9306         }
9307         if (ndr_flags & NDR_BUFFERS) {
9308                 int level = ndr_push_get_switch_value(ndr, r);
9309                 switch (level) {
9310                         case 1:
9311                         break;
9312
9313                         default:
9314                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9315                 }
9316         }
9317         return NDR_ERR_SUCCESS;
9318 }
9319
9320 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9321 {
9322         int level;
9323         uint32_t _level;
9324         level = ndr_pull_get_switch_value(ndr, r);
9325         if (ndr_flags & NDR_SCALARS) {
9326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9327                 if (_level != level) {
9328                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9329                 }
9330                 switch (level) {
9331                         case 1: {
9332                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9333                         break; }
9334
9335                         default:
9336                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9337                 }
9338         }
9339         if (ndr_flags & NDR_BUFFERS) {
9340                 switch (level) {
9341                         case 1:
9342                         break;
9343
9344                         default:
9345                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9346                 }
9347         }
9348         return NDR_ERR_SUCCESS;
9349 }
9350
9351 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9352 {
9353         int level;
9354         level = ndr_print_get_switch_value(ndr, r);
9355         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9356         switch (level) {
9357                 case 1:
9358                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9359                 break;
9360
9361                 default:
9362                         ndr_print_bad_level(ndr, name, level);
9363         }
9364 }
9365
9366 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9367 {
9368         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9369         return NDR_ERR_SUCCESS;
9370 }
9371
9372 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9373 {
9374         uint32_t v;
9375         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9376         *r = v;
9377         return NDR_ERR_SUCCESS;
9378 }
9379
9380 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9381 {
9382         const char *val = NULL;
9383
9384         switch (r) {
9385                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9386                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9387         }
9388         ndr_print_enum(ndr, name, "ENUM", val, r);
9389 }
9390
9391 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9392 {
9393         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9394         return NDR_ERR_SUCCESS;
9395 }
9396
9397 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9398 {
9399         uint32_t v;
9400         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9401         *r = v;
9402         return NDR_ERR_SUCCESS;
9403 }
9404
9405 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9406 {
9407         const char *val = NULL;
9408
9409         switch (r) {
9410                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9411                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9412                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9413                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9414                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9415                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9416                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9417                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9418                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9419                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9420                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9421                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9422                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9423                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9424                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9425         }
9426         ndr_print_enum(ndr, name, "ENUM", val, r);
9427 }
9428
9429 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9430 {
9431         if (ndr_flags & NDR_SCALARS) {
9432                 NDR_CHECK(ndr_push_align(ndr, 5));
9433                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9435                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9436         }
9437         if (ndr_flags & NDR_BUFFERS) {
9438                 if (r->object_dn) {
9439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9440                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9442                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9443                 }
9444         }
9445         return NDR_ERR_SUCCESS;
9446 }
9447
9448 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9449 {
9450         uint32_t _ptr_object_dn;
9451         TALLOC_CTX *_mem_save_object_dn_0;
9452         if (ndr_flags & NDR_SCALARS) {
9453                 NDR_CHECK(ndr_pull_align(ndr, 5));
9454                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9455                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9456                 if (_ptr_object_dn) {
9457                         NDR_PULL_ALLOC(ndr, r->object_dn);
9458                 } else {
9459                         r->object_dn = NULL;
9460                 }
9461                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9462         }
9463         if (ndr_flags & NDR_BUFFERS) {
9464                 if (r->object_dn) {
9465                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9466                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9467                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9468                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9469                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9470                                 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));
9471                         }
9472                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9473                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9475                 }
9476         }
9477         return NDR_ERR_SUCCESS;
9478 }
9479
9480 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9481 {
9482         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9483         ndr->depth++;
9484         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9485         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9486         ndr->depth++;
9487         if (r->object_dn) {
9488                 ndr_print_string(ndr, "object_dn", r->object_dn);
9489         }
9490         ndr->depth--;
9491         ndr_print_GUID(ndr, "guid1", &r->guid1);
9492         ndr->depth--;
9493 }
9494
9495 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9496 {
9497         if (ndr_flags & NDR_SCALARS) {
9498                 NDR_CHECK(ndr_push_align(ndr, 5));
9499                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9500                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9501                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9503                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9504                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
9506         }
9507         if (ndr_flags & NDR_BUFFERS) {
9508                 if (r->object_dn) {
9509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9512                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9513                 }
9514                 if (r->string1) {
9515                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9516                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9517                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9518                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9519                 }
9520                 if (r->string2) {
9521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9524                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9525                 }
9526         }
9527         return NDR_ERR_SUCCESS;
9528 }
9529
9530 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9531 {
9532         uint32_t _ptr_object_dn;
9533         TALLOC_CTX *_mem_save_object_dn_0;
9534         uint32_t _ptr_string1;
9535         TALLOC_CTX *_mem_save_string1_0;
9536         uint32_t _ptr_string2;
9537         TALLOC_CTX *_mem_save_string2_0;
9538         if (ndr_flags & NDR_SCALARS) {
9539                 NDR_CHECK(ndr_pull_align(ndr, 5));
9540                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9542                 if (_ptr_object_dn) {
9543                         NDR_PULL_ALLOC(ndr, r->object_dn);
9544                 } else {
9545                         r->object_dn = NULL;
9546                 }
9547                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9550                 if (_ptr_string1) {
9551                         NDR_PULL_ALLOC(ndr, r->string1);
9552                 } else {
9553                         r->string1 = NULL;
9554                 }
9555                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9556                 if (_ptr_string2) {
9557                         NDR_PULL_ALLOC(ndr, r->string2);
9558                 } else {
9559                         r->string2 = NULL;
9560                 }
9561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
9562         }
9563         if (ndr_flags & NDR_BUFFERS) {
9564                 if (r->object_dn) {
9565                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9566                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9569                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9570                                 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));
9571                         }
9572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9575                 }
9576                 if (r->string1) {
9577                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9578                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9581                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9582                                 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));
9583                         }
9584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9587                 }
9588                 if (r->string2) {
9589                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9590                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9593                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9594                                 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));
9595                         }
9596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9599                 }
9600         }
9601         return NDR_ERR_SUCCESS;
9602 }
9603
9604 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9605 {
9606         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9607         ndr->depth++;
9608         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9609         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9610         ndr->depth++;
9611         if (r->object_dn) {
9612                 ndr_print_string(ndr, "object_dn", r->object_dn);
9613         }
9614         ndr->depth--;
9615         ndr_print_GUID(ndr, "guid1", &r->guid1);
9616         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9617         ndr_print_ptr(ndr, "string1", r->string1);
9618         ndr->depth++;
9619         if (r->string1) {
9620                 ndr_print_string(ndr, "string1", r->string1);
9621         }
9622         ndr->depth--;
9623         ndr_print_ptr(ndr, "string2", r->string2);
9624         ndr->depth++;
9625         if (r->string2) {
9626                 ndr_print_string(ndr, "string2", r->string2);
9627         }
9628         ndr->depth--;
9629         ndr_print_uint32(ndr, "unknown2", r->unknown2);
9630         ndr->depth--;
9631 }
9632
9633 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9634 {
9635         if (ndr_flags & NDR_SCALARS) {
9636                 int level = ndr_push_get_switch_value(ndr, r);
9637                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9638                 switch (level) {
9639                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9640                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9641                         break; }
9642
9643                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9644                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9645                         break; }
9646
9647                         default:
9648                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9649                 }
9650         }
9651         if (ndr_flags & NDR_BUFFERS) {
9652                 int level = ndr_push_get_switch_value(ndr, r);
9653                 switch (level) {
9654                         case DRSUAPI_DS_REPLICA_GET_INFO:
9655                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9656                         break;
9657
9658                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9659                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9660                         break;
9661
9662                         default:
9663                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9664                 }
9665         }
9666         return NDR_ERR_SUCCESS;
9667 }
9668
9669 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9670 {
9671         int level;
9672         uint32_t _level;
9673         level = ndr_pull_get_switch_value(ndr, r);
9674         if (ndr_flags & NDR_SCALARS) {
9675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9676                 if (_level != level) {
9677                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9678                 }
9679                 switch (level) {
9680                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9681                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9682                         break; }
9683
9684                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9685                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9686                         break; }
9687
9688                         default:
9689                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9690                 }
9691         }
9692         if (ndr_flags & NDR_BUFFERS) {
9693                 switch (level) {
9694                         case DRSUAPI_DS_REPLICA_GET_INFO:
9695                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9696                         break;
9697
9698                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9699                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9700                         break;
9701
9702                         default:
9703                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9704                 }
9705         }
9706         return NDR_ERR_SUCCESS;
9707 }
9708
9709 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9710 {
9711         int level;
9712         level = ndr_print_get_switch_value(ndr, r);
9713         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9714         switch (level) {
9715                 case DRSUAPI_DS_REPLICA_GET_INFO:
9716                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9717                 break;
9718
9719                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9720                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9721                 break;
9722
9723                 default:
9724                         ndr_print_bad_level(ndr, name, level);
9725         }
9726 }
9727
9728 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9729 {
9730         if (ndr_flags & NDR_SCALARS) {
9731                 NDR_CHECK(ndr_push_align(ndr, 8));
9732                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9733                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9734                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9735                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9736                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
9737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9738                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9739                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9740                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9741                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9742                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9743                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9744                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9745                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9748         }
9749         if (ndr_flags & NDR_BUFFERS) {
9750                 if (r->naming_context_dn) {
9751                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9753                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9754                         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));
9755                 }
9756                 if (r->source_dsa_obj_dn) {
9757                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9760                         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));
9761                 }
9762                 if (r->source_dsa_address) {
9763                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9766                         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));
9767                 }
9768                 if (r->transport_obj_dn) {
9769                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9772                         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));
9773                 }
9774         }
9775         return NDR_ERR_SUCCESS;
9776 }
9777
9778 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9779 {
9780         uint32_t _ptr_naming_context_dn;
9781         TALLOC_CTX *_mem_save_naming_context_dn_0;
9782         uint32_t _ptr_source_dsa_obj_dn;
9783         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9784         uint32_t _ptr_source_dsa_address;
9785         TALLOC_CTX *_mem_save_source_dsa_address_0;
9786         uint32_t _ptr_transport_obj_dn;
9787         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9788         if (ndr_flags & NDR_SCALARS) {
9789                 NDR_CHECK(ndr_pull_align(ndr, 8));
9790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9791                 if (_ptr_naming_context_dn) {
9792                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9793                 } else {
9794                         r->naming_context_dn = NULL;
9795                 }
9796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9797                 if (_ptr_source_dsa_obj_dn) {
9798                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9799                 } else {
9800                         r->source_dsa_obj_dn = NULL;
9801                 }
9802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9803                 if (_ptr_source_dsa_address) {
9804                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9805                 } else {
9806                         r->source_dsa_address = NULL;
9807                 }
9808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9809                 if (_ptr_transport_obj_dn) {
9810                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9811                 } else {
9812                         r->transport_obj_dn = NULL;
9813                 }
9814                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
9815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9816                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9817                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9818                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9819                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9820                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9821                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9822                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
9823                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
9824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
9825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
9826         }
9827         if (ndr_flags & NDR_BUFFERS) {
9828                 if (r->naming_context_dn) {
9829                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9830                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
9831                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
9832                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
9833                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
9834                                 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));
9835                         }
9836                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
9837                         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));
9838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
9839                 }
9840                 if (r->source_dsa_obj_dn) {
9841                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9842                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
9843                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
9844                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
9845                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
9846                                 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));
9847                         }
9848                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
9849                         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));
9850                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
9851                 }
9852                 if (r->source_dsa_address) {
9853                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
9854                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
9855                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
9856                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
9857                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
9858                                 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));
9859                         }
9860                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
9861                         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));
9862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
9863                 }
9864                 if (r->transport_obj_dn) {
9865                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9866                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
9867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
9868                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
9869                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
9870                                 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));
9871                         }
9872                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
9873                         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));
9874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
9875                 }
9876         }
9877         return NDR_ERR_SUCCESS;
9878 }
9879
9880 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
9881 {
9882         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
9883         ndr->depth++;
9884         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
9885         ndr->depth++;
9886         if (r->naming_context_dn) {
9887                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
9888         }
9889         ndr->depth--;
9890         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
9891         ndr->depth++;
9892         if (r->source_dsa_obj_dn) {
9893                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
9894         }
9895         ndr->depth--;
9896         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
9897         ndr->depth++;
9898         if (r->source_dsa_address) {
9899                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
9900         }
9901         ndr->depth--;
9902         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
9903         ndr->depth++;
9904         if (r->transport_obj_dn) {
9905                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
9906         }
9907         ndr->depth--;
9908         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
9909         ndr_print_uint32(ndr, "reserved", r->reserved);
9910         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
9911         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
9912         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
9913         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
9914         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
9915         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
9916         ndr_print_NTTIME(ndr, "last_success", r->last_success);
9917         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
9918         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
9919         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
9920         ndr->depth--;
9921 }
9922
9923 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
9924 {
9925         uint32_t cntr_array_0;
9926         if (ndr_flags & NDR_SCALARS) {
9927                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9928                 NDR_CHECK(ndr_push_align(ndr, 8));
9929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9931                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9932                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9933                 }
9934         }
9935         if (ndr_flags & NDR_BUFFERS) {
9936                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9937                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9938                 }
9939         }
9940         return NDR_ERR_SUCCESS;
9941 }
9942
9943 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
9944 {
9945         uint32_t cntr_array_0;
9946         TALLOC_CTX *_mem_save_array_0;
9947         if (ndr_flags & NDR_SCALARS) {
9948                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9949                 NDR_CHECK(ndr_pull_align(ndr, 8));
9950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9952                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9953                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9954                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9955                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9956                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9957                 }
9958                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9959                 if (r->array) {
9960                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9961                 }
9962         }
9963         if (ndr_flags & NDR_BUFFERS) {
9964                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9965                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9966                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9967                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9968                 }
9969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9970         }
9971         return NDR_ERR_SUCCESS;
9972 }
9973
9974 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
9975 {
9976         uint32_t cntr_array_0;
9977         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
9978         ndr->depth++;
9979         ndr_print_uint32(ndr, "count", r->count);
9980         ndr_print_uint32(ndr, "reserved", r->reserved);
9981         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9982         ndr->depth++;
9983         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9984                 char *idx_0=NULL;
9985                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9986                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
9987                         free(idx_0);
9988                 }
9989         }
9990         ndr->depth--;
9991         ndr->depth--;
9992 }
9993
9994 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
9995 {
9996         uint32_t cntr_array_0;
9997         if (ndr_flags & NDR_SCALARS) {
9998                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9999                 NDR_CHECK(ndr_push_align(ndr, 8));
10000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10002                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10003                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10004                 }
10005         }
10006         if (ndr_flags & NDR_BUFFERS) {
10007         }
10008         return NDR_ERR_SUCCESS;
10009 }
10010
10011 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10012 {
10013         uint32_t cntr_array_0;
10014         TALLOC_CTX *_mem_save_array_0;
10015         if (ndr_flags & NDR_SCALARS) {
10016                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10017                 NDR_CHECK(ndr_pull_align(ndr, 8));
10018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10020                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10021                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10022                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10023                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10024                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10025                 }
10026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10027                 if (r->array) {
10028                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10029                 }
10030         }
10031         if (ndr_flags & NDR_BUFFERS) {
10032         }
10033         return NDR_ERR_SUCCESS;
10034 }
10035
10036 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10037 {
10038         uint32_t cntr_array_0;
10039         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10040         ndr->depth++;
10041         ndr_print_uint32(ndr, "count", r->count);
10042         ndr_print_uint32(ndr, "reserved", r->reserved);
10043         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10044         ndr->depth++;
10045         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10046                 char *idx_0=NULL;
10047                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10048                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10049                         free(idx_0);
10050                 }
10051         }
10052         ndr->depth--;
10053         ndr->depth--;
10054 }
10055
10056 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10057 {
10058         if (ndr_flags & NDR_SCALARS) {
10059                 NDR_CHECK(ndr_push_align(ndr, 8));
10060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10062                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10063                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10064                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10065                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10066         }
10067         if (ndr_flags & NDR_BUFFERS) {
10068                 if (r->attribute_name) {
10069                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10070                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10072                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10073                 }
10074         }
10075         return NDR_ERR_SUCCESS;
10076 }
10077
10078 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10079 {
10080         uint32_t _ptr_attribute_name;
10081         TALLOC_CTX *_mem_save_attribute_name_0;
10082         if (ndr_flags & NDR_SCALARS) {
10083                 NDR_CHECK(ndr_pull_align(ndr, 8));
10084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10085                 if (_ptr_attribute_name) {
10086                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10087                 } else {
10088                         r->attribute_name = NULL;
10089                 }
10090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10091                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10092                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10093                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10094                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10095         }
10096         if (ndr_flags & NDR_BUFFERS) {
10097                 if (r->attribute_name) {
10098                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10099                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10102                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10103                                 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));
10104                         }
10105                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10106                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10108                 }
10109         }
10110         return NDR_ERR_SUCCESS;
10111 }
10112
10113 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10114 {
10115         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10116         ndr->depth++;
10117         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10118         ndr->depth++;
10119         if (r->attribute_name) {
10120                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10121         }
10122         ndr->depth--;
10123         ndr_print_uint32(ndr, "version", r->version);
10124         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10125         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10126         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10127         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10128         ndr->depth--;
10129 }
10130
10131 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10132 {
10133         uint32_t cntr_array_0;
10134         if (ndr_flags & NDR_SCALARS) {
10135                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10136                 NDR_CHECK(ndr_push_align(ndr, 8));
10137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10139                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10140                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10141                 }
10142         }
10143         if (ndr_flags & NDR_BUFFERS) {
10144                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10145                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10146                 }
10147         }
10148         return NDR_ERR_SUCCESS;
10149 }
10150
10151 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10152 {
10153         uint32_t cntr_array_0;
10154         TALLOC_CTX *_mem_save_array_0;
10155         if (ndr_flags & NDR_SCALARS) {
10156                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10157                 NDR_CHECK(ndr_pull_align(ndr, 8));
10158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10160                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10161                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10162                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10163                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10164                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10165                 }
10166                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10167                 if (r->array) {
10168                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10169                 }
10170         }
10171         if (ndr_flags & NDR_BUFFERS) {
10172                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10173                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10174                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10175                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10176                 }
10177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10178         }
10179         return NDR_ERR_SUCCESS;
10180 }
10181
10182 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10183 {
10184         uint32_t cntr_array_0;
10185         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10186         ndr->depth++;
10187         ndr_print_uint32(ndr, "count", r->count);
10188         ndr_print_uint32(ndr, "reserved", r->reserved);
10189         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10190         ndr->depth++;
10191         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10192                 char *idx_0=NULL;
10193                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10194                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10195                         free(idx_0);
10196                 }
10197         }
10198         ndr->depth--;
10199         ndr->depth--;
10200 }
10201
10202 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10203 {
10204         if (ndr_flags & NDR_SCALARS) {
10205                 NDR_CHECK(ndr_push_align(ndr, 5));
10206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10207                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10208                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10211         }
10212         if (ndr_flags & NDR_BUFFERS) {
10213                 if (r->dsa_obj_dn) {
10214                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10216                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10217                         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));
10218                 }
10219         }
10220         return NDR_ERR_SUCCESS;
10221 }
10222
10223 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10224 {
10225         uint32_t _ptr_dsa_obj_dn;
10226         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10227         if (ndr_flags & NDR_SCALARS) {
10228                 NDR_CHECK(ndr_pull_align(ndr, 5));
10229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10230                 if (_ptr_dsa_obj_dn) {
10231                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10232                 } else {
10233                         r->dsa_obj_dn = NULL;
10234                 }
10235                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10236                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10238                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10239         }
10240         if (ndr_flags & NDR_BUFFERS) {
10241                 if (r->dsa_obj_dn) {
10242                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10243                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10246                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10247                                 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));
10248                         }
10249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10250                         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));
10251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10252                 }
10253         }
10254         return NDR_ERR_SUCCESS;
10255 }
10256
10257 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10258 {
10259         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10260         ndr->depth++;
10261         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10262         ndr->depth++;
10263         if (r->dsa_obj_dn) {
10264                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10265         }
10266         ndr->depth--;
10267         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10268         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10269         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10270         ndr_print_WERROR(ndr, "last_result", r->last_result);
10271         ndr->depth--;
10272 }
10273
10274 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10275 {
10276         uint32_t cntr_array_0;
10277         if (ndr_flags & NDR_SCALARS) {
10278                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10279                 NDR_CHECK(ndr_push_align(ndr, 5));
10280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10282                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10283                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10284                 }
10285         }
10286         if (ndr_flags & NDR_BUFFERS) {
10287                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10288                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10289                 }
10290         }
10291         return NDR_ERR_SUCCESS;
10292 }
10293
10294 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10295 {
10296         uint32_t cntr_array_0;
10297         TALLOC_CTX *_mem_save_array_0;
10298         if (ndr_flags & NDR_SCALARS) {
10299                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10300                 NDR_CHECK(ndr_pull_align(ndr, 5));
10301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10303                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10304                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10305                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10306                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10307                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10308                 }
10309                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10310                 if (r->array) {
10311                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10312                 }
10313         }
10314         if (ndr_flags & NDR_BUFFERS) {
10315                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10316                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10317                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10318                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10319                 }
10320                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10321         }
10322         return NDR_ERR_SUCCESS;
10323 }
10324
10325 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10326 {
10327         uint32_t cntr_array_0;
10328         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10329         ndr->depth++;
10330         ndr_print_uint32(ndr, "count", r->count);
10331         ndr_print_uint32(ndr, "reserved", r->reserved);
10332         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10333         ndr->depth++;
10334         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10335                 char *idx_0=NULL;
10336                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10337                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10338                         free(idx_0);
10339                 }
10340         }
10341         ndr->depth--;
10342         ndr->depth--;
10343 }
10344
10345 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10346 {
10347         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
10348         return NDR_ERR_SUCCESS;
10349 }
10350
10351 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10352 {
10353         uint16_t v;
10354         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
10355         *r = v;
10356         return NDR_ERR_SUCCESS;
10357 }
10358
10359 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10360 {
10361         const char *val = NULL;
10362
10363         switch (r) {
10364                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10365                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10366                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10367                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10368                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10369         }
10370         ndr_print_enum(ndr, name, "ENUM", val, r);
10371 }
10372
10373 static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
10374 {
10375         if (ndr_flags & NDR_SCALARS) {
10376                 int level = ndr_push_get_switch_value(ndr, r);
10377                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
10378                 switch (level) {
10379                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10380                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
10381                         break; }
10382
10383                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10384                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
10385                         break; }
10386
10387                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10388                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
10389                         break; }
10390
10391                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10392                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
10393                         break; }
10394
10395                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10396                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
10397                         break; }
10398
10399                         default: {
10400                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
10401                         break; }
10402
10403                 }
10404         }
10405         if (ndr_flags & NDR_BUFFERS) {
10406                 int level = ndr_push_get_switch_value(ndr, r);
10407                 switch (level) {
10408                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10409                         break;
10410
10411                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10412                         break;
10413
10414                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10415                         break;
10416
10417                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10418                         break;
10419
10420                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10421                         break;
10422
10423                         default:
10424                         break;
10425
10426                 }
10427         }
10428         return NDR_ERR_SUCCESS;
10429 }
10430
10431 static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
10432 {
10433         int level;
10434         uint16_t _level;
10435         level = ndr_pull_get_switch_value(ndr, r);
10436         if (ndr_flags & NDR_SCALARS) {
10437                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
10438                 if (_level != level) {
10439                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10440                 }
10441                 switch (level) {
10442                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10443                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
10444                         break; }
10445
10446                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10447                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
10448                         break; }
10449
10450                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10451                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
10452                         break; }
10453
10454                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10455                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
10456                         break; }
10457
10458                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10459                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
10460                         break; }
10461
10462                         default: {
10463                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
10464                         break; }
10465
10466                 }
10467         }
10468         if (ndr_flags & NDR_BUFFERS) {
10469                 switch (level) {
10470                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10471                         break;
10472
10473                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10474                         break;
10475
10476                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10477                         break;
10478
10479                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10480                         break;
10481
10482                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10483                         break;
10484
10485                         default:
10486                         break;
10487
10488                 }
10489         }
10490         return NDR_ERR_SUCCESS;
10491 }
10492
10493 _PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
10494 {
10495         int level;
10496         level = ndr_print_get_switch_value(ndr, r);
10497         ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
10498         switch (level) {
10499                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10500                         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
10501                 break;
10502
10503                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10504                         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
10505                 break;
10506
10507                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10508                         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
10509                 break;
10510
10511                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10512                         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
10513                 break;
10514
10515                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10516                         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
10517                 break;
10518
10519                 default:
10520                         ndr_print_uint32(ndr, "unknown", r->unknown);
10521                 break;
10522
10523         }
10524 }
10525
10526 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10527 {
10528         if (ndr_flags & NDR_SCALARS) {
10529                 NDR_CHECK(ndr_push_align(ndr, 5));
10530                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10533                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10534                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
10535                 NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10536                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10539                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10540                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10541         }
10542         if (ndr_flags & NDR_BUFFERS) {
10543                 if (r->nc_dn) {
10544                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10545                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10546                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10547                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10548                 }
10549                 if (r->remote_dsa_obj_dn) {
10550                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10551                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10552                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10553                         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));
10554                 }
10555                 if (r->remote_dsa_address) {
10556                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10557                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10558                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10559                         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));
10560                 }
10561         }
10562         return NDR_ERR_SUCCESS;
10563 }
10564
10565 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10566 {
10567         uint32_t _ptr_nc_dn;
10568         TALLOC_CTX *_mem_save_nc_dn_0;
10569         uint32_t _ptr_remote_dsa_obj_dn;
10570         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10571         uint32_t _ptr_remote_dsa_address;
10572         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10573         if (ndr_flags & NDR_SCALARS) {
10574                 NDR_CHECK(ndr_pull_align(ndr, 5));
10575                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10578                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10579                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
10580                 NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10582                 if (_ptr_nc_dn) {
10583                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10584                 } else {
10585                         r->nc_dn = NULL;
10586                 }
10587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10588                 if (_ptr_remote_dsa_obj_dn) {
10589                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10590                 } else {
10591                         r->remote_dsa_obj_dn = NULL;
10592                 }
10593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10594                 if (_ptr_remote_dsa_address) {
10595                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10596                 } else {
10597                         r->remote_dsa_address = NULL;
10598                 }
10599                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10600                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10601         }
10602         if (ndr_flags & NDR_BUFFERS) {
10603                 if (r->nc_dn) {
10604                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10605                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10606                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10607                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10608                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10609                                 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));
10610                         }
10611                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10612                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10613                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10614                 }
10615                 if (r->remote_dsa_obj_dn) {
10616                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10617                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10620                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10621                                 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));
10622                         }
10623                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10624                         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));
10625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10626                 }
10627                 if (r->remote_dsa_address) {
10628                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10629                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10632                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10633                                 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));
10634                         }
10635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10636                         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));
10637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10638                 }
10639         }
10640         return NDR_ERR_SUCCESS;
10641 }
10642
10643 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10644 {
10645         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10646         ndr->depth++;
10647         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10648         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10649         ndr_print_uint32(ndr, "priority", r->priority);
10650         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10651         ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
10652         ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
10653         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10654         ndr->depth++;
10655         if (r->nc_dn) {
10656                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10657         }
10658         ndr->depth--;
10659         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10660         ndr->depth++;
10661         if (r->remote_dsa_obj_dn) {
10662                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10663         }
10664         ndr->depth--;
10665         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10666         ndr->depth++;
10667         if (r->remote_dsa_address) {
10668                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10669         }
10670         ndr->depth--;
10671         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10672         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10673         ndr->depth--;
10674 }
10675
10676 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10677 {
10678         uint32_t cntr_array_0;
10679         if (ndr_flags & NDR_SCALARS) {
10680                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10681                 NDR_CHECK(ndr_push_align(ndr, 5));
10682                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10684                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10685                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10686                 }
10687         }
10688         if (ndr_flags & NDR_BUFFERS) {
10689                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10690                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10691                 }
10692         }
10693         return NDR_ERR_SUCCESS;
10694 }
10695
10696 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10697 {
10698         uint32_t cntr_array_0;
10699         TALLOC_CTX *_mem_save_array_0;
10700         if (ndr_flags & NDR_SCALARS) {
10701                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10702                 NDR_CHECK(ndr_pull_align(ndr, 5));
10703                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10705                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10706                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10707                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10708                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10709                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10710                 }
10711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10712                 if (r->array) {
10713                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10714                 }
10715         }
10716         if (ndr_flags & NDR_BUFFERS) {
10717                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10718                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10719                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10720                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10721                 }
10722                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10723         }
10724         return NDR_ERR_SUCCESS;
10725 }
10726
10727 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10728 {
10729         uint32_t cntr_array_0;
10730         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10731         ndr->depth++;
10732         ndr_print_NTTIME(ndr, "time", r->time);
10733         ndr_print_uint32(ndr, "count", r->count);
10734         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10735         ndr->depth++;
10736         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10737                 char *idx_0=NULL;
10738                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10739                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10740                         free(idx_0);
10741                 }
10742         }
10743         ndr->depth--;
10744         ndr->depth--;
10745 }
10746
10747 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10748 {
10749         if (ndr_flags & NDR_SCALARS) {
10750                 NDR_CHECK(ndr_push_align(ndr, 8));
10751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10755                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10756                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10758                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10759                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10760                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10761                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10762         }
10763         if (ndr_flags & NDR_BUFFERS) {
10764                 if (r->attribute_name) {
10765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10766                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10767                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10768                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10769                 }
10770                 if (r->object_dn) {
10771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10773                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10774                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10775                 }
10776                 if (r->binary) {
10777                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10778                 }
10779         }
10780         return NDR_ERR_SUCCESS;
10781 }
10782
10783 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10784 {
10785         uint32_t _ptr_attribute_name;
10786         TALLOC_CTX *_mem_save_attribute_name_0;
10787         uint32_t _ptr_object_dn;
10788         TALLOC_CTX *_mem_save_object_dn_0;
10789         uint32_t _ptr_binary;
10790         TALLOC_CTX *_mem_save_binary_0;
10791         if (ndr_flags & NDR_SCALARS) {
10792                 NDR_CHECK(ndr_pull_align(ndr, 8));
10793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10794                 if (_ptr_attribute_name) {
10795                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10796                 } else {
10797                         r->attribute_name = NULL;
10798                 }
10799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10800                 if (_ptr_object_dn) {
10801                         NDR_PULL_ALLOC(ndr, r->object_dn);
10802                 } else {
10803                         r->object_dn = NULL;
10804                 }
10805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10806                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10807                 if (_ptr_binary) {
10808                         NDR_PULL_ALLOC(ndr, r->binary);
10809                 } else {
10810                         r->binary = NULL;
10811                 }
10812                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10813                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10815                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10816                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10817                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10818                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10819         }
10820         if (ndr_flags & NDR_BUFFERS) {
10821                 if (r->attribute_name) {
10822                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10823                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10824                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10825                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10826                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10827                                 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));
10828                         }
10829                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10830                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10831                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10832                 }
10833                 if (r->object_dn) {
10834                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10835                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10836                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10837                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10838                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10839                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
10840                         }
10841                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10842                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10844                 }
10845                 if (r->binary) {
10846                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10847                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10848                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10850                 }
10851         }
10852         return NDR_ERR_SUCCESS;
10853 }
10854
10855 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10856 {
10857         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10858         ndr->depth++;
10859         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10860         ndr->depth++;
10861         if (r->attribute_name) {
10862                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10863         }
10864         ndr->depth--;
10865         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10866         ndr->depth++;
10867         if (r->object_dn) {
10868                 ndr_print_string(ndr, "object_dn", r->object_dn);
10869         }
10870         ndr->depth--;
10871         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);
10872         ndr_print_ptr(ndr, "binary", r->binary);
10873         ndr->depth++;
10874         if (r->binary) {
10875                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10876         }
10877         ndr->depth--;
10878         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10879         ndr_print_NTTIME(ndr, "created", r->created);
10880         ndr_print_uint32(ndr, "version", r->version);
10881         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10882         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10883         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10884         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10885         ndr->depth--;
10886 }
10887
10888 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10889 {
10890         uint32_t cntr_array_0;
10891         if (ndr_flags & NDR_SCALARS) {
10892                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10893                 NDR_CHECK(ndr_push_align(ndr, 8));
10894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10895                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10896                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10897                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10898                 }
10899         }
10900         if (ndr_flags & NDR_BUFFERS) {
10901                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10902                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10903                 }
10904         }
10905         return NDR_ERR_SUCCESS;
10906 }
10907
10908 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10909 {
10910         uint32_t cntr_array_0;
10911         TALLOC_CTX *_mem_save_array_0;
10912         if (ndr_flags & NDR_SCALARS) {
10913                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10914                 NDR_CHECK(ndr_pull_align(ndr, 8));
10915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10916                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10917                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10918                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10919                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10920                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10921                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10922                 }
10923                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10924                 if (r->array) {
10925                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10926                 }
10927         }
10928         if (ndr_flags & NDR_BUFFERS) {
10929                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10930                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10931                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10932                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10933                 }
10934                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10935         }
10936         return NDR_ERR_SUCCESS;
10937 }
10938
10939 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10940 {
10941         uint32_t cntr_array_0;
10942         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10943         ndr->depth++;
10944         ndr_print_uint32(ndr, "count", r->count);
10945         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10946         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10947         ndr->depth++;
10948         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10949                 char *idx_0=NULL;
10950                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10951                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10952                         free(idx_0);
10953                 }
10954         }
10955         ndr->depth--;
10956         ndr->depth--;
10957 }
10958
10959 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
10960 {
10961         uint32_t cntr_array_0;
10962         if (ndr_flags & NDR_SCALARS) {
10963                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10964                 NDR_CHECK(ndr_push_align(ndr, 8));
10965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10966                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10967                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10968                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10969                 }
10970         }
10971         if (ndr_flags & NDR_BUFFERS) {
10972         }
10973         return NDR_ERR_SUCCESS;
10974 }
10975
10976 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
10977 {
10978         uint32_t cntr_array_0;
10979         TALLOC_CTX *_mem_save_array_0;
10980         if (ndr_flags & NDR_SCALARS) {
10981                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10982                 NDR_CHECK(ndr_pull_align(ndr, 8));
10983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10984                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10985                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10986                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10987                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10988                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10989                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10990                 }
10991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10992                 if (r->array) {
10993                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10994                 }
10995         }
10996         if (ndr_flags & NDR_BUFFERS) {
10997         }
10998         return NDR_ERR_SUCCESS;
10999 }
11000
11001 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11002 {
11003         uint32_t cntr_array_0;
11004         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11005         ndr->depth++;
11006         ndr_print_uint32(ndr, "count", r->count);
11007         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11008         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11009         ndr->depth++;
11010         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11011                 char *idx_0=NULL;
11012                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11013                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11014                         free(idx_0);
11015                 }
11016         }
11017         ndr->depth--;
11018         ndr->depth--;
11019 }
11020
11021 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11022 {
11023         if (ndr_flags & NDR_SCALARS) {
11024                 NDR_CHECK(ndr_push_align(ndr, 8));
11025                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11026                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11027                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11029         }
11030         if (ndr_flags & NDR_BUFFERS) {
11031                 if (r->source_dsa_obj_dn) {
11032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11035                         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));
11036                 }
11037         }
11038         return NDR_ERR_SUCCESS;
11039 }
11040
11041 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11042 {
11043         uint32_t _ptr_source_dsa_obj_dn;
11044         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11045         if (ndr_flags & NDR_SCALARS) {
11046                 NDR_CHECK(ndr_pull_align(ndr, 8));
11047                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11048                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11049                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11050                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11051                 if (_ptr_source_dsa_obj_dn) {
11052                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11053                 } else {
11054                         r->source_dsa_obj_dn = NULL;
11055                 }
11056         }
11057         if (ndr_flags & NDR_BUFFERS) {
11058                 if (r->source_dsa_obj_dn) {
11059                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11060                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11062                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11063                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11064                                 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));
11065                         }
11066                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11067                         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));
11068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11069                 }
11070         }
11071         return NDR_ERR_SUCCESS;
11072 }
11073
11074 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11075 {
11076         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11077         ndr->depth++;
11078         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11079         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11080         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11081         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11082         ndr->depth++;
11083         if (r->source_dsa_obj_dn) {
11084                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11085         }
11086         ndr->depth--;
11087         ndr->depth--;
11088 }
11089
11090 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11091 {
11092         uint32_t cntr_array_0;
11093         if (ndr_flags & NDR_SCALARS) {
11094                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11095                 NDR_CHECK(ndr_push_align(ndr, 8));
11096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11097                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11098                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11099                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11100                 }
11101         }
11102         if (ndr_flags & NDR_BUFFERS) {
11103                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11104                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11105                 }
11106         }
11107         return NDR_ERR_SUCCESS;
11108 }
11109
11110 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11111 {
11112         uint32_t cntr_array_0;
11113         TALLOC_CTX *_mem_save_array_0;
11114         if (ndr_flags & NDR_SCALARS) {
11115                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11116                 NDR_CHECK(ndr_pull_align(ndr, 8));
11117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11118                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11119                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11120                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11121                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11122                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11123                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11124                 }
11125                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11126                 if (r->array) {
11127                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11128                 }
11129         }
11130         if (ndr_flags & NDR_BUFFERS) {
11131                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11132                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11133                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11134                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11135                 }
11136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11137         }
11138         return NDR_ERR_SUCCESS;
11139 }
11140
11141 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11142 {
11143         uint32_t cntr_array_0;
11144         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11145         ndr->depth++;
11146         ndr_print_uint32(ndr, "count", r->count);
11147         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11148         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11149         ndr->depth++;
11150         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11151                 char *idx_0=NULL;
11152                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11153                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11154                         free(idx_0);
11155                 }
11156         }
11157         ndr->depth--;
11158         ndr->depth--;
11159 }
11160
11161 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11162 {
11163         if (ndr_flags & NDR_SCALARS) {
11164                 NDR_CHECK(ndr_push_align(ndr, 8));
11165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11167                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11168                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11169                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11170                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11172         }
11173         if (ndr_flags & NDR_BUFFERS) {
11174                 if (r->attribute_name) {
11175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11178                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11179                 }
11180                 if (r->originating_dsa_dn) {
11181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11184                         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));
11185                 }
11186         }
11187         return NDR_ERR_SUCCESS;
11188 }
11189
11190 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11191 {
11192         uint32_t _ptr_attribute_name;
11193         TALLOC_CTX *_mem_save_attribute_name_0;
11194         uint32_t _ptr_originating_dsa_dn;
11195         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11196         if (ndr_flags & NDR_SCALARS) {
11197                 NDR_CHECK(ndr_pull_align(ndr, 8));
11198                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11199                 if (_ptr_attribute_name) {
11200                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11201                 } else {
11202                         r->attribute_name = NULL;
11203                 }
11204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11205                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11206                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11207                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11208                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11210                 if (_ptr_originating_dsa_dn) {
11211                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11212                 } else {
11213                         r->originating_dsa_dn = NULL;
11214                 }
11215         }
11216         if (ndr_flags & NDR_BUFFERS) {
11217                 if (r->attribute_name) {
11218                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11219                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11222                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11223                                 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));
11224                         }
11225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11228                 }
11229                 if (r->originating_dsa_dn) {
11230                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11231                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11234                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11235                                 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));
11236                         }
11237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11238                         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));
11239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11240                 }
11241         }
11242         return NDR_ERR_SUCCESS;
11243 }
11244
11245 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11246 {
11247         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11248         ndr->depth++;
11249         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11250         ndr->depth++;
11251         if (r->attribute_name) {
11252                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11253         }
11254         ndr->depth--;
11255         ndr_print_uint32(ndr, "version", r->version);
11256         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11257         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11258         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11259         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11260         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11261         ndr->depth++;
11262         if (r->originating_dsa_dn) {
11263                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11264         }
11265         ndr->depth--;
11266         ndr->depth--;
11267 }
11268
11269 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11270 {
11271         uint32_t cntr_array_0;
11272         if (ndr_flags & NDR_SCALARS) {
11273                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11274                 NDR_CHECK(ndr_push_align(ndr, 8));
11275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11276                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11277                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11278                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11279                 }
11280         }
11281         if (ndr_flags & NDR_BUFFERS) {
11282                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11283                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11284                 }
11285         }
11286         return NDR_ERR_SUCCESS;
11287 }
11288
11289 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11290 {
11291         uint32_t cntr_array_0;
11292         TALLOC_CTX *_mem_save_array_0;
11293         if (ndr_flags & NDR_SCALARS) {
11294                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11295                 NDR_CHECK(ndr_pull_align(ndr, 8));
11296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11297                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11298                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11299                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11300                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11301                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11302                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11303                 }
11304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11305                 if (r->array) {
11306                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11307                 }
11308         }
11309         if (ndr_flags & NDR_BUFFERS) {
11310                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11311                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11312                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11313                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11314                 }
11315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11316         }
11317         return NDR_ERR_SUCCESS;
11318 }
11319
11320 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11321 {
11322         uint32_t cntr_array_0;
11323         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11324         ndr->depth++;
11325         ndr_print_uint32(ndr, "count", r->count);
11326         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11327         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11328         ndr->depth++;
11329         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11330                 char *idx_0=NULL;
11331                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11332                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11333                         free(idx_0);
11334                 }
11335         }
11336         ndr->depth--;
11337         ndr->depth--;
11338 }
11339
11340 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11341 {
11342         if (ndr_flags & NDR_SCALARS) {
11343                 NDR_CHECK(ndr_push_align(ndr, 8));
11344                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11348                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11349                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11351                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11352                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11353                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11354                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11356         }
11357         if (ndr_flags & NDR_BUFFERS) {
11358                 if (r->attribute_name) {
11359                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11361                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11362                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11363                 }
11364                 if (r->object_dn) {
11365                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11366                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11367                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11368                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11369                 }
11370                 if (r->binary) {
11371                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11372                 }
11373                 if (r->originating_dsa_dn) {
11374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11377                         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));
11378                 }
11379         }
11380         return NDR_ERR_SUCCESS;
11381 }
11382
11383 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11384 {
11385         uint32_t _ptr_attribute_name;
11386         TALLOC_CTX *_mem_save_attribute_name_0;
11387         uint32_t _ptr_object_dn;
11388         TALLOC_CTX *_mem_save_object_dn_0;
11389         uint32_t _ptr_binary;
11390         TALLOC_CTX *_mem_save_binary_0;
11391         uint32_t _ptr_originating_dsa_dn;
11392         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11393         if (ndr_flags & NDR_SCALARS) {
11394                 NDR_CHECK(ndr_pull_align(ndr, 8));
11395                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11396                 if (_ptr_attribute_name) {
11397                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11398                 } else {
11399                         r->attribute_name = NULL;
11400                 }
11401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11402                 if (_ptr_object_dn) {
11403                         NDR_PULL_ALLOC(ndr, r->object_dn);
11404                 } else {
11405                         r->object_dn = NULL;
11406                 }
11407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11408                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11409                 if (_ptr_binary) {
11410                         NDR_PULL_ALLOC(ndr, r->binary);
11411                 } else {
11412                         r->binary = NULL;
11413                 }
11414                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11415                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11417                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11418                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11419                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11420                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11422                 if (_ptr_originating_dsa_dn) {
11423                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11424                 } else {
11425                         r->originating_dsa_dn = NULL;
11426                 }
11427         }
11428         if (ndr_flags & NDR_BUFFERS) {
11429                 if (r->attribute_name) {
11430                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11431                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11432                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11433                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11434                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11435                                 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));
11436                         }
11437                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11438                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11440                 }
11441                 if (r->object_dn) {
11442                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11443                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11445                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11446                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11447                                 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));
11448                         }
11449                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11450                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11452                 }
11453                 if (r->binary) {
11454                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11455                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11456                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11457                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11458                 }
11459                 if (r->originating_dsa_dn) {
11460                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11461                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11462                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11463                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11464                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11465                                 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));
11466                         }
11467                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11468                         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));
11469                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11470                 }
11471         }
11472         return NDR_ERR_SUCCESS;
11473 }
11474
11475 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11476 {
11477         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11478         ndr->depth++;
11479         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11480         ndr->depth++;
11481         if (r->attribute_name) {
11482                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11483         }
11484         ndr->depth--;
11485         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11486         ndr->depth++;
11487         if (r->object_dn) {
11488                 ndr_print_string(ndr, "object_dn", r->object_dn);
11489         }
11490         ndr->depth--;
11491         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);
11492         ndr_print_ptr(ndr, "binary", r->binary);
11493         ndr->depth++;
11494         if (r->binary) {
11495                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11496         }
11497         ndr->depth--;
11498         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11499         ndr_print_NTTIME(ndr, "created", r->created);
11500         ndr_print_uint32(ndr, "version", r->version);
11501         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11502         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11503         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11504         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11505         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11506         ndr->depth++;
11507         if (r->originating_dsa_dn) {
11508                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11509         }
11510         ndr->depth--;
11511         ndr->depth--;
11512 }
11513
11514 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11515 {
11516         uint32_t cntr_array_0;
11517         if (ndr_flags & NDR_SCALARS) {
11518                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11519                 NDR_CHECK(ndr_push_align(ndr, 8));
11520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11521                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11522                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11523                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11524                 }
11525         }
11526         if (ndr_flags & NDR_BUFFERS) {
11527                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11528                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11529                 }
11530         }
11531         return NDR_ERR_SUCCESS;
11532 }
11533
11534 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11535 {
11536         uint32_t cntr_array_0;
11537         TALLOC_CTX *_mem_save_array_0;
11538         if (ndr_flags & NDR_SCALARS) {
11539                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11540                 NDR_CHECK(ndr_pull_align(ndr, 8));
11541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11542                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11543                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11544                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11545                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11546                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11547                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11548                 }
11549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11550                 if (r->array) {
11551                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11552                 }
11553         }
11554         if (ndr_flags & NDR_BUFFERS) {
11555                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11556                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11557                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11558                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11559                 }
11560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11561         }
11562         return NDR_ERR_SUCCESS;
11563 }
11564
11565 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11566 {
11567         uint32_t cntr_array_0;
11568         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11569         ndr->depth++;
11570         ndr_print_uint32(ndr, "count", r->count);
11571         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11572         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11573         ndr->depth++;
11574         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11575                 char *idx_0=NULL;
11576                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11577                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11578                         free(idx_0);
11579                 }
11580         }
11581         ndr->depth--;
11582         ndr->depth--;
11583 }
11584
11585 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11586 {
11587         if (ndr_flags & NDR_SCALARS) {
11588                 NDR_CHECK(ndr_push_align(ndr, 8));
11589                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11592                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11593                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11594                 {
11595                         uint32_t _flags_save_ipv4address = ndr->flags;
11596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11597                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11598                         ndr->flags = _flags_save_ipv4address;
11599                 }
11600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11601         }
11602         if (ndr_flags & NDR_BUFFERS) {
11603         }
11604         return NDR_ERR_SUCCESS;
11605 }
11606
11607 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11608 {
11609         if (ndr_flags & NDR_SCALARS) {
11610                 NDR_CHECK(ndr_pull_align(ndr, 8));
11611                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11614                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11615                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11616                 {
11617                         uint32_t _flags_save_ipv4address = ndr->flags;
11618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11619                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11620                         ndr->flags = _flags_save_ipv4address;
11621                 }
11622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11623         }
11624         if (ndr_flags & NDR_BUFFERS) {
11625         }
11626         return NDR_ERR_SUCCESS;
11627 }
11628
11629 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11630 {
11631         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11632         ndr->depth++;
11633         ndr_print_hyper(ndr, "u1", r->u1);
11634         ndr_print_uint32(ndr, "u2", r->u2);
11635         ndr_print_uint32(ndr, "u3", r->u3);
11636         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11637         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11638         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11639         ndr_print_uint32(ndr, "u5", r->u5);
11640         ndr->depth--;
11641 }
11642
11643 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11644 {
11645         uint32_t cntr_array_0;
11646         if (ndr_flags & NDR_SCALARS) {
11647                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11648                 NDR_CHECK(ndr_push_align(ndr, 8));
11649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11651                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11652                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11653                 }
11654         }
11655         if (ndr_flags & NDR_BUFFERS) {
11656         }
11657         return NDR_ERR_SUCCESS;
11658 }
11659
11660 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11661 {
11662         uint32_t cntr_array_0;
11663         TALLOC_CTX *_mem_save_array_0;
11664         if (ndr_flags & NDR_SCALARS) {
11665                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11666                 NDR_CHECK(ndr_pull_align(ndr, 8));
11667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11668                 if (r->count > 10000) {
11669                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11670                 }
11671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11672                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11673                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11674                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11675                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11676                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11677                 }
11678                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11679                 if (r->array) {
11680                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11681                 }
11682         }
11683         if (ndr_flags & NDR_BUFFERS) {
11684         }
11685         return NDR_ERR_SUCCESS;
11686 }
11687
11688 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11689 {
11690         uint32_t cntr_array_0;
11691         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11692         ndr->depth++;
11693         ndr_print_uint32(ndr, "count", r->count);
11694         ndr_print_uint32(ndr, "reserved", r->reserved);
11695         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11696         ndr->depth++;
11697         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11698                 char *idx_0=NULL;
11699                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11700                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11701                         free(idx_0);
11702                 }
11703         }
11704         ndr->depth--;
11705         ndr->depth--;
11706 }
11707
11708 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11709 {
11710         if (ndr_flags & NDR_SCALARS) {
11711                 NDR_CHECK(ndr_push_align(ndr, 8));
11712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11718                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11720         }
11721         if (ndr_flags & NDR_BUFFERS) {
11722                 if (r->str1) {
11723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11724                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11725                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11727                 }
11728         }
11729         return NDR_ERR_SUCCESS;
11730 }
11731
11732 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11733 {
11734         uint32_t _ptr_str1;
11735         TALLOC_CTX *_mem_save_str1_0;
11736         if (ndr_flags & NDR_SCALARS) {
11737                 NDR_CHECK(ndr_pull_align(ndr, 8));
11738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11739                 if (_ptr_str1) {
11740                         NDR_PULL_ALLOC(ndr, r->str1);
11741                 } else {
11742                         r->str1 = NULL;
11743                 }
11744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11749                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11751         }
11752         if (ndr_flags & NDR_BUFFERS) {
11753                 if (r->str1) {
11754                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11755                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11756                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11757                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11758                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11759                                 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));
11760                         }
11761                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11762                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11764                 }
11765         }
11766         return NDR_ERR_SUCCESS;
11767 }
11768
11769 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11770 {
11771         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11772         ndr->depth++;
11773         ndr_print_ptr(ndr, "str1", r->str1);
11774         ndr->depth++;
11775         if (r->str1) {
11776                 ndr_print_string(ndr, "str1", r->str1);
11777         }
11778         ndr->depth--;
11779         ndr_print_uint32(ndr, "u1", r->u1);
11780         ndr_print_uint32(ndr, "u2", r->u2);
11781         ndr_print_uint32(ndr, "u3", r->u3);
11782         ndr_print_uint32(ndr, "u4", r->u4);
11783         ndr_print_uint32(ndr, "u5", r->u5);
11784         ndr_print_hyper(ndr, "u6", r->u6);
11785         ndr_print_uint32(ndr, "u7", r->u7);
11786         ndr->depth--;
11787 }
11788
11789 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11790 {
11791         uint32_t cntr_array_0;
11792         if (ndr_flags & NDR_SCALARS) {
11793                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11794                 NDR_CHECK(ndr_push_align(ndr, 8));
11795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11797                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11798                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11799                 }
11800         }
11801         if (ndr_flags & NDR_BUFFERS) {
11802                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11803                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11804                 }
11805         }
11806         return NDR_ERR_SUCCESS;
11807 }
11808
11809 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11810 {
11811         uint32_t cntr_array_0;
11812         TALLOC_CTX *_mem_save_array_0;
11813         if (ndr_flags & NDR_SCALARS) {
11814                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11815                 NDR_CHECK(ndr_pull_align(ndr, 8));
11816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11817                 if (r->count > 256) {
11818                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11819                 }
11820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11821                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11822                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11823                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11824                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11825                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11826                 }
11827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11828                 if (r->array) {
11829                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11830                 }
11831         }
11832         if (ndr_flags & NDR_BUFFERS) {
11833                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11834                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11835                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11836                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11837                 }
11838                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11839         }
11840         return NDR_ERR_SUCCESS;
11841 }
11842
11843 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11844 {
11845         uint32_t cntr_array_0;
11846         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11847         ndr->depth++;
11848         ndr_print_uint32(ndr, "count", r->count);
11849         ndr_print_uint32(ndr, "reserved", r->reserved);
11850         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11851         ndr->depth++;
11852         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11853                 char *idx_0=NULL;
11854                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11855                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11856                         free(idx_0);
11857                 }
11858         }
11859         ndr->depth--;
11860         ndr->depth--;
11861 }
11862
11863 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11864 {
11865         if (ndr_flags & NDR_SCALARS) {
11866                 int level = ndr_push_get_switch_value(ndr, r);
11867                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11868                 switch (level) {
11869                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11870                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11871                         break; }
11872
11873                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11874                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11875                         break; }
11876
11877                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11878                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11879                         break; }
11880
11881                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11882                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11883                         break; }
11884
11885                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11886                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11887                         break; }
11888
11889                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11890                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11891                         break; }
11892
11893                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11894                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11895                         break; }
11896
11897                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11898                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11899                         break; }
11900
11901                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11902                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11903                         break; }
11904
11905                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11906                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11907                         break; }
11908
11909                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11910                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11911                         break; }
11912
11913                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11914                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
11915                         break; }
11916
11917                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
11918                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
11919                         break; }
11920
11921                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
11922                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
11923                         break; }
11924
11925                         case DRSUAPI_DS_REPLICA_INFO_06: {
11926                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
11927                         break; }
11928
11929                         default:
11930                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11931                 }
11932         }
11933         if (ndr_flags & NDR_BUFFERS) {
11934                 int level = ndr_push_get_switch_value(ndr, r);
11935                 switch (level) {
11936                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11937                                 if (r->neighbours) {
11938                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11939                                 }
11940                         break;
11941
11942                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11943                                 if (r->cursors) {
11944                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11945                                 }
11946                         break;
11947
11948                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11949                                 if (r->objmetadata) {
11950                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11951                                 }
11952                         break;
11953
11954                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11955                                 if (r->connectfailures) {
11956                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11957                                 }
11958                         break;
11959
11960                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11961                                 if (r->linkfailures) {
11962                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
11963                                 }
11964                         break;
11965
11966                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11967                                 if (r->pendingops) {
11968                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
11969                                 }
11970                         break;
11971
11972                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11973                                 if (r->attrvalmetadata) {
11974                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
11975                                 }
11976                         break;
11977
11978                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11979                                 if (r->cursors2) {
11980                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
11981                                 }
11982                         break;
11983
11984                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11985                                 if (r->cursors3) {
11986                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
11987                                 }
11988                         break;
11989
11990                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11991                                 if (r->objmetadata2) {
11992                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
11993                                 }
11994                         break;
11995
11996                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
11997                                 if (r->attrvalmetadata2) {
11998                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
11999                                 }
12000                         break;
12001
12002                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12003                                 if (r->neighbours02) {
12004                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12005                                 }
12006                         break;
12007
12008                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12009                                 if (r->connections04) {
12010                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12011                                 }
12012                         break;
12013
12014                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12015                                 if (r->cursors05) {
12016                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12017                                 }
12018                         break;
12019
12020                         case DRSUAPI_DS_REPLICA_INFO_06:
12021                                 if (r->i06) {
12022                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12023                                 }
12024                         break;
12025
12026                         default:
12027                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12028                 }
12029         }
12030         return NDR_ERR_SUCCESS;
12031 }
12032
12033 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12034 {
12035         int level;
12036         uint32_t _level;
12037         TALLOC_CTX *_mem_save_neighbours_0;
12038         TALLOC_CTX *_mem_save_cursors_0;
12039         TALLOC_CTX *_mem_save_objmetadata_0;
12040         TALLOC_CTX *_mem_save_connectfailures_0;
12041         TALLOC_CTX *_mem_save_linkfailures_0;
12042         TALLOC_CTX *_mem_save_pendingops_0;
12043         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12044         TALLOC_CTX *_mem_save_cursors2_0;
12045         TALLOC_CTX *_mem_save_cursors3_0;
12046         TALLOC_CTX *_mem_save_objmetadata2_0;
12047         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12048         TALLOC_CTX *_mem_save_neighbours02_0;
12049         TALLOC_CTX *_mem_save_connections04_0;
12050         TALLOC_CTX *_mem_save_cursors05_0;
12051         TALLOC_CTX *_mem_save_i06_0;
12052         level = ndr_pull_get_switch_value(ndr, r);
12053         if (ndr_flags & NDR_SCALARS) {
12054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12055                 if (_level != level) {
12056                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12057                 }
12058                 switch (level) {
12059                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12060                                 uint32_t _ptr_neighbours;
12061                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12062                                 if (_ptr_neighbours) {
12063                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12064                                 } else {
12065                                         r->neighbours = NULL;
12066                                 }
12067                         break; }
12068
12069                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12070                                 uint32_t _ptr_cursors;
12071                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12072                                 if (_ptr_cursors) {
12073                                         NDR_PULL_ALLOC(ndr, r->cursors);
12074                                 } else {
12075                                         r->cursors = NULL;
12076                                 }
12077                         break; }
12078
12079                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12080                                 uint32_t _ptr_objmetadata;
12081                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12082                                 if (_ptr_objmetadata) {
12083                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12084                                 } else {
12085                                         r->objmetadata = NULL;
12086                                 }
12087                         break; }
12088
12089                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12090                                 uint32_t _ptr_connectfailures;
12091                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12092                                 if (_ptr_connectfailures) {
12093                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12094                                 } else {
12095                                         r->connectfailures = NULL;
12096                                 }
12097                         break; }
12098
12099                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12100                                 uint32_t _ptr_linkfailures;
12101                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12102                                 if (_ptr_linkfailures) {
12103                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12104                                 } else {
12105                                         r->linkfailures = NULL;
12106                                 }
12107                         break; }
12108
12109                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12110                                 uint32_t _ptr_pendingops;
12111                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12112                                 if (_ptr_pendingops) {
12113                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12114                                 } else {
12115                                         r->pendingops = NULL;
12116                                 }
12117                         break; }
12118
12119                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12120                                 uint32_t _ptr_attrvalmetadata;
12121                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12122                                 if (_ptr_attrvalmetadata) {
12123                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12124                                 } else {
12125                                         r->attrvalmetadata = NULL;
12126                                 }
12127                         break; }
12128
12129                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12130                                 uint32_t _ptr_cursors2;
12131                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12132                                 if (_ptr_cursors2) {
12133                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12134                                 } else {
12135                                         r->cursors2 = NULL;
12136                                 }
12137                         break; }
12138
12139                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12140                                 uint32_t _ptr_cursors3;
12141                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12142                                 if (_ptr_cursors3) {
12143                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12144                                 } else {
12145                                         r->cursors3 = NULL;
12146                                 }
12147                         break; }
12148
12149                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12150                                 uint32_t _ptr_objmetadata2;
12151                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12152                                 if (_ptr_objmetadata2) {
12153                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12154                                 } else {
12155                                         r->objmetadata2 = NULL;
12156                                 }
12157                         break; }
12158
12159                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12160                                 uint32_t _ptr_attrvalmetadata2;
12161                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12162                                 if (_ptr_attrvalmetadata2) {
12163                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12164                                 } else {
12165                                         r->attrvalmetadata2 = NULL;
12166                                 }
12167                         break; }
12168
12169                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12170                                 uint32_t _ptr_neighbours02;
12171                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12172                                 if (_ptr_neighbours02) {
12173                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
12174                                 } else {
12175                                         r->neighbours02 = NULL;
12176                                 }
12177                         break; }
12178
12179                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12180                                 uint32_t _ptr_connections04;
12181                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12182                                 if (_ptr_connections04) {
12183                                         NDR_PULL_ALLOC(ndr, r->connections04);
12184                                 } else {
12185                                         r->connections04 = NULL;
12186                                 }
12187                         break; }
12188
12189                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12190                                 uint32_t _ptr_cursors05;
12191                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12192                                 if (_ptr_cursors05) {
12193                                         NDR_PULL_ALLOC(ndr, r->cursors05);
12194                                 } else {
12195                                         r->cursors05 = NULL;
12196                                 }
12197                         break; }
12198
12199                         case DRSUAPI_DS_REPLICA_INFO_06: {
12200                                 uint32_t _ptr_i06;
12201                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12202                                 if (_ptr_i06) {
12203                                         NDR_PULL_ALLOC(ndr, r->i06);
12204                                 } else {
12205                                         r->i06 = NULL;
12206                                 }
12207                         break; }
12208
12209                         default:
12210                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12211                 }
12212         }
12213         if (ndr_flags & NDR_BUFFERS) {
12214                 switch (level) {
12215                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12216                                 if (r->neighbours) {
12217                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12218                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12219                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12220                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12221                                 }
12222                         break;
12223
12224                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12225                                 if (r->cursors) {
12226                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12227                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12228                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12229                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12230                                 }
12231                         break;
12232
12233                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12234                                 if (r->objmetadata) {
12235                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12236                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12237                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12238                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12239                                 }
12240                         break;
12241
12242                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12243                                 if (r->connectfailures) {
12244                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12245                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12246                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12247                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12248                                 }
12249                         break;
12250
12251                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12252                                 if (r->linkfailures) {
12253                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12254                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12255                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12256                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12257                                 }
12258                         break;
12259
12260                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12261                                 if (r->pendingops) {
12262                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12263                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12264                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12265                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12266                                 }
12267                         break;
12268
12269                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12270                                 if (r->attrvalmetadata) {
12271                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12272                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12273                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12274                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12275                                 }
12276                         break;
12277
12278                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12279                                 if (r->cursors2) {
12280                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12281                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12282                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12283                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12284                                 }
12285                         break;
12286
12287                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12288                                 if (r->cursors3) {
12289                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12290                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12291                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12292                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12293                                 }
12294                         break;
12295
12296                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12297                                 if (r->objmetadata2) {
12298                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12299                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12300                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12301                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12302                                 }
12303                         break;
12304
12305                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12306                                 if (r->attrvalmetadata2) {
12307                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12308                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12309                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12310                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12311                                 }
12312                         break;
12313
12314                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12315                                 if (r->neighbours02) {
12316                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12317                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12318                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12319                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12320                                 }
12321                         break;
12322
12323                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12324                                 if (r->connections04) {
12325                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12326                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12327                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12328                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12329                                 }
12330                         break;
12331
12332                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12333                                 if (r->cursors05) {
12334                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12335                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12336                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12337                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12338                                 }
12339                         break;
12340
12341                         case DRSUAPI_DS_REPLICA_INFO_06:
12342                                 if (r->i06) {
12343                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12344                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12345                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12346                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12347                                 }
12348                         break;
12349
12350                         default:
12351                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12352                 }
12353         }
12354         return NDR_ERR_SUCCESS;
12355 }
12356
12357 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12358 {
12359         int level;
12360         level = ndr_print_get_switch_value(ndr, r);
12361         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12362         switch (level) {
12363                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12364                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12365                         ndr->depth++;
12366                         if (r->neighbours) {
12367                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12368                         }
12369                         ndr->depth--;
12370                 break;
12371
12372                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12373                         ndr_print_ptr(ndr, "cursors", r->cursors);
12374                         ndr->depth++;
12375                         if (r->cursors) {
12376                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12377                         }
12378                         ndr->depth--;
12379                 break;
12380
12381                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12382                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12383                         ndr->depth++;
12384                         if (r->objmetadata) {
12385                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12386                         }
12387                         ndr->depth--;
12388                 break;
12389
12390                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12391                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12392                         ndr->depth++;
12393                         if (r->connectfailures) {
12394                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12395                         }
12396                         ndr->depth--;
12397                 break;
12398
12399                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12400                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12401                         ndr->depth++;
12402                         if (r->linkfailures) {
12403                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12404                         }
12405                         ndr->depth--;
12406                 break;
12407
12408                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12409                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12410                         ndr->depth++;
12411                         if (r->pendingops) {
12412                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12413                         }
12414                         ndr->depth--;
12415                 break;
12416
12417                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12418                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12419                         ndr->depth++;
12420                         if (r->attrvalmetadata) {
12421                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12422                         }
12423                         ndr->depth--;
12424                 break;
12425
12426                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12427                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12428                         ndr->depth++;
12429                         if (r->cursors2) {
12430                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12431                         }
12432                         ndr->depth--;
12433                 break;
12434
12435                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12436                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12437                         ndr->depth++;
12438                         if (r->cursors3) {
12439                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12440                         }
12441                         ndr->depth--;
12442                 break;
12443
12444                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12445                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12446                         ndr->depth++;
12447                         if (r->objmetadata2) {
12448                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12449                         }
12450                         ndr->depth--;
12451                 break;
12452
12453                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12454                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12455                         ndr->depth++;
12456                         if (r->attrvalmetadata2) {
12457                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12458                         }
12459                         ndr->depth--;
12460                 break;
12461
12462                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12463                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12464                         ndr->depth++;
12465                         if (r->neighbours02) {
12466                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12467                         }
12468                         ndr->depth--;
12469                 break;
12470
12471                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12472                         ndr_print_ptr(ndr, "connections04", r->connections04);
12473                         ndr->depth++;
12474                         if (r->connections04) {
12475                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12476                         }
12477                         ndr->depth--;
12478                 break;
12479
12480                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12481                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12482                         ndr->depth++;
12483                         if (r->cursors05) {
12484                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12485                         }
12486                         ndr->depth--;
12487                 break;
12488
12489                 case DRSUAPI_DS_REPLICA_INFO_06:
12490                         ndr_print_ptr(ndr, "i06", r->i06);
12491                         ndr->depth++;
12492                         if (r->i06) {
12493                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12494                         }
12495                         ndr->depth--;
12496                 break;
12497
12498                 default:
12499                         ndr_print_bad_level(ndr, name, level);
12500         }
12501 }
12502
12503 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12504 {
12505         if (ndr_flags & NDR_SCALARS) {
12506                 int level = ndr_push_get_switch_value(ndr, r);
12507                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12508                 switch (level) {
12509                         case 1: {
12510                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12511                         break; }
12512
12513                         default:
12514                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12515                 }
12516         }
12517         if (ndr_flags & NDR_BUFFERS) {
12518                 int level = ndr_push_get_switch_value(ndr, r);
12519                 switch (level) {
12520                         case 1:
12521                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12522                         break;
12523
12524                         default:
12525                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12526                 }
12527         }
12528         return NDR_ERR_SUCCESS;
12529 }
12530
12531 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12532 {
12533         int level;
12534         int32_t _level;
12535         level = ndr_pull_get_switch_value(ndr, r);
12536         if (ndr_flags & NDR_SCALARS) {
12537                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12538                 if (_level != level) {
12539                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12540                 }
12541                 switch (level) {
12542                         case 1: {
12543                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12544                         break; }
12545
12546                         default:
12547                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12548                 }
12549         }
12550         if (ndr_flags & NDR_BUFFERS) {
12551                 switch (level) {
12552                         case 1:
12553                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
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         return NDR_ERR_SUCCESS;
12561 }
12562
12563 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12564 {
12565         int level;
12566         level = ndr_print_get_switch_value(ndr, r);
12567         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12568         switch (level) {
12569                 case 1:
12570                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12571                 break;
12572
12573                 default:
12574                         ndr_print_bad_level(ndr, name, level);
12575         }
12576 }
12577
12578 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12579 {
12580         uint32_t cntr_req_array_1;
12581         if (ndr_flags & NDR_SCALARS) {
12582                 NDR_CHECK(ndr_push_align(ndr, 5));
12583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12584                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12585         }
12586         if (ndr_flags & NDR_BUFFERS) {
12587                 if (r->req_array) {
12588                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12589                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12590                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12591                         }
12592                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12593                                 if (r->req_array[cntr_req_array_1]) {
12594                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12595                                 }
12596                         }
12597                 }
12598         }
12599         return NDR_ERR_SUCCESS;
12600 }
12601
12602 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12603 {
12604         uint32_t _ptr_req_array;
12605         uint32_t cntr_req_array_1;
12606         TALLOC_CTX *_mem_save_req_array_0;
12607         TALLOC_CTX *_mem_save_req_array_1;
12608         TALLOC_CTX *_mem_save_req_array_2;
12609         if (ndr_flags & NDR_SCALARS) {
12610                 NDR_CHECK(ndr_pull_align(ndr, 5));
12611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12612                 if (r->num_req < 1 || r->num_req > 10000) {
12613                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12614                 }
12615                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12616                 if (_ptr_req_array) {
12617                         NDR_PULL_ALLOC(ndr, r->req_array);
12618                 } else {
12619                         r->req_array = NULL;
12620                 }
12621         }
12622         if (ndr_flags & NDR_BUFFERS) {
12623                 if (r->req_array) {
12624                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12625                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12626                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12627                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12628                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12629                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12630                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12631                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12632                                 if (_ptr_req_array) {
12633                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12634                                 } else {
12635                                         r->req_array[cntr_req_array_1] = NULL;
12636                                 }
12637                         }
12638                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12639                                 if (r->req_array[cntr_req_array_1]) {
12640                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12641                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12642                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12643                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12644                                 }
12645                         }
12646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12648                 }
12649                 if (r->req_array) {
12650                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12651                 }
12652         }
12653         return NDR_ERR_SUCCESS;
12654 }
12655
12656 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12657 {
12658         uint32_t cntr_req_array_1;
12659         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12660         ndr->depth++;
12661         ndr_print_uint32(ndr, "num_req", r->num_req);
12662         ndr_print_ptr(ndr, "req_array", r->req_array);
12663         ndr->depth++;
12664         if (r->req_array) {
12665                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12666                 ndr->depth++;
12667                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12668                         char *idx_1=NULL;
12669                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12670                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12671                                 ndr->depth++;
12672                                 if (r->req_array[cntr_req_array_1]) {
12673                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12674                                 }
12675                                 ndr->depth--;
12676                                 free(idx_1);
12677                         }
12678                 }
12679                 ndr->depth--;
12680         }
12681         ndr->depth--;
12682         ndr->depth--;
12683 }
12684
12685 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12686 {
12687         if (ndr_flags & NDR_SCALARS) {
12688                 int level = ndr_push_get_switch_value(ndr, r);
12689                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12690                 switch (level) {
12691                         case 1: {
12692                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12693                         break; }
12694
12695                         default:
12696                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12697                 }
12698         }
12699         if (ndr_flags & NDR_BUFFERS) {
12700                 int level = ndr_push_get_switch_value(ndr, r);
12701                 switch (level) {
12702                         case 1:
12703                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12704                         break;
12705
12706                         default:
12707                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12708                 }
12709         }
12710         return NDR_ERR_SUCCESS;
12711 }
12712
12713 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12714 {
12715         int level;
12716         int32_t _level;
12717         level = ndr_pull_get_switch_value(ndr, r);
12718         if (ndr_flags & NDR_SCALARS) {
12719                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12720                 if (_level != level) {
12721                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12722                 }
12723                 switch (level) {
12724                         case 1: {
12725                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12726                         break; }
12727
12728                         default:
12729                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12730                 }
12731         }
12732         if (ndr_flags & NDR_BUFFERS) {
12733                 switch (level) {
12734                         case 1:
12735                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12736                         break;
12737
12738                         default:
12739                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12740                 }
12741         }
12742         return NDR_ERR_SUCCESS;
12743 }
12744
12745 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12746 {
12747         int level;
12748         level = ndr_print_get_switch_value(ndr, r);
12749         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12750         switch (level) {
12751                 case 1:
12752                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12753                 break;
12754
12755                 default:
12756                         ndr_print_bad_level(ndr, name, level);
12757         }
12758 }
12759
12760 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12761 {
12762         if (ndr_flags & NDR_SCALARS) {
12763                 NDR_CHECK(ndr_push_align(ndr, 4));
12764                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12766         }
12767         if (ndr_flags & NDR_BUFFERS) {
12768         }
12769         return NDR_ERR_SUCCESS;
12770 }
12771
12772 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12773 {
12774         if (ndr_flags & NDR_SCALARS) {
12775                 NDR_CHECK(ndr_pull_align(ndr, 4));
12776                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12778         }
12779         if (ndr_flags & NDR_BUFFERS) {
12780         }
12781         return NDR_ERR_SUCCESS;
12782 }
12783
12784 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12785 {
12786         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12787         ndr->depth++;
12788         ndr_print_WERROR(ndr, "error_code", r->error_code);
12789         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12790         ndr->depth--;
12791 }
12792
12793 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12794 {
12795         uint32_t cntr_info_1;
12796         if (ndr_flags & NDR_SCALARS) {
12797                 NDR_CHECK(ndr_push_align(ndr, 5));
12798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12801         }
12802         if (ndr_flags & NDR_BUFFERS) {
12803                 if (r->info) {
12804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
12805                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12806                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12807                         }
12808                 }
12809         }
12810         return NDR_ERR_SUCCESS;
12811 }
12812
12813 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12814 {
12815         uint32_t _ptr_info;
12816         uint32_t cntr_info_1;
12817         TALLOC_CTX *_mem_save_info_0;
12818         TALLOC_CTX *_mem_save_info_1;
12819         if (ndr_flags & NDR_SCALARS) {
12820                 NDR_CHECK(ndr_pull_align(ndr, 5));
12821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12822                 if (r->num_info > 10000) {
12823                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12824                 }
12825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12826                 if (_ptr_info) {
12827                         NDR_PULL_ALLOC(ndr, r->info);
12828                 } else {
12829                         r->info = NULL;
12830                 }
12831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12832         }
12833         if (ndr_flags & NDR_BUFFERS) {
12834                 if (r->info) {
12835                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12836                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12837                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12838                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12839                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12840                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12841                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12842                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12843                         }
12844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12845                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12846                 }
12847                 if (r->info) {
12848                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12849                 }
12850         }
12851         return NDR_ERR_SUCCESS;
12852 }
12853
12854 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12855 {
12856         uint32_t cntr_info_1;
12857         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12858         ndr->depth++;
12859         ndr_print_uint32(ndr, "num_info", r->num_info);
12860         ndr_print_ptr(ndr, "info", r->info);
12861         ndr->depth++;
12862         if (r->info) {
12863                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12864                 ndr->depth++;
12865                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12866                         char *idx_1=NULL;
12867                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12868                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12869                                 free(idx_1);
12870                         }
12871                 }
12872                 ndr->depth--;
12873         }
12874         ndr->depth--;
12875         ndr_print_uint32(ndr, "unknown", r->unknown);
12876         ndr->depth--;
12877 }
12878
12879 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12880 {
12881         if (ndr_flags & NDR_SCALARS) {
12882                 int level = ndr_push_get_switch_value(ndr, r);
12883                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12884                 switch (level) {
12885                         case 1: {
12886                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12887                         break; }
12888
12889                         default:
12890                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12891                 }
12892         }
12893         if (ndr_flags & NDR_BUFFERS) {
12894                 int level = ndr_push_get_switch_value(ndr, r);
12895                 switch (level) {
12896                         case 1:
12897                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12898                         break;
12899
12900                         default:
12901                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12902                 }
12903         }
12904         return NDR_ERR_SUCCESS;
12905 }
12906
12907 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12908 {
12909         int level;
12910         int32_t _level;
12911         level = ndr_pull_get_switch_value(ndr, r);
12912         if (ndr_flags & NDR_SCALARS) {
12913                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12914                 if (_level != level) {
12915                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12916                 }
12917                 switch (level) {
12918                         case 1: {
12919                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12920                         break; }
12921
12922                         default:
12923                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12924                 }
12925         }
12926         if (ndr_flags & NDR_BUFFERS) {
12927                 switch (level) {
12928                         case 1:
12929                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12930                         break;
12931
12932                         default:
12933                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12934                 }
12935         }
12936         return NDR_ERR_SUCCESS;
12937 }
12938
12939 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
12940 {
12941         int level;
12942         level = ndr_print_get_switch_value(ndr, r);
12943         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
12944         switch (level) {
12945                 case 1:
12946                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
12947                 break;
12948
12949                 default:
12950                         ndr_print_bad_level(ndr, name, level);
12951         }
12952 }
12953
12954 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
12955 {
12956         uint32_t cntr_site_to_1;
12957         if (ndr_flags & NDR_SCALARS) {
12958                 NDR_CHECK(ndr_push_align(ndr, 5));
12959                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
12960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
12962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
12963         }
12964         if (ndr_flags & NDR_BUFFERS) {
12965                 if (r->site_from) {
12966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12968                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12969                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12970                 }
12971                 if (r->site_to) {
12972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12973                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12974                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
12975                         }
12976                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12977                                 if (r->site_to[cntr_site_to_1]) {
12978                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12979                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12980                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12981                                         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));
12982                                 }
12983                         }
12984                 }
12985         }
12986         return NDR_ERR_SUCCESS;
12987 }
12988
12989 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
12990 {
12991         uint32_t _ptr_site_from;
12992         TALLOC_CTX *_mem_save_site_from_0;
12993         uint32_t _ptr_site_to;
12994         uint32_t cntr_site_to_1;
12995         TALLOC_CTX *_mem_save_site_to_0;
12996         TALLOC_CTX *_mem_save_site_to_1;
12997         TALLOC_CTX *_mem_save_site_to_2;
12998         if (ndr_flags & NDR_SCALARS) {
12999                 NDR_CHECK(ndr_pull_align(ndr, 5));
13000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13001                 if (_ptr_site_from) {
13002                         NDR_PULL_ALLOC(ndr, r->site_from);
13003                 } else {
13004                         r->site_from = NULL;
13005                 }
13006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13007                 if (r->num_req < 1 || r->num_req > 10000) {
13008                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13009                 }
13010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13011                 if (_ptr_site_to) {
13012                         NDR_PULL_ALLOC(ndr, r->site_to);
13013                 } else {
13014                         r->site_to = NULL;
13015                 }
13016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13017         }
13018         if (ndr_flags & NDR_BUFFERS) {
13019                 if (r->site_from) {
13020                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13021                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13022                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13023                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13024                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13025                                 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));
13026                         }
13027                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13028                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13030                 }
13031                 if (r->site_to) {
13032                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13033                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13034                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13035                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13036                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13037                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13038                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13039                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13040                                 if (_ptr_site_to) {
13041                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13042                                 } else {
13043                                         r->site_to[cntr_site_to_1] = NULL;
13044                                 }
13045                         }
13046                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13047                                 if (r->site_to[cntr_site_to_1]) {
13048                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13049                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13050                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13051                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13052                                         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])) {
13053                                                 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]));
13054                                         }
13055                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13056                                         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));
13057                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13058                                 }
13059                         }
13060                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13062                 }
13063                 if (r->site_to) {
13064                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13065                 }
13066         }
13067         return NDR_ERR_SUCCESS;
13068 }
13069
13070 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13071 {
13072         uint32_t cntr_site_to_1;
13073         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13074         ndr->depth++;
13075         ndr_print_ptr(ndr, "site_from", r->site_from);
13076         ndr->depth++;
13077         if (r->site_from) {
13078                 ndr_print_string(ndr, "site_from", r->site_from);
13079         }
13080         ndr->depth--;
13081         ndr_print_uint32(ndr, "num_req", r->num_req);
13082         ndr_print_ptr(ndr, "site_to", r->site_to);
13083         ndr->depth++;
13084         if (r->site_to) {
13085                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13086                 ndr->depth++;
13087                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13088                         char *idx_1=NULL;
13089                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13090                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13091                                 ndr->depth++;
13092                                 if (r->site_to[cntr_site_to_1]) {
13093                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13094                                 }
13095                                 ndr->depth--;
13096                                 free(idx_1);
13097                         }
13098                 }
13099                 ndr->depth--;
13100         }
13101         ndr->depth--;
13102         ndr_print_uint32(ndr, "flags", r->flags);
13103         ndr->depth--;
13104 }
13105
13106 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13107 {
13108         if (ndr_flags & NDR_SCALARS) {
13109                 int level = ndr_push_get_switch_value(ndr, r);
13110                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13111                 switch (level) {
13112                         case 1: {
13113                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13114                         break; }
13115
13116                         default:
13117                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13118                 }
13119         }
13120         if (ndr_flags & NDR_BUFFERS) {
13121                 int level = ndr_push_get_switch_value(ndr, r);
13122                 switch (level) {
13123                         case 1:
13124                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13125                         break;
13126
13127                         default:
13128                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13129                 }
13130         }
13131         return NDR_ERR_SUCCESS;
13132 }
13133
13134 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13135 {
13136         int level;
13137         int32_t _level;
13138         level = ndr_pull_get_switch_value(ndr, r);
13139         if (ndr_flags & NDR_SCALARS) {
13140                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13141                 if (_level != level) {
13142                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13143                 }
13144                 switch (level) {
13145                         case 1: {
13146                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13147                         break; }
13148
13149                         default:
13150                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13151                 }
13152         }
13153         if (ndr_flags & NDR_BUFFERS) {
13154                 switch (level) {
13155                         case 1:
13156                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13157                         break;
13158
13159                         default:
13160                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13161                 }
13162         }
13163         return NDR_ERR_SUCCESS;
13164 }
13165
13166 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13167 {
13168         int level;
13169         level = ndr_print_get_switch_value(ndr, r);
13170         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13171         switch (level) {
13172                 case 1:
13173                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13174                 break;
13175
13176                 default:
13177                         ndr_print_bad_level(ndr, name, level);
13178         }
13179 }
13180
13181 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13182 {
13183         if (flags & NDR_IN) {
13184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13185                 if (r->in.bind_guid) {
13186                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13187                 }
13188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13189                 if (r->in.bind_info) {
13190                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13191                 }
13192         }
13193         if (flags & NDR_OUT) {
13194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13195                 if (r->out.bind_info) {
13196                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13197                 }
13198                 if (r->out.bind_handle == NULL) {
13199                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13200                 }
13201                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13202                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13203         }
13204         return NDR_ERR_SUCCESS;
13205 }
13206
13207 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13208 {
13209         uint32_t _ptr_bind_guid;
13210         uint32_t _ptr_bind_info;
13211         TALLOC_CTX *_mem_save_bind_guid_0;
13212         TALLOC_CTX *_mem_save_bind_info_0;
13213         TALLOC_CTX *_mem_save_bind_handle_0;
13214         if (flags & NDR_IN) {
13215                 ZERO_STRUCT(r->out);
13216
13217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13218                 if (_ptr_bind_guid) {
13219                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13220                 } else {
13221                         r->in.bind_guid = NULL;
13222                 }
13223                 if (r->in.bind_guid) {
13224                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13225                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13226                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13228                 }
13229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13230                 if (_ptr_bind_info) {
13231                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13232                 } else {
13233                         r->in.bind_info = NULL;
13234                 }
13235                 if (r->in.bind_info) {
13236                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13237                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13238                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13240                 }
13241                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13242                 ZERO_STRUCTP(r->out.bind_handle);
13243         }
13244         if (flags & NDR_OUT) {
13245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13246                 if (_ptr_bind_info) {
13247                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13248                 } else {
13249                         r->out.bind_info = NULL;
13250                 }
13251                 if (r->out.bind_info) {
13252                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13253                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13254                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13256                 }
13257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13258                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13259                 }
13260                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13261                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13262                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13263                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13264                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13265         }
13266         return NDR_ERR_SUCCESS;
13267 }
13268
13269 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13270 {
13271         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13272         ndr->depth++;
13273         if (flags & NDR_SET_VALUES) {
13274                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13275         }
13276         if (flags & NDR_IN) {
13277                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13278                 ndr->depth++;
13279                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13280                 ndr->depth++;
13281                 if (r->in.bind_guid) {
13282                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13283                 }
13284                 ndr->depth--;
13285                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13286                 ndr->depth++;
13287                 if (r->in.bind_info) {
13288                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13289                 }
13290                 ndr->depth--;
13291                 ndr->depth--;
13292         }
13293         if (flags & NDR_OUT) {
13294                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13295                 ndr->depth++;
13296                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13297                 ndr->depth++;
13298                 if (r->out.bind_info) {
13299                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13300                 }
13301                 ndr->depth--;
13302                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13303                 ndr->depth++;
13304                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13305                 ndr->depth--;
13306                 ndr_print_WERROR(ndr, "result", r->out.result);
13307                 ndr->depth--;
13308         }
13309         ndr->depth--;
13310 }
13311
13312 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13313 {
13314         if (flags & NDR_IN) {
13315                 if (r->in.bind_handle == NULL) {
13316                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13317                 }
13318                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13319         }
13320         if (flags & NDR_OUT) {
13321                 if (r->out.bind_handle == NULL) {
13322                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13323                 }
13324                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13325                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13326         }
13327         return NDR_ERR_SUCCESS;
13328 }
13329
13330 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13331 {
13332         TALLOC_CTX *_mem_save_bind_handle_0;
13333         if (flags & NDR_IN) {
13334                 ZERO_STRUCT(r->out);
13335
13336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13337                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13338                 }
13339                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13340                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13341                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13343                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13344                 *r->out.bind_handle = *r->in.bind_handle;
13345         }
13346         if (flags & NDR_OUT) {
13347                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13348                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13349                 }
13350                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13351                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13352                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13353                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13354                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13355         }
13356         return NDR_ERR_SUCCESS;
13357 }
13358
13359 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13360 {
13361         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13362         ndr->depth++;
13363         if (flags & NDR_SET_VALUES) {
13364                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13365         }
13366         if (flags & NDR_IN) {
13367                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13368                 ndr->depth++;
13369                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13370                 ndr->depth++;
13371                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13372                 ndr->depth--;
13373                 ndr->depth--;
13374         }
13375         if (flags & NDR_OUT) {
13376                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13377                 ndr->depth++;
13378                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13379                 ndr->depth++;
13380                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13381                 ndr->depth--;
13382                 ndr_print_WERROR(ndr, "result", r->out.result);
13383                 ndr->depth--;
13384         }
13385         ndr->depth--;
13386 }
13387
13388 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13389 {
13390         if (flags & NDR_IN) {
13391                 if (r->in.bind_handle == NULL) {
13392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13393                 }
13394                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13395                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13396                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13397                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13398         }
13399         if (flags & NDR_OUT) {
13400                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13401         }
13402         return NDR_ERR_SUCCESS;
13403 }
13404
13405 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13406 {
13407         TALLOC_CTX *_mem_save_bind_handle_0;
13408         if (flags & NDR_IN) {
13409                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13410                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13411                 }
13412                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13413                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13414                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13416                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13417                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13418                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13419         }
13420         if (flags & NDR_OUT) {
13421                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13422         }
13423         return NDR_ERR_SUCCESS;
13424 }
13425
13426 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13427 {
13428         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13429         ndr->depth++;
13430         if (flags & NDR_SET_VALUES) {
13431                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13432         }
13433         if (flags & NDR_IN) {
13434                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13435                 ndr->depth++;
13436                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13437                 ndr->depth++;
13438                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13439                 ndr->depth--;
13440                 ndr_print_int32(ndr, "level", r->in.level);
13441                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13442                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13443                 ndr->depth--;
13444         }
13445         if (flags & NDR_OUT) {
13446                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13447                 ndr->depth++;
13448                 ndr_print_WERROR(ndr, "result", r->out.result);
13449                 ndr->depth--;
13450         }
13451         ndr->depth--;
13452 }
13453
13454 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13455 {
13456         if (flags & NDR_IN) {
13457                 if (r->in.bind_handle == NULL) {
13458                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13459                 }
13460                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13461                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13462                 if (r->in.req == NULL) {
13463                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13464                 }
13465                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13466                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13467         }
13468         if (flags & NDR_OUT) {
13469                 if (r->out.level_out == NULL) {
13470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13471                 }
13472                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13473                 if (r->out.ctr == NULL) {
13474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13475                 }
13476                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13477                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13478                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13479         }
13480         return NDR_ERR_SUCCESS;
13481 }
13482
13483 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13484 {
13485         TALLOC_CTX *_mem_save_bind_handle_0;
13486         TALLOC_CTX *_mem_save_req_0;
13487         TALLOC_CTX *_mem_save_level_out_0;
13488         TALLOC_CTX *_mem_save_ctr_0;
13489         if (flags & NDR_IN) {
13490                 ZERO_STRUCT(r->out);
13491
13492                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13493                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13494                 }
13495                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13496                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13497                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13498                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13499                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13500                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13501                         NDR_PULL_ALLOC(ndr, r->in.req);
13502                 }
13503                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13504                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13505                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13506                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13508                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13509                 ZERO_STRUCTP(r->out.level_out);
13510                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13511                 ZERO_STRUCTP(r->out.ctr);
13512         }
13513         if (flags & NDR_OUT) {
13514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13515                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13516                 }
13517                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13518                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13519                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13521                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13522                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13523                 }
13524                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13525                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13526                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13527                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13529                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13530         }
13531         return NDR_ERR_SUCCESS;
13532 }
13533
13534 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13535 {
13536         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13537         ndr->depth++;
13538         if (flags & NDR_SET_VALUES) {
13539                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13540         }
13541         if (flags & NDR_IN) {
13542                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13543                 ndr->depth++;
13544                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13545                 ndr->depth++;
13546                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13547                 ndr->depth--;
13548                 ndr_print_int32(ndr, "level", r->in.level);
13549                 ndr_print_ptr(ndr, "req", r->in.req);
13550                 ndr->depth++;
13551                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13552                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13553                 ndr->depth--;
13554                 ndr->depth--;
13555         }
13556         if (flags & NDR_OUT) {
13557                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13558                 ndr->depth++;
13559                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13560                 ndr->depth++;
13561                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13562                 ndr->depth--;
13563                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13564                 ndr->depth++;
13565                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13566                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13567                 ndr->depth--;
13568                 ndr_print_WERROR(ndr, "result", r->out.result);
13569                 ndr->depth--;
13570         }
13571         ndr->depth--;
13572 }
13573
13574 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13575 {
13576         if (flags & NDR_IN) {
13577                 if (r->in.bind_handle == NULL) {
13578                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13579                 }
13580                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13581                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13582                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13583                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13584         }
13585         if (flags & NDR_OUT) {
13586                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13587         }
13588         return NDR_ERR_SUCCESS;
13589 }
13590
13591 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13592 {
13593         TALLOC_CTX *_mem_save_bind_handle_0;
13594         if (flags & NDR_IN) {
13595                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13596                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13597                 }
13598                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13599                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13600                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13601                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13602                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13603                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13604                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13605         }
13606         if (flags & NDR_OUT) {
13607                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13608         }
13609         return NDR_ERR_SUCCESS;
13610 }
13611
13612 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13613 {
13614         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13615         ndr->depth++;
13616         if (flags & NDR_SET_VALUES) {
13617                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13618         }
13619         if (flags & NDR_IN) {
13620                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13621                 ndr->depth++;
13622                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13623                 ndr->depth++;
13624                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13625                 ndr->depth--;
13626                 ndr_print_int32(ndr, "level", r->in.level);
13627                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13628                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13629                 ndr->depth--;
13630         }
13631         if (flags & NDR_OUT) {
13632                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13633                 ndr->depth++;
13634                 ndr_print_WERROR(ndr, "result", r->out.result);
13635                 ndr->depth--;
13636         }
13637         ndr->depth--;
13638 }
13639
13640 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13641 {
13642         if (flags & NDR_IN) {
13643                 if (r->in.bind_handle == NULL) {
13644                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13645                 }
13646                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13647                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13648                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13649                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13650         }
13651         if (flags & NDR_OUT) {
13652                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13653         }
13654         return NDR_ERR_SUCCESS;
13655 }
13656
13657 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13658 {
13659         TALLOC_CTX *_mem_save_bind_handle_0;
13660         if (flags & NDR_IN) {
13661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13662                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13663                 }
13664                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13665                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13666                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13668                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13669                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13670                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13671         }
13672         if (flags & NDR_OUT) {
13673                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13674         }
13675         return NDR_ERR_SUCCESS;
13676 }
13677
13678 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13679 {
13680         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13681         ndr->depth++;
13682         if (flags & NDR_SET_VALUES) {
13683                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13684         }
13685         if (flags & NDR_IN) {
13686                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13687                 ndr->depth++;
13688                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13689                 ndr->depth++;
13690                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13691                 ndr->depth--;
13692                 ndr_print_int32(ndr, "level", r->in.level);
13693                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13694                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13695                 ndr->depth--;
13696         }
13697         if (flags & NDR_OUT) {
13698                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13699                 ndr->depth++;
13700                 ndr_print_WERROR(ndr, "result", r->out.result);
13701                 ndr->depth--;
13702         }
13703         ndr->depth--;
13704 }
13705
13706 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13707 {
13708         if (flags & NDR_IN) {
13709                 if (r->in.bind_handle == NULL) {
13710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13711                 }
13712                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13713                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13714                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13715                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13716         }
13717         if (flags & NDR_OUT) {
13718                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13719         }
13720         return NDR_ERR_SUCCESS;
13721 }
13722
13723 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13724 {
13725         TALLOC_CTX *_mem_save_bind_handle_0;
13726         if (flags & NDR_IN) {
13727                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13728                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13729                 }
13730                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13731                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13732                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13733                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13734                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13735                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13736                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13737         }
13738         if (flags & NDR_OUT) {
13739                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13740         }
13741         return NDR_ERR_SUCCESS;
13742 }
13743
13744 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13745 {
13746         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13747         ndr->depth++;
13748         if (flags & NDR_SET_VALUES) {
13749                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13750         }
13751         if (flags & NDR_IN) {
13752                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13753                 ndr->depth++;
13754                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13755                 ndr->depth++;
13756                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13757                 ndr->depth--;
13758                 ndr_print_int32(ndr, "level", r->in.level);
13759                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13760                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13761                 ndr->depth--;
13762         }
13763         if (flags & NDR_OUT) {
13764                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13765                 ndr->depth++;
13766                 ndr_print_WERROR(ndr, "result", r->out.result);
13767                 ndr->depth--;
13768         }
13769         ndr->depth--;
13770 }
13771
13772 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13773 {
13774         if (flags & NDR_IN) {
13775                 if (r->in.bind_handle == NULL) {
13776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13777                 }
13778                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13779                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13780                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13781                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13782         }
13783         if (flags & NDR_OUT) {
13784                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13785         }
13786         return NDR_ERR_SUCCESS;
13787 }
13788
13789 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13790 {
13791         TALLOC_CTX *_mem_save_bind_handle_0;
13792         if (flags & NDR_IN) {
13793                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13794                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13795                 }
13796                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13797                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13798                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13799                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13800                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13801                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13802                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13803         }
13804         if (flags & NDR_OUT) {
13805                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13806         }
13807         return NDR_ERR_SUCCESS;
13808 }
13809
13810 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13811 {
13812         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13813         ndr->depth++;
13814         if (flags & NDR_SET_VALUES) {
13815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13816         }
13817         if (flags & NDR_IN) {
13818                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13819                 ndr->depth++;
13820                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13821                 ndr->depth++;
13822                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13823                 ndr->depth--;
13824                 ndr_print_int32(ndr, "level", r->in.level);
13825                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13826                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13827                 ndr->depth--;
13828         }
13829         if (flags & NDR_OUT) {
13830                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13831                 ndr->depth++;
13832                 ndr_print_WERROR(ndr, "result", r->out.result);
13833                 ndr->depth--;
13834         }
13835         ndr->depth--;
13836 }
13837
13838 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13839 {
13840         if (flags & NDR_IN) {
13841         }
13842         if (flags & NDR_OUT) {
13843                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13844         }
13845         return NDR_ERR_SUCCESS;
13846 }
13847
13848 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13849 {
13850         if (flags & NDR_IN) {
13851         }
13852         if (flags & NDR_OUT) {
13853                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13854         }
13855         return NDR_ERR_SUCCESS;
13856 }
13857
13858 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13859 {
13860         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13861         ndr->depth++;
13862         if (flags & NDR_SET_VALUES) {
13863                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13864         }
13865         if (flags & NDR_IN) {
13866                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13867                 ndr->depth++;
13868                 ndr->depth--;
13869         }
13870         if (flags & NDR_OUT) {
13871                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13872                 ndr->depth++;
13873                 ndr_print_WERROR(ndr, "result", r->out.result);
13874                 ndr->depth--;
13875         }
13876         ndr->depth--;
13877 }
13878
13879 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13880 {
13881         if (flags & NDR_IN) {
13882                 if (r->in.bind_handle == NULL) {
13883                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13884                 }
13885                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13886                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13887                 if (r->in.req == 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->in.req, r->in.level));
13891                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13892         }
13893         if (flags & NDR_OUT) {
13894                 if (r->out.level_out == NULL) {
13895                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13896                 }
13897                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13898                 if (r->out.ctr == NULL) {
13899                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13900                 }
13901                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13902                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13903                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13904         }
13905         return NDR_ERR_SUCCESS;
13906 }
13907
13908 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13909 {
13910         TALLOC_CTX *_mem_save_bind_handle_0;
13911         TALLOC_CTX *_mem_save_req_0;
13912         TALLOC_CTX *_mem_save_level_out_0;
13913         TALLOC_CTX *_mem_save_ctr_0;
13914         if (flags & NDR_IN) {
13915                 ZERO_STRUCT(r->out);
13916
13917                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13918                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13919                 }
13920                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13921                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13922                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13923                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13924                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13925                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13926                         NDR_PULL_ALLOC(ndr, r->in.req);
13927                 }
13928                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13929                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13930                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13931                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13932                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13933                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13934                 ZERO_STRUCTP(r->out.level_out);
13935                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13936                 ZERO_STRUCTP(r->out.ctr);
13937         }
13938         if (flags & NDR_OUT) {
13939                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13940                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13941                 }
13942                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13943                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13944                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13945                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13947                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13948                 }
13949                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13950                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13951                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13952                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13953                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13954                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13955         }
13956         return NDR_ERR_SUCCESS;
13957 }
13958
13959 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
13960 {
13961         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
13962         ndr->depth++;
13963         if (flags & NDR_SET_VALUES) {
13964                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13965         }
13966         if (flags & NDR_IN) {
13967                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
13968                 ndr->depth++;
13969                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13970                 ndr->depth++;
13971                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13972                 ndr->depth--;
13973                 ndr_print_int32(ndr, "level", r->in.level);
13974                 ndr_print_ptr(ndr, "req", r->in.req);
13975                 ndr->depth++;
13976                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13977                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
13978                 ndr->depth--;
13979                 ndr->depth--;
13980         }
13981         if (flags & NDR_OUT) {
13982                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
13983                 ndr->depth++;
13984                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13985                 ndr->depth++;
13986                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13987                 ndr->depth--;
13988                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13989                 ndr->depth++;
13990                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13991                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
13992                 ndr->depth--;
13993                 ndr_print_WERROR(ndr, "result", r->out.result);
13994                 ndr->depth--;
13995         }
13996         ndr->depth--;
13997 }
13998
13999 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14000 {
14001         if (flags & NDR_IN) {
14002         }
14003         if (flags & NDR_OUT) {
14004                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14005         }
14006         return NDR_ERR_SUCCESS;
14007 }
14008
14009 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14010 {
14011         if (flags & NDR_IN) {
14012         }
14013         if (flags & NDR_OUT) {
14014                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14015         }
14016         return NDR_ERR_SUCCESS;
14017 }
14018
14019 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14020 {
14021         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14022         ndr->depth++;
14023         if (flags & NDR_SET_VALUES) {
14024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14025         }
14026         if (flags & NDR_IN) {
14027                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14028                 ndr->depth++;
14029                 ndr->depth--;
14030         }
14031         if (flags & NDR_OUT) {
14032                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14033                 ndr->depth++;
14034                 ndr_print_WERROR(ndr, "result", r->out.result);
14035                 ndr->depth--;
14036         }
14037         ndr->depth--;
14038 }
14039
14040 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14041 {
14042         if (flags & NDR_IN) {
14043                 if (r->in.bind_handle == NULL) {
14044                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14045                 }
14046                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14048                 if (r->in.req == NULL) {
14049                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14050                 }
14051                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14052                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14053         }
14054         if (flags & NDR_OUT) {
14055                 if (r->out.level_out == NULL) {
14056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14057                 }
14058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14059                 if (r->out.info == NULL) {
14060                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14061                 }
14062                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14063                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14064                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14065         }
14066         return NDR_ERR_SUCCESS;
14067 }
14068
14069 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14070 {
14071         TALLOC_CTX *_mem_save_bind_handle_0;
14072         TALLOC_CTX *_mem_save_req_0;
14073         TALLOC_CTX *_mem_save_level_out_0;
14074         TALLOC_CTX *_mem_save_info_0;
14075         if (flags & NDR_IN) {
14076                 ZERO_STRUCT(r->out);
14077
14078                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14079                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14080                 }
14081                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14082                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14083                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14086                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14087                         NDR_PULL_ALLOC(ndr, r->in.req);
14088                 }
14089                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14090                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14091                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14092                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14093                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14094                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14095                 ZERO_STRUCTP(r->out.level_out);
14096                 NDR_PULL_ALLOC(ndr, r->out.info);
14097                 ZERO_STRUCTP(r->out.info);
14098         }
14099         if (flags & NDR_OUT) {
14100                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14101                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14102                 }
14103                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14104                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14106                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14107                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14108                         NDR_PULL_ALLOC(ndr, r->out.info);
14109                 }
14110                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14111                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14112                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14113                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14114                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14115                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14116         }
14117         return NDR_ERR_SUCCESS;
14118 }
14119
14120 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14121 {
14122         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14123         ndr->depth++;
14124         if (flags & NDR_SET_VALUES) {
14125                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14126         }
14127         if (flags & NDR_IN) {
14128                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14129                 ndr->depth++;
14130                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14131                 ndr->depth++;
14132                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14133                 ndr->depth--;
14134                 ndr_print_uint32(ndr, "level", r->in.level);
14135                 ndr_print_ptr(ndr, "req", r->in.req);
14136                 ndr->depth++;
14137                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14138                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14139                 ndr->depth--;
14140                 ndr->depth--;
14141         }
14142         if (flags & NDR_OUT) {
14143                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14144                 ndr->depth++;
14145                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14146                 ndr->depth++;
14147                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14148                 ndr->depth--;
14149                 ndr_print_ptr(ndr, "info", r->out.info);
14150                 ndr->depth++;
14151                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14152                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14153                 ndr->depth--;
14154                 ndr_print_WERROR(ndr, "result", r->out.result);
14155                 ndr->depth--;
14156         }
14157         ndr->depth--;
14158 }
14159
14160 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14161 {
14162         if (flags & NDR_IN) {
14163                 if (r->in.bind_handle == NULL) {
14164                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14165                 }
14166                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14167                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14168                 if (r->in.req == NULL) {
14169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14170                 }
14171                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14172                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14173         }
14174         if (flags & NDR_OUT) {
14175                 if (r->out.level_out == NULL) {
14176                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14177                 }
14178                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14179                 if (r->out.ctr == NULL) {
14180                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14181                 }
14182                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14183                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14184                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14185         }
14186         return NDR_ERR_SUCCESS;
14187 }
14188
14189 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14190 {
14191         TALLOC_CTX *_mem_save_bind_handle_0;
14192         TALLOC_CTX *_mem_save_req_0;
14193         TALLOC_CTX *_mem_save_level_out_0;
14194         TALLOC_CTX *_mem_save_ctr_0;
14195         if (flags & NDR_IN) {
14196                 ZERO_STRUCT(r->out);
14197
14198                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14199                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14200                 }
14201                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14202                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14203                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14205                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14206                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14207                         NDR_PULL_ALLOC(ndr, r->in.req);
14208                 }
14209                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14210                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14211                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14212                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14214                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14215                 ZERO_STRUCTP(r->out.level_out);
14216                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14217                 ZERO_STRUCTP(r->out.ctr);
14218         }
14219         if (flags & NDR_OUT) {
14220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14221                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14222                 }
14223                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14224                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14225                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14227                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14228                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14229                 }
14230                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14231                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14232                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14233                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14235                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14236         }
14237         return NDR_ERR_SUCCESS;
14238 }
14239
14240 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14241 {
14242         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14243         ndr->depth++;
14244         if (flags & NDR_SET_VALUES) {
14245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14246         }
14247         if (flags & NDR_IN) {
14248                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14249                 ndr->depth++;
14250                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14251                 ndr->depth++;
14252                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14253                 ndr->depth--;
14254                 ndr_print_int32(ndr, "level", r->in.level);
14255                 ndr_print_ptr(ndr, "req", r->in.req);
14256                 ndr->depth++;
14257                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14258                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14259                 ndr->depth--;
14260                 ndr->depth--;
14261         }
14262         if (flags & NDR_OUT) {
14263                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14264                 ndr->depth++;
14265                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14266                 ndr->depth++;
14267                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14268                 ndr->depth--;
14269                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14270                 ndr->depth++;
14271                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14272                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14273                 ndr->depth--;
14274                 ndr_print_WERROR(ndr, "result", r->out.result);
14275                 ndr->depth--;
14276         }
14277         ndr->depth--;
14278 }
14279
14280 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14281 {
14282         if (flags & NDR_IN) {
14283                 if (r->in.bind_handle == NULL) {
14284                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14285                 }
14286                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14287                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14288                 if (r->in.req == NULL) {
14289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14290                 }
14291                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14292                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14293         }
14294         if (flags & NDR_OUT) {
14295                 if (r->out.level_out == NULL) {
14296                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14297                 }
14298                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14299                 if (r->out.res == NULL) {
14300                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14301                 }
14302                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14303                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14304                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14305         }
14306         return NDR_ERR_SUCCESS;
14307 }
14308
14309 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14310 {
14311         TALLOC_CTX *_mem_save_bind_handle_0;
14312         TALLOC_CTX *_mem_save_req_0;
14313         TALLOC_CTX *_mem_save_level_out_0;
14314         TALLOC_CTX *_mem_save_res_0;
14315         if (flags & NDR_IN) {
14316                 ZERO_STRUCT(r->out);
14317
14318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14319                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14320                 }
14321                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14322                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14323                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14325                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14326                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14327                         NDR_PULL_ALLOC(ndr, r->in.req);
14328                 }
14329                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14330                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14331                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14332                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14333                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14334                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14335                 ZERO_STRUCTP(r->out.level_out);
14336                 NDR_PULL_ALLOC(ndr, r->out.res);
14337                 ZERO_STRUCTP(r->out.res);
14338         }
14339         if (flags & NDR_OUT) {
14340                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14341                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14342                 }
14343                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14344                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14345                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14346                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14347                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14348                         NDR_PULL_ALLOC(ndr, r->out.res);
14349                 }
14350                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14351                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14352                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14353                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14354                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14355                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14356         }
14357         return NDR_ERR_SUCCESS;
14358 }
14359
14360 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14361 {
14362         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14363         ndr->depth++;
14364         if (flags & NDR_SET_VALUES) {
14365                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14366         }
14367         if (flags & NDR_IN) {
14368                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14369                 ndr->depth++;
14370                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14371                 ndr->depth++;
14372                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14373                 ndr->depth--;
14374                 ndr_print_int32(ndr, "level", r->in.level);
14375                 ndr_print_ptr(ndr, "req", r->in.req);
14376                 ndr->depth++;
14377                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14378                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14379                 ndr->depth--;
14380                 ndr->depth--;
14381         }
14382         if (flags & NDR_OUT) {
14383                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14384                 ndr->depth++;
14385                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14386                 ndr->depth++;
14387                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14388                 ndr->depth--;
14389                 ndr_print_ptr(ndr, "res", r->out.res);
14390                 ndr->depth++;
14391                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14392                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14393                 ndr->depth--;
14394                 ndr_print_WERROR(ndr, "result", r->out.result);
14395                 ndr->depth--;
14396         }
14397         ndr->depth--;
14398 }
14399
14400 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14401 {
14402         if (flags & NDR_IN) {
14403                 if (r->in.bind_handle == NULL) {
14404                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14405                 }
14406                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14407                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14408                 if (r->in.req == 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->in.req, r->in.level));
14412                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14413         }
14414         if (flags & NDR_OUT) {
14415                 if (r->out.level_out == NULL) {
14416                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14417                 }
14418                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14419                 if (r->out.res == NULL) {
14420                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14421                 }
14422                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14423                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14424                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14425         }
14426         return NDR_ERR_SUCCESS;
14427 }
14428
14429 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14430 {
14431         TALLOC_CTX *_mem_save_bind_handle_0;
14432         TALLOC_CTX *_mem_save_req_0;
14433         TALLOC_CTX *_mem_save_level_out_0;
14434         TALLOC_CTX *_mem_save_res_0;
14435         if (flags & NDR_IN) {
14436                 ZERO_STRUCT(r->out);
14437
14438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14439                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14440                 }
14441                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14442                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14443                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14445                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14446                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14447                         NDR_PULL_ALLOC(ndr, r->in.req);
14448                 }
14449                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14450                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14451                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14452                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14453                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14454                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14455                 ZERO_STRUCTP(r->out.level_out);
14456                 NDR_PULL_ALLOC(ndr, r->out.res);
14457                 ZERO_STRUCTP(r->out.res);
14458         }
14459         if (flags & NDR_OUT) {
14460                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14461                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14462                 }
14463                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14464                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14465                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14466                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14467                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14468                         NDR_PULL_ALLOC(ndr, r->out.res);
14469                 }
14470                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14471                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14472                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14473                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14474                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14475                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14476         }
14477         return NDR_ERR_SUCCESS;
14478 }
14479
14480 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14481 {
14482         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14483         ndr->depth++;
14484         if (flags & NDR_SET_VALUES) {
14485                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14486         }
14487         if (flags & NDR_IN) {
14488                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14489                 ndr->depth++;
14490                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14491                 ndr->depth++;
14492                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14493                 ndr->depth--;
14494                 ndr_print_int32(ndr, "level", r->in.level);
14495                 ndr_print_ptr(ndr, "req", r->in.req);
14496                 ndr->depth++;
14497                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14498                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14499                 ndr->depth--;
14500                 ndr->depth--;
14501         }
14502         if (flags & NDR_OUT) {
14503                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14504                 ndr->depth++;
14505                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14506                 ndr->depth++;
14507                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14508                 ndr->depth--;
14509                 ndr_print_ptr(ndr, "res", r->out.res);
14510                 ndr->depth++;
14511                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14512                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14513                 ndr->depth--;
14514                 ndr_print_WERROR(ndr, "result", r->out.result);
14515                 ndr->depth--;
14516         }
14517         ndr->depth--;
14518 }
14519
14520 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14521 {
14522         if (flags & NDR_IN) {
14523         }
14524         if (flags & NDR_OUT) {
14525                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14526         }
14527         return NDR_ERR_SUCCESS;
14528 }
14529
14530 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14531 {
14532         if (flags & NDR_IN) {
14533         }
14534         if (flags & NDR_OUT) {
14535                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14536         }
14537         return NDR_ERR_SUCCESS;
14538 }
14539
14540 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14541 {
14542         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14543         ndr->depth++;
14544         if (flags & NDR_SET_VALUES) {
14545                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14546         }
14547         if (flags & NDR_IN) {
14548                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14549                 ndr->depth++;
14550                 ndr->depth--;
14551         }
14552         if (flags & NDR_OUT) {
14553                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14554                 ndr->depth++;
14555                 ndr_print_WERROR(ndr, "result", r->out.result);
14556                 ndr->depth--;
14557         }
14558         ndr->depth--;
14559 }
14560
14561 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14562 {
14563         if (flags & NDR_IN) {
14564                 if (r->in.bind_handle == NULL) {
14565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14566                 }
14567                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14568                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14569                 if (r->in.req == NULL) {
14570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14571                 }
14572                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14573                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14574         }
14575         if (flags & NDR_OUT) {
14576                 if (r->out.level_out == NULL) {
14577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14578                 }
14579                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14580                 if (r->out.ctr == NULL) {
14581                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14582                 }
14583                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14584                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14585                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14586         }
14587         return NDR_ERR_SUCCESS;
14588 }
14589
14590 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14591 {
14592         TALLOC_CTX *_mem_save_bind_handle_0;
14593         TALLOC_CTX *_mem_save_req_0;
14594         TALLOC_CTX *_mem_save_level_out_0;
14595         TALLOC_CTX *_mem_save_ctr_0;
14596         if (flags & NDR_IN) {
14597                 ZERO_STRUCT(r->out);
14598
14599                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14600                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14601                 }
14602                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14603                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14604                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14606                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14607                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14608                         NDR_PULL_ALLOC(ndr, r->in.req);
14609                 }
14610                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14611                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14612                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14613                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14615                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14616                 ZERO_STRUCTP(r->out.level_out);
14617                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14618                 ZERO_STRUCTP(r->out.ctr);
14619         }
14620         if (flags & NDR_OUT) {
14621                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14622                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14623                 }
14624                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14625                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14626                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14627                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14629                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14630                 }
14631                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14632                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14633                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14634                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14636                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14637         }
14638         return NDR_ERR_SUCCESS;
14639 }
14640
14641 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14642 {
14643         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14644         ndr->depth++;
14645         if (flags & NDR_SET_VALUES) {
14646                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14647         }
14648         if (flags & NDR_IN) {
14649                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14650                 ndr->depth++;
14651                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14652                 ndr->depth++;
14653                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14654                 ndr->depth--;
14655                 ndr_print_int32(ndr, "level", r->in.level);
14656                 ndr_print_ptr(ndr, "req", r->in.req);
14657                 ndr->depth++;
14658                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14659                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14660                 ndr->depth--;
14661                 ndr->depth--;
14662         }
14663         if (flags & NDR_OUT) {
14664                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14665                 ndr->depth++;
14666                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14667                 ndr->depth++;
14668                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14669                 ndr->depth--;
14670                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14671                 ndr->depth++;
14672                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14673                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14674                 ndr->depth--;
14675                 ndr_print_WERROR(ndr, "result", r->out.result);
14676                 ndr->depth--;
14677         }
14678         ndr->depth--;
14679 }
14680
14681 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14682 {
14683         if (flags & NDR_IN) {
14684                 if (r->in.bind_handle == NULL) {
14685                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14686                 }
14687                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14688                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14689                 if (r->in.req == NULL) {
14690                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14691                 }
14692                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14693                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14694         }
14695         if (flags & NDR_OUT) {
14696                 if (r->out.level_out == NULL) {
14697                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14698                 }
14699                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14700                 if (r->out.ctr == NULL) {
14701                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14702                 }
14703                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14704                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14705                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14706         }
14707         return NDR_ERR_SUCCESS;
14708 }
14709
14710 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14711 {
14712         TALLOC_CTX *_mem_save_bind_handle_0;
14713         TALLOC_CTX *_mem_save_req_0;
14714         TALLOC_CTX *_mem_save_level_out_0;
14715         TALLOC_CTX *_mem_save_ctr_0;
14716         if (flags & NDR_IN) {
14717                 ZERO_STRUCT(r->out);
14718
14719                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14720                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14721                 }
14722                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14723                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14724                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14726                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14727                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14728                         NDR_PULL_ALLOC(ndr, r->in.req);
14729                 }
14730                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14731                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14732                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14733                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14734                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14735                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14736                 ZERO_STRUCTP(r->out.level_out);
14737                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14738                 ZERO_STRUCTP(r->out.ctr);
14739         }
14740         if (flags & NDR_OUT) {
14741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14742                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14743                 }
14744                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14745                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14746                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14748                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14749                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14750                 }
14751                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14752                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14753                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14754                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14756                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14757         }
14758         return NDR_ERR_SUCCESS;
14759 }
14760
14761 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14762 {
14763         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14764         ndr->depth++;
14765         if (flags & NDR_SET_VALUES) {
14766                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14767         }
14768         if (flags & NDR_IN) {
14769                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14770                 ndr->depth++;
14771                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14772                 ndr->depth++;
14773                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14774                 ndr->depth--;
14775                 ndr_print_int32(ndr, "level", r->in.level);
14776                 ndr_print_ptr(ndr, "req", r->in.req);
14777                 ndr->depth++;
14778                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14779                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14780                 ndr->depth--;
14781                 ndr->depth--;
14782         }
14783         if (flags & NDR_OUT) {
14784                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14785                 ndr->depth++;
14786                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14787                 ndr->depth++;
14788                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14789                 ndr->depth--;
14790                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14791                 ndr->depth++;
14792                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14793                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14794                 ndr->depth--;
14795                 ndr_print_WERROR(ndr, "result", r->out.result);
14796                 ndr->depth--;
14797         }
14798         ndr->depth--;
14799 }
14800
14801 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
14802 {
14803         if (flags & NDR_IN) {
14804                 if (r->in.bind_handle == NULL) {
14805                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14806                 }
14807                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14809                 if (r->in.req == NULL) {
14810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14811                 }
14812                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14813                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14814         }
14815         if (flags & NDR_OUT) {
14816                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14817         }
14818         return NDR_ERR_SUCCESS;
14819 }
14820
14821 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
14822 {
14823         TALLOC_CTX *_mem_save_bind_handle_0;
14824         TALLOC_CTX *_mem_save_req_0;
14825         if (flags & NDR_IN) {
14826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14827                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14828                 }
14829                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14830                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14831                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14834                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14835                         NDR_PULL_ALLOC(ndr, r->in.req);
14836                 }
14837                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14838                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14839                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14840                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14841                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14842         }
14843         if (flags & NDR_OUT) {
14844                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14845         }
14846         return NDR_ERR_SUCCESS;
14847 }
14848
14849 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
14850 {
14851         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
14852         ndr->depth++;
14853         if (flags & NDR_SET_VALUES) {
14854                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14855         }
14856         if (flags & NDR_IN) {
14857                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
14858                 ndr->depth++;
14859                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14860                 ndr->depth++;
14861                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14862                 ndr->depth--;
14863                 ndr_print_uint32(ndr, "level", r->in.level);
14864                 ndr_print_ptr(ndr, "req", r->in.req);
14865                 ndr->depth++;
14866                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14867                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
14868                 ndr->depth--;
14869                 ndr->depth--;
14870         }
14871         if (flags & NDR_OUT) {
14872                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
14873                 ndr->depth++;
14874                 ndr_print_WERROR(ndr, "result", r->out.result);
14875                 ndr->depth--;
14876         }
14877         ndr->depth--;
14878 }
14879
14880 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14881 {
14882         if (flags & NDR_IN) {
14883                 if (r->in.bind_handle == NULL) {
14884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14885                 }
14886                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14887                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14888                 if (r->in.req == NULL) {
14889                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14890                 }
14891                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14892                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14893         }
14894         if (flags & NDR_OUT) {
14895                 if (r->out.info_type == NULL) {
14896                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14897                 }
14898                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14899                 if (r->out.info == NULL) {
14900                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14901                 }
14902                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
14903                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14904                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14905         }
14906         return NDR_ERR_SUCCESS;
14907 }
14908
14909 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14910 {
14911         TALLOC_CTX *_mem_save_bind_handle_0;
14912         TALLOC_CTX *_mem_save_req_0;
14913         TALLOC_CTX *_mem_save_info_type_0;
14914         TALLOC_CTX *_mem_save_info_0;
14915         if (flags & NDR_IN) {
14916                 ZERO_STRUCT(r->out);
14917
14918                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14919                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14920                 }
14921                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14922                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14923                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14924                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14925                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
14926                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14927                         NDR_PULL_ALLOC(ndr, r->in.req);
14928                 }
14929                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14930                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14931                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14932                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14934                 NDR_PULL_ALLOC(ndr, r->out.info_type);
14935                 ZERO_STRUCTP(r->out.info_type);
14936                 NDR_PULL_ALLOC(ndr, r->out.info);
14937                 ZERO_STRUCTP(r->out.info);
14938         }
14939         if (flags & NDR_OUT) {
14940                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14941                         NDR_PULL_ALLOC(ndr, r->out.info_type);
14942                 }
14943                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
14944                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
14945                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
14946                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
14947                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14948                         NDR_PULL_ALLOC(ndr, r->out.info);
14949                 }
14950                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14951                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14952                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
14953                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14955                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14956         }
14957         return NDR_ERR_SUCCESS;
14958 }
14959
14960 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14961 {
14962         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
14963         ndr->depth++;
14964         if (flags & NDR_SET_VALUES) {
14965                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14966         }
14967         if (flags & NDR_IN) {
14968                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
14969                 ndr->depth++;
14970                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14971                 ndr->depth++;
14972                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14973                 ndr->depth--;
14974                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
14975                 ndr_print_ptr(ndr, "req", r->in.req);
14976                 ndr->depth++;
14977                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14978                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
14979                 ndr->depth--;
14980                 ndr->depth--;
14981         }
14982         if (flags & NDR_OUT) {
14983                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
14984                 ndr->depth++;
14985                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
14986                 ndr->depth++;
14987                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
14988                 ndr->depth--;
14989                 ndr_print_ptr(ndr, "info", r->out.info);
14990                 ndr->depth++;
14991                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
14992                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
14993                 ndr->depth--;
14994                 ndr_print_WERROR(ndr, "result", r->out.result);
14995                 ndr->depth--;
14996         }
14997         ndr->depth--;
14998 }
14999
15000 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15001 {
15002         if (flags & NDR_IN) {
15003         }
15004         if (flags & NDR_OUT) {
15005                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15006         }
15007         return NDR_ERR_SUCCESS;
15008 }
15009
15010 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15011 {
15012         if (flags & NDR_IN) {
15013         }
15014         if (flags & NDR_OUT) {
15015                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15016         }
15017         return NDR_ERR_SUCCESS;
15018 }
15019
15020 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15021 {
15022         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15023         ndr->depth++;
15024         if (flags & NDR_SET_VALUES) {
15025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15026         }
15027         if (flags & NDR_IN) {
15028                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15029                 ndr->depth++;
15030                 ndr->depth--;
15031         }
15032         if (flags & NDR_OUT) {
15033                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15034                 ndr->depth++;
15035                 ndr_print_WERROR(ndr, "result", r->out.result);
15036                 ndr->depth--;
15037         }
15038         ndr->depth--;
15039 }
15040
15041 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15042 {
15043         if (flags & NDR_IN) {
15044                 if (r->in.bind_handle == NULL) {
15045                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15046                 }
15047                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15048                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15049                 if (r->in.req == NULL) {
15050                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15051                 }
15052                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15053                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15054         }
15055         if (flags & NDR_OUT) {
15056                 if (r->out.level_out == NULL) {
15057                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15058                 }
15059                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15060                 if (r->out.ctr == NULL) {
15061                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15062                 }
15063                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15064                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15065                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15066         }
15067         return NDR_ERR_SUCCESS;
15068 }
15069
15070 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15071 {
15072         TALLOC_CTX *_mem_save_bind_handle_0;
15073         TALLOC_CTX *_mem_save_req_0;
15074         TALLOC_CTX *_mem_save_level_out_0;
15075         TALLOC_CTX *_mem_save_ctr_0;
15076         if (flags & NDR_IN) {
15077                 ZERO_STRUCT(r->out);
15078
15079                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15080                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15081                 }
15082                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15083                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15084                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15085                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15086                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15087                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15088                         NDR_PULL_ALLOC(ndr, r->in.req);
15089                 }
15090                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15091                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15092                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15093                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15095                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15096                 ZERO_STRUCTP(r->out.level_out);
15097                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15098                 ZERO_STRUCTP(r->out.ctr);
15099         }
15100         if (flags & NDR_OUT) {
15101                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15102                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15103                 }
15104                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15105                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15106                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15107                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15108                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15109                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15110                 }
15111                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15112                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15113                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15114                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15115                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15116                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15117         }
15118         return NDR_ERR_SUCCESS;
15119 }
15120
15121 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15122 {
15123         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15124         ndr->depth++;
15125         if (flags & NDR_SET_VALUES) {
15126                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15127         }
15128         if (flags & NDR_IN) {
15129                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15130                 ndr->depth++;
15131                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15132                 ndr->depth++;
15133                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15134                 ndr->depth--;
15135                 ndr_print_int32(ndr, "level", r->in.level);
15136                 ndr_print_ptr(ndr, "req", r->in.req);
15137                 ndr->depth++;
15138                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15139                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15140                 ndr->depth--;
15141                 ndr->depth--;
15142         }
15143         if (flags & NDR_OUT) {
15144                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15145                 ndr->depth++;
15146                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15147                 ndr->depth++;
15148                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15149                 ndr->depth--;
15150                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15151                 ndr->depth++;
15152                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15153                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15154                 ndr->depth--;
15155                 ndr_print_WERROR(ndr, "result", r->out.result);
15156                 ndr->depth--;
15157         }
15158         ndr->depth--;
15159 }
15160
15161 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15162 {
15163         if (flags & NDR_IN) {
15164         }
15165         if (flags & NDR_OUT) {
15166                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15167         }
15168         return NDR_ERR_SUCCESS;
15169 }
15170
15171 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15172 {
15173         if (flags & NDR_IN) {
15174         }
15175         if (flags & NDR_OUT) {
15176                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15177         }
15178         return NDR_ERR_SUCCESS;
15179 }
15180
15181 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15182 {
15183         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15184         ndr->depth++;
15185         if (flags & NDR_SET_VALUES) {
15186                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15187         }
15188         if (flags & NDR_IN) {
15189                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15190                 ndr->depth++;
15191                 ndr->depth--;
15192         }
15193         if (flags & NDR_OUT) {
15194                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15195                 ndr->depth++;
15196                 ndr_print_WERROR(ndr, "result", r->out.result);
15197                 ndr->depth--;
15198         }
15199         ndr->depth--;
15200 }
15201
15202 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15203 {
15204         if (flags & NDR_IN) {
15205         }
15206         if (flags & NDR_OUT) {
15207                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15208         }
15209         return NDR_ERR_SUCCESS;
15210 }
15211
15212 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15213 {
15214         if (flags & NDR_IN) {
15215         }
15216         if (flags & NDR_OUT) {
15217                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15218         }
15219         return NDR_ERR_SUCCESS;
15220 }
15221
15222 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15223 {
15224         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15225         ndr->depth++;
15226         if (flags & NDR_SET_VALUES) {
15227                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15228         }
15229         if (flags & NDR_IN) {
15230                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15231                 ndr->depth++;
15232                 ndr->depth--;
15233         }
15234         if (flags & NDR_OUT) {
15235                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15236                 ndr->depth++;
15237                 ndr_print_WERROR(ndr, "result", r->out.result);
15238                 ndr->depth--;
15239         }
15240         ndr->depth--;
15241 }
15242
15243 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15244 {
15245         if (flags & NDR_IN) {
15246                 if (r->in.bind_handle == NULL) {
15247                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15248                 }
15249                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15250                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15251                 if (r->in.req == NULL) {
15252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15253                 }
15254                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15255                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15256         }
15257         if (flags & NDR_OUT) {
15258                 if (r->out.level_out == NULL) {
15259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15260                 }
15261                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15262                 if (r->out.ctr == NULL) {
15263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15264                 }
15265                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15266                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15267                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15268         }
15269         return NDR_ERR_SUCCESS;
15270 }
15271
15272 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15273 {
15274         TALLOC_CTX *_mem_save_bind_handle_0;
15275         TALLOC_CTX *_mem_save_req_0;
15276         TALLOC_CTX *_mem_save_level_out_0;
15277         TALLOC_CTX *_mem_save_ctr_0;
15278         if (flags & NDR_IN) {
15279                 ZERO_STRUCT(r->out);
15280
15281                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15282                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15283                 }
15284                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15285                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15286                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15287                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15288                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15290                         NDR_PULL_ALLOC(ndr, r->in.req);
15291                 }
15292                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15293                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15294                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15295                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15296                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15297                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15298                 ZERO_STRUCTP(r->out.level_out);
15299                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15300                 ZERO_STRUCTP(r->out.ctr);
15301         }
15302         if (flags & NDR_OUT) {
15303                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15304                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15305                 }
15306                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15307                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15308                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15309                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15310                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15311                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15312                 }
15313                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15314                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15315                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15316                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15318                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15319         }
15320         return NDR_ERR_SUCCESS;
15321 }
15322
15323 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15324 {
15325         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15326         ndr->depth++;
15327         if (flags & NDR_SET_VALUES) {
15328                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15329         }
15330         if (flags & NDR_IN) {
15331                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15332                 ndr->depth++;
15333                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15334                 ndr->depth++;
15335                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15336                 ndr->depth--;
15337                 ndr_print_int32(ndr, "level", r->in.level);
15338                 ndr_print_ptr(ndr, "req", r->in.req);
15339                 ndr->depth++;
15340                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15341                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15342                 ndr->depth--;
15343                 ndr->depth--;
15344         }
15345         if (flags & NDR_OUT) {
15346                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15347                 ndr->depth++;
15348                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15349                 ndr->depth++;
15350                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15351                 ndr->depth--;
15352                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15353                 ndr->depth++;
15354                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15355                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15356                 ndr->depth--;
15357                 ndr_print_WERROR(ndr, "result", r->out.result);
15358                 ndr->depth--;
15359         }
15360         ndr->depth--;
15361 }
15362
15363 static const struct ndr_interface_call drsuapi_calls[] = {
15364         {
15365                 "drsuapi_DsBind",
15366                 sizeof(struct drsuapi_DsBind),
15367                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15368                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15369                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15370                 false,
15371         },
15372         {
15373                 "drsuapi_DsUnbind",
15374                 sizeof(struct drsuapi_DsUnbind),
15375                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15376                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15377                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15378                 false,
15379         },
15380         {
15381                 "drsuapi_DsReplicaSync",
15382                 sizeof(struct drsuapi_DsReplicaSync),
15383                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15384                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15385                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15386                 false,
15387         },
15388         {
15389                 "drsuapi_DsGetNCChanges",
15390                 sizeof(struct drsuapi_DsGetNCChanges),
15391                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15392                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15393                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15394                 false,
15395         },
15396         {
15397                 "drsuapi_DsReplicaUpdateRefs",
15398                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15399                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15400                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15401                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15402                 false,
15403         },
15404         {
15405                 "drsuapi_DsReplicaAdd",
15406                 sizeof(struct drsuapi_DsReplicaAdd),
15407                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15408                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15409                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15410                 false,
15411         },
15412         {
15413                 "drsuapi_DsReplicaDel",
15414                 sizeof(struct drsuapi_DsReplicaDel),
15415                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15416                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15417                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15418                 false,
15419         },
15420         {
15421                 "drsuapi_DsReplicaMod",
15422                 sizeof(struct drsuapi_DsReplicaMod),
15423                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15424                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15425                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15426                 false,
15427         },
15428         {
15429                 "DRSUAPI_VERIFY_NAMES",
15430                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15431                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15432                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15433                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15434                 false,
15435         },
15436         {
15437                 "drsuapi_DsGetMemberships",
15438                 sizeof(struct drsuapi_DsGetMemberships),
15439                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15440                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15441                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15442                 false,
15443         },
15444         {
15445                 "DRSUAPI_INTER_DOMAIN_MOVE",
15446                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15447                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15448                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15449                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15450                 false,
15451         },
15452         {
15453                 "drsuapi_DsGetNT4ChangeLog",
15454                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15455                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15456                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15457                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15458                 false,
15459         },
15460         {
15461                 "drsuapi_DsCrackNames",
15462                 sizeof(struct drsuapi_DsCrackNames),
15463                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15464                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15465                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15466                 false,
15467         },
15468         {
15469                 "drsuapi_DsWriteAccountSpn",
15470                 sizeof(struct drsuapi_DsWriteAccountSpn),
15471                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15472                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15473                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15474                 false,
15475         },
15476         {
15477                 "drsuapi_DsRemoveDSServer",
15478                 sizeof(struct drsuapi_DsRemoveDSServer),
15479                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15480                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15481                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15482                 false,
15483         },
15484         {
15485                 "DRSUAPI_REMOVE_DS_DOMAIN",
15486                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15487                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15488                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15489                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15490                 false,
15491         },
15492         {
15493                 "drsuapi_DsGetDomainControllerInfo",
15494                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15495                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15496                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15497                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15498                 false,
15499         },
15500         {
15501                 "drsuapi_DsAddEntry",
15502                 sizeof(struct drsuapi_DsAddEntry),
15503                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15504                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15505                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15506                 false,
15507         },
15508         {
15509                 "drsuapi_DsExecuteKCC",
15510                 sizeof(struct drsuapi_DsExecuteKCC),
15511                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15512                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15513                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15514                 false,
15515         },
15516         {
15517                 "drsuapi_DsReplicaGetInfo",
15518                 sizeof(struct drsuapi_DsReplicaGetInfo),
15519                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15520                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15521                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15522                 false,
15523         },
15524         {
15525                 "DRSUAPI_ADD_SID_HISTORY",
15526                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15527                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15528                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15529                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15530                 false,
15531         },
15532         {
15533                 "drsuapi_DsGetMemberships2",
15534                 sizeof(struct drsuapi_DsGetMemberships2),
15535                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15536                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15537                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15538                 false,
15539         },
15540         {
15541                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15542                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15543                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15544                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15545                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15546                 false,
15547         },
15548         {
15549                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15550                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15551                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15552                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15553                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15554                 false,
15555         },
15556         {
15557                 "drsuapi_QuerySitesByCost",
15558                 sizeof(struct drsuapi_QuerySitesByCost),
15559                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15560                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15561                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15562                 false,
15563         },
15564         { NULL, 0, NULL, NULL, NULL, false }
15565 };
15566
15567 static const char * const drsuapi_endpoint_strings[] = {
15568         "ncacn_np:[\\pipe\\lsass]",
15569         "ncacn_np:[\\pipe\\protected_storage]",
15570         "ncacn_ip_tcp:",
15571         "ncalrpc:",
15572 };
15573
15574 static const struct ndr_interface_string_array drsuapi_endpoints = {
15575         .count  = 4,
15576         .names  = drsuapi_endpoint_strings
15577 };
15578
15579 static const char * const drsuapi_authservice_strings[] = {
15580         "ldap",
15581 };
15582
15583 static const struct ndr_interface_string_array drsuapi_authservices = {
15584         .count  = 1,
15585         .names  = drsuapi_authservice_strings
15586 };
15587
15588
15589 const struct ndr_interface_table ndr_table_drsuapi = {
15590         .name           = "drsuapi",
15591         .syntax_id      = {
15592                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15593                 NDR_DRSUAPI_VERSION
15594         },
15595         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15596         .num_calls      = 25,
15597         .calls          = drsuapi_calls,
15598         .endpoints      = &drsuapi_endpoints,
15599         .authservices   = &drsuapi_authservices
15600 };
15601