source/librpc/gen_ndr/ndr_drsuapi.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_drsuapi.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 #include "librpc/gen_ndr/ndr_misc.h"
   8 #include "librpc/gen_ndr/ndr_samr.h"
   9 #include "librpc/ndr/ndr_compression.h"
  10 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  11 {
  12         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  13         return NDR_ERR_SUCCESS;
  14 }
  15
  16 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  17 {
  18         uint32_t v;
  19         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  20         *r = v;
  21         return NDR_ERR_SUCCESS;
  22 }
  23
  24 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensions(struct ndr_print *ndr, const char *name, uint32_t r)
  25 {
  26         ndr_print_uint32(ndr, name, r);
  27         ndr->depth++;
  28         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_BASE", DRSUAPI_SUPPORTED_EXTENSION_BASE, r);
  29         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION, r);
  30         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI", DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI, r);
  31         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2", DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2, r);
  32         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS, r);
  33         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1, r);
  34         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION", DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION, r);
  35         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00000080", DRSUAPI_SUPPORTED_EXTENSION_00000080, r);
  36         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE", DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE, r);
  37         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2, r);
  38         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION, r);
  39         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2, r);
  40         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD", DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD, r);
  41         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND", DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND, r);
  42         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO", DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO, r);
  43         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION", DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION, r);
  44         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01, r);
  45         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP", DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP, r);
  46         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY", DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY, r);
  47         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3", DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3, r);
  48         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00100000", DRSUAPI_SUPPORTED_EXTENSION_00100000, r);
  49         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2", DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2, r);
  50         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6, r);
  51         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS", DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS, r);
  52         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8, r);
  53         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5, r);
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT", DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT, r);
  58         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS, r);
  59         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_20000000", DRSUAPI_SUPPORTED_EXTENSION_20000000, r);
  60         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_40000000", DRSUAPI_SUPPORTED_EXTENSION_40000000, r);
  61         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_80000000", DRSUAPI_SUPPORTED_EXTENSION_80000000, r);
  62         ndr->depth--;
  63 }
  64
  65 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensionsExt(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  66 {
  67         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  68         return NDR_ERR_SUCCESS;
  69 }
  70
  71 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensionsExt(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  72 {
  73         uint32_t v;
  74         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  75         *r = v;
  76         return NDR_ERR_SUCCESS;
  77 }
  78
  79 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensionsExt(struct ndr_print *ndr, const char *name, uint32_t r)
  80 {
  81         ndr_print_uint32(ndr, name, r);
  82         ndr->depth++;
  83         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADAM", DRSUAPI_SUPPORTED_EXTENSION_ADAM, r);
  84         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2", DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2, r);
  85         ndr->depth--;
  86 }
  87
  88 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo24 *r)
  89 {
  90         if (ndr_flags & NDR_SCALARS) {
  91                 NDR_CHECK(ndr_push_align(ndr, 4));
  92                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
  93                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
  94                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
  95         }
  96         if (ndr_flags & NDR_BUFFERS) {
  97         }
  98         return NDR_ERR_SUCCESS;
  99 }
 100
 101 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo24 *r)
 102 {
 103         if (ndr_flags & NDR_SCALARS) {
 104                 NDR_CHECK(ndr_pull_align(ndr, 4));
 105                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 106                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 108         }
 109         if (ndr_flags & NDR_BUFFERS) {
 110         }
 111         return NDR_ERR_SUCCESS;
 112 }
 113
 114 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r)
 115 {
 116         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo24");
 117         ndr->depth++;
 118         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 119         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 120         ndr_print_uint32(ndr, "pid", r->pid);
 121         ndr->depth--;
 122 }
 123
 124 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo28 *r)
 125 {
 126         if (ndr_flags & NDR_SCALARS) {
 127                 NDR_CHECK(ndr_push_align(ndr, 4));
 128                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 129                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 132         }
 133         if (ndr_flags & NDR_BUFFERS) {
 134         }
 135         return NDR_ERR_SUCCESS;
 136 }
 137
 138 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo28 *r)
 139 {
 140         if (ndr_flags & NDR_SCALARS) {
 141                 NDR_CHECK(ndr_pull_align(ndr, 4));
 142                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 143                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 146         }
 147         if (ndr_flags & NDR_BUFFERS) {
 148         }
 149         return NDR_ERR_SUCCESS;
 150 }
 151
 152 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo28(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo28 *r)
 153 {
 154         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo28");
 155         ndr->depth++;
 156         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 157         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 158         ndr_print_uint32(ndr, "pid", r->pid);
 159         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 160         ndr->depth--;
 161 }
 162
 163 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo48 *r)
 164 {
 165         if (ndr_flags & NDR_SCALARS) {
 166                 NDR_CHECK(ndr_push_align(ndr, 4));
 167                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 168                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 171                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
 172                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 173         }
 174         if (ndr_flags & NDR_BUFFERS) {
 175         }
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo48 *r)
 180 {
 181         if (ndr_flags & NDR_SCALARS) {
 182                 NDR_CHECK(ndr_pull_align(ndr, 4));
 183                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 184                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 187                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
 188                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 189         }
 190         if (ndr_flags & NDR_BUFFERS) {
 191         }
 192         return NDR_ERR_SUCCESS;
 193 }
 194
 195 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo48(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo48 *r)
 196 {
 197         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo48");
 198         ndr->depth++;
 199         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 200         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 201         ndr_print_uint32(ndr, "pid", r->pid);
 202         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 203         ndr_print_drsuapi_SupportedExtensionsExt(ndr, "supported_extensions_ext", r->supported_extensions_ext);
 204         ndr_print_GUID(ndr, "config_dn_guid", &r->config_dn_guid);
 205         ndr->depth--;
 206 }
 207
 208 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoFallBack *r)
 209 {
 210         if (ndr_flags & NDR_SCALARS) {
 211                 NDR_CHECK(ndr_push_align(ndr, 4));
 212                 {
 213                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 215                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
 216                         ndr->flags = _flags_save_DATA_BLOB;
 217                 }
 218         }
 219         if (ndr_flags & NDR_BUFFERS) {
 220         }
 221         return NDR_ERR_SUCCESS;
 222 }
 223
 224 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoFallBack *r)
 225 {
 226         if (ndr_flags & NDR_SCALARS) {
 227                 NDR_CHECK(ndr_pull_align(ndr, 4));
 228                 {
 229                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 231                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
 232                         ndr->flags = _flags_save_DATA_BLOB;
 233                 }
 234         }
 235         if (ndr_flags & NDR_BUFFERS) {
 236         }
 237         return NDR_ERR_SUCCESS;
 238 }
 239
 240 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoFallBack(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoFallBack *r)
 241 {
 242         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoFallBack");
 243         ndr->depth++;
 244         ndr_print_DATA_BLOB(ndr, "info", r->info);
 245         ndr->depth--;
 246 }
 247
 248 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
 249 {
 250         if (ndr_flags & NDR_SCALARS) {
 251                 int level = ndr_push_get_switch_value(ndr, r);
 252                 switch (level) {
 253                         case 24: {
 254                                 {
 255                                         struct ndr_push *_ndr_info24;
 256                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 4, -1));
 257                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 258                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 4, -1));
 259                                 }
 260                         break; }
 261
 262                         case 28: {
 263                                 {
 264                                         struct ndr_push *_ndr_info28;
 265                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 4, -1));
 266                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 267                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 4, -1));
 268                                 }
 269                         break; }
 270
 271                         case 48: {
 272                                 {
 273                                         struct ndr_push *_ndr_info48;
 274                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 4, -1));
 275                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 276                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 4, -1));
 277                                 }
 278                         break; }
 279
 280                         default: {
 281                                 {
 282                                         struct ndr_push *_ndr_FallBack;
 283                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 284                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 285                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 286                                 }
 287                         break; }
 288
 289                 }
 290         }
 291         if (ndr_flags & NDR_BUFFERS) {
 292                 int level = ndr_push_get_switch_value(ndr, r);
 293                 switch (level) {
 294                         case 24:
 295                         break;
 296
 297                         case 28:
 298                         break;
 299
 300                         case 48:
 301                         break;
 302
 303                         default:
 304                         break;
 305
 306                 }
 307         }
 308         return NDR_ERR_SUCCESS;
 309 }
 310
 311 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
 312 {
 313         int level;
 314         level = ndr_pull_get_switch_value(ndr, r);
 315         if (ndr_flags & NDR_SCALARS) {
 316                 switch (level) {
 317                         case 24: {
 318                                 {
 319                                         struct ndr_pull *_ndr_info24;
 320                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 4, -1));
 321                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 322                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 4, -1));
 323                                 }
 324                         break; }
 325
 326                         case 28: {
 327                                 {
 328                                         struct ndr_pull *_ndr_info28;
 329                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 4, -1));
 330                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 331                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 4, -1));
 332                                 }
 333                         break; }
 334
 335                         case 48: {
 336                                 {
 337                                         struct ndr_pull *_ndr_info48;
 338                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 4, -1));
 339                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 340                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 4, -1));
 341                                 }
 342                         break; }
 343
 344                         default: {
 345                                 {
 346                                         struct ndr_pull *_ndr_FallBack;
 347                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 348                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 349                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 350                                 }
 351                         break; }
 352
 353                 }
 354         }
 355         if (ndr_flags & NDR_BUFFERS) {
 356                 switch (level) {
 357                         case 24:
 358                         break;
 359
 360                         case 28:
 361                         break;
 362
 363                         case 48:
 364                         break;
 365
 366                         default:
 367                         break;
 368
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
 375 {
 376         int level;
 377         level = ndr_print_get_switch_value(ndr, r);
 378         ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
 379         switch (level) {
 380                 case 24:
 381                         ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
 382                 break;
 383
 384                 case 28:
 385                         ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
 386                 break;
 387
 388                 case 48:
 389                         ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
 390                 break;
 391
 392                 default:
 393                         ndr_print_drsuapi_DsBindInfoFallBack(ndr, "FallBack", &r->FallBack);
 394                 break;
 395
 396         }
 397 }
 398
 399 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoCtr *r)
 400 {
 401         if (ndr_flags & NDR_SCALARS) {
 402                 NDR_CHECK(ndr_push_align(ndr, 4));
 403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 404                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
 405                 NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 406         }
 407         if (ndr_flags & NDR_BUFFERS) {
 408         }
 409         return NDR_ERR_SUCCESS;
 410 }
 411
 412 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoCtr *r)
 413 {
 414         if (ndr_flags & NDR_SCALARS) {
 415                 NDR_CHECK(ndr_pull_align(ndr, 4));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 417                 if (r->length < 1 || r->length > 10000) {
 418                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 419                 }
 420                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
 421                 NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 422         }
 423         if (ndr_flags & NDR_BUFFERS) {
 424         }
 425         return NDR_ERR_SUCCESS;
 426 }
 427
 428 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoCtr *r)
 429 {
 430         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoCtr");
 431         ndr->depth++;
 432         ndr_print_uint32(ndr, "length", r->length);
 433         ndr_print_set_switch_value(ndr, &r->info, r->length);
 434         ndr_print_drsuapi_DsBindInfo(ndr, "info", &r->info);
 435         ndr->depth--;
 436 }
 437
 438 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 439 {
 440         if (ndr_flags & NDR_SCALARS) {
 441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
 442                 NDR_CHECK(ndr_push_align(ndr, 4));
 443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->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->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, int flags)
 491 {
 492         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier);
 493 }
 494
 495 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 496 {
 497         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 498         return NDR_ERR_SUCCESS;
 499 }
 500
 501 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 502 {
 503         uint32_t v;
 504         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 505         *r = v;
 506         return NDR_ERR_SUCCESS;
 507 }
 508
 509 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, const char *name, uint32_t r)
 510 {
 511         ndr_print_uint32(ndr, name, r);
 512         ndr->depth++;
 513         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION, r);
 514         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_WRITEABLE", DRSUAPI_DS_REPLICA_SYNC_WRITEABLE, r);
 515         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PERIODIC", DRSUAPI_DS_REPLICA_SYNC_PERIODIC, r);
 516         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING", DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING, r);
 517         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES", DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES, r);
 518         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL", DRSUAPI_DS_REPLICA_SYNC_FULL, r);
 519         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_URGENT", DRSUAPI_DS_REPLICA_SYNC_URGENT, r);
 520         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD", DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD, r);
 521         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FORCE", DRSUAPI_DS_REPLICA_SYNC_FORCE, r);
 522         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE", DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE, r);
 523         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED", DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED, r);
 524         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_TWO_WAY", DRSUAPI_DS_REPLICA_SYNC_TWO_WAY, r);
 525         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY", DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY, r);
 526         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL", DRSUAPI_DS_REPLICA_SYNC_INITIAL, r);
 527         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION", DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION, r);
 528         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ABANDONED", DRSUAPI_DS_REPLICA_SYNC_ABANDONED, r);
 529         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS, r);
 530         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET, r);
 531         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_REQUEUE", DRSUAPI_DS_REPLICA_SYNC_REQUEUE, r);
 532         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION", DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION, r);
 533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA, r);
 534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_CRITICAL", DRSUAPI_DS_REPLICA_SYNC_CRITICAL, r);
 535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS, r);
 536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PREEMPTED", DRSUAPI_DS_REPLICA_SYNC_PREEMPTED, r);
 537         ndr->depth--;
 538 }
 539
 540 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 541 {
 542         if (ndr_flags & NDR_SCALARS) {
 543                 NDR_CHECK(ndr_push_align(ndr, 4));
 544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
 545                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 546                 {
 547                         uint32_t _flags_save_string = ndr->flags;
 548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 549                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
 550                         ndr->flags = _flags_save_string;
 551                 }
 552                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->options));
 553         }
 554         if (ndr_flags & NDR_BUFFERS) {
 555                 if (r->naming_context) {
 556                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 557                 }
 558                 {
 559                         uint32_t _flags_save_string = ndr->flags;
 560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 561                         if (r->other_info) {
 562                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->other_info));
 563                         }
 564                         ndr->flags = _flags_save_string;
 565                 }
 566         }
 567         return NDR_ERR_SUCCESS;
 568 }
 569
 570 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 571 {
 572         uint32_t _ptr_naming_context;
 573         TALLOC_CTX *_mem_save_naming_context_0;
 574         uint32_t _ptr_other_info;
 575         TALLOC_CTX *_mem_save_other_info_0;
 576         if (ndr_flags & NDR_SCALARS) {
 577                 NDR_CHECK(ndr_pull_align(ndr, 4));
 578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
 579                 if (_ptr_naming_context) {
 580                         NDR_PULL_ALLOC(ndr, r->naming_context);
 581                 } else {
 582                         r->naming_context = NULL;
 583                 }
 584                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 585                 {
 586                         uint32_t _flags_save_string = ndr->flags;
 587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 588                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 589                         if (_ptr_other_info) {
 590                                 NDR_PULL_ALLOC(ndr, r->other_info);
 591                         } else {
 592                                 r->other_info = NULL;
 593                         }
 594                         ndr->flags = _flags_save_string;
 595                 }
 596                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->options));
 597         }
 598         if (ndr_flags & NDR_BUFFERS) {
 599                 if (r->naming_context) {
 600                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 601                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 602                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 604                 }
 605                 {
 606                         uint32_t _flags_save_string = ndr->flags;
 607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 608                         if (r->other_info) {
 609                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 610                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->other_info));
 612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 613                         }
 614                         ndr->flags = _flags_save_string;
 615                 }
 616         }
 617         return NDR_ERR_SUCCESS;
 618 }
 619
 620 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 621 {
 622         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 623         ndr->depth++;
 624         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 625         ndr->depth++;
 626         if (r->naming_context) {
 627                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 628         }
 629         ndr->depth--;
 630         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 631         ndr_print_ptr(ndr, "other_info", r->other_info);
 632         ndr->depth++;
 633         if (r->other_info) {
 634                 ndr_print_string(ndr, "other_info", r->other_info);
 635         }
 636         ndr->depth--;
 637         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "options", r->options);
 638         ndr->depth--;
 639 }
 640
 641 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 642 {
 643         if (ndr_flags & NDR_SCALARS) {
 644                 int level = ndr_push_get_switch_value(ndr, r);
 645                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
 646                 switch (level) {
 647                         case 1: {
 648                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 649                         break; }
 650
 651                         default:
 652                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 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", level);
 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", _level);
 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", level);
 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", level);
 696                 }
 697         }
 698         return NDR_ERR_SUCCESS;
 699 }
 700
 701 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 702 {
 703         int level;
 704         level = ndr_print_get_switch_value(ndr, r);
 705         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 706         switch (level) {
 707                 case 1:
 708                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 709                 break;
 710
 711                 default:
 712                         ndr_print_bad_level(ndr, name, level);
 713         }
 714 }
 715
 716 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 717 {
 718         if (ndr_flags & NDR_SCALARS) {
 719                 NDR_CHECK(ndr_push_align(ndr, 8));
 720                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 721                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 722                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 723         }
 724         if (ndr_flags & NDR_BUFFERS) {
 725         }
 726         return NDR_ERR_SUCCESS;
 727 }
 728
 729 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 730 {
 731         if (ndr_flags & NDR_SCALARS) {
 732                 NDR_CHECK(ndr_pull_align(ndr, 8));
 733                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 734                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 735                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 736         }
 737         if (ndr_flags & NDR_BUFFERS) {
 738         }
 739         return NDR_ERR_SUCCESS;
 740 }
 741
 742 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 743 {
 744         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 745         ndr->depth++;
 746         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 747         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 748         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 749         ndr->depth--;
 750 }
 751
 752 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 753 {
 754         if (ndr_flags & NDR_SCALARS) {
 755                 NDR_CHECK(ndr_push_align(ndr, 8));
 756                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 757                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 758         }
 759         if (ndr_flags & NDR_BUFFERS) {
 760         }
 761         return NDR_ERR_SUCCESS;
 762 }
 763
 764 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 765 {
 766         if (ndr_flags & NDR_SCALARS) {
 767                 NDR_CHECK(ndr_pull_align(ndr, 8));
 768                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 769                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 770         }
 771         if (ndr_flags & NDR_BUFFERS) {
 772         }
 773         return NDR_ERR_SUCCESS;
 774 }
 775
 776 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 777 {
 778         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 779         ndr->depth++;
 780         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 781         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 782         ndr->depth--;
 783 }
 784
 785 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 786 {
 787         uint32_t cntr_cursors_0;
 788         if (ndr_flags & NDR_SCALARS) {
 789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 790                 NDR_CHECK(ndr_push_align(ndr, 8));
 791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 795                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 796                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 797                 }
 798         }
 799         if (ndr_flags & NDR_BUFFERS) {
 800         }
 801         return NDR_ERR_SUCCESS;
 802 }
 803
 804 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 805 {
 806         uint32_t cntr_cursors_0;
 807         TALLOC_CTX *_mem_save_cursors_0;
 808         if (ndr_flags & NDR_SCALARS) {
 809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 810                 NDR_CHECK(ndr_pull_align(ndr, 8));
 811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 814                 if (r->count < 0 || r->count > 0x100000) {
 815                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 816                 }
 817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 818                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
 819                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 820                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 821                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 822                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 823                 }
 824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 825                 if (r->cursors) {
 826                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 827                 }
 828         }
 829         if (ndr_flags & NDR_BUFFERS) {
 830         }
 831         return NDR_ERR_SUCCESS;
 832 }
 833
 834 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 835 {
 836         uint32_t cntr_cursors_0;
 837         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 838         ndr->depth++;
 839         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 840         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 841         ndr_print_uint32(ndr, "count", r->count);
 842         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 843         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 844         ndr->depth++;
 845         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 846                 char *idx_0=NULL;
 847                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 848                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 849                         free(idx_0);
 850                 }
 851         }
 852         ndr->depth--;
 853         ndr->depth--;
 854 }
 855
 856 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 857 {
 858         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 859         return NDR_ERR_SUCCESS;
 860 }
 861
 862 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 863 {
 864         uint32_t v;
 865         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 866         *r = v;
 867         return NDR_ERR_SUCCESS;
 868 }
 869
 870 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 871 {
 872         ndr_print_uint32(ndr, name, r);
 873         ndr->depth++;
 874         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE", DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE, r);
 875         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP", DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP, r);
 876         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS", DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS, r);
 877         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_USE_ASYNC_INTERSIDE_TRANSPORT", DRSUAPI_DS_REPLICA_NEIGHBOUR_USE_ASYNC_INTERSIDE_TRANSPORT, r);
 878         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC, r);
 879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS", DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS, r);
 880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS, r);
 881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_NEXT_PACKET", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_NEXT_PACKET, r);
 882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED", DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED, r);
 883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED", DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED, r);
 884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS, r);
 885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC, r);
 886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES", DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES, r);
 887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS, r);
 888         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET, r);
 889         ndr->depth--;
 890 }
 891
 892 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 893 {
 894         {
 895                 uint32_t _flags_save_ENUM = ndr->flags;
 896                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 898                 ndr->flags = _flags_save_ENUM;
 899         }
 900         return NDR_ERR_SUCCESS;
 901 }
 902
 903 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 904 {
 905         uint32_t v;
 906         {
 907                 uint32_t _flags_save_ENUM = ndr->flags;
 908                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 910                 *r = v;
 911                 ndr->flags = _flags_save_ENUM;
 912         }
 913         return NDR_ERR_SUCCESS;
 914 }
 915
 916 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 917 {
 918         const char *val = NULL;
 919
 920         {
 921                 uint32_t _flags_save_ENUM = ndr->flags;
 922                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 923                 switch (r) {
 924                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
 925                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
 926                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
 927                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
 928                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
 929                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
 930                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
 931                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
 932                 }
 933                 ndr_print_enum(ndr, name, "ENUM", val, r);
 934                 ndr->flags = _flags_save_ENUM;
 935         }
 936 }
 937
 938 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
 939 {
 940         {
 941                 uint32_t _flags_save_ENUM = ndr->flags;
 942                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 944                 ndr->flags = _flags_save_ENUM;
 945         }
 946         return NDR_ERR_SUCCESS;
 947 }
 948
 949 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
 950 {
 951         uint32_t v;
 952         {
 953                 uint32_t _flags_save_ENUM = ndr->flags;
 954                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 956                 *r = v;
 957                 ndr->flags = _flags_save_ENUM;
 958         }
 959         return NDR_ERR_SUCCESS;
 960 }
 961
 962 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
 963 {
 964         const char *val = NULL;
 965
 966         {
 967                 uint32_t _flags_save_ENUM = ndr->flags;
 968                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 969                 switch (r) {
 970                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
 971                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
 972                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
 973                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
 974                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
 975                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
 976                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
 977                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
 978                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
 979                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
 980                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
 981                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
 982                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
 983                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
 984                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
 985                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
 986                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
 987                 }
 988                 ndr_print_enum(ndr, name, "ENUM", val, r);
 989                 ndr->flags = _flags_save_ENUM;
 990         }
 991 }
 992
 993 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
 994 {
 995         if (ndr_flags & NDR_SCALARS) {
 996                 NDR_CHECK(ndr_push_align(ndr, 8));
 997                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
 998                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 999                 if (r->naming_context == NULL) {
1000                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1001                 }
1002                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1003                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1005                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1008                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1009                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1010         }
1011         if (ndr_flags & NDR_BUFFERS) {
1012                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1013                 if (r->uptodateness_vector) {
1014                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1015                 }
1016         }
1017         return NDR_ERR_SUCCESS;
1018 }
1019
1020 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1021 {
1022         uint32_t _ptr_naming_context;
1023         TALLOC_CTX *_mem_save_naming_context_0;
1024         uint32_t _ptr_uptodateness_vector;
1025         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1026         if (ndr_flags & NDR_SCALARS) {
1027                 NDR_CHECK(ndr_pull_align(ndr, 8));
1028                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1029                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1030                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1031                 if (_ptr_naming_context) {
1032                         NDR_PULL_ALLOC(ndr, r->naming_context);
1033                 } else {
1034                         r->naming_context = NULL;
1035                 }
1036                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1037                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1038                 if (_ptr_uptodateness_vector) {
1039                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1040                 } else {
1041                         r->uptodateness_vector = NULL;
1042                 }
1043                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1045                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1046                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1047                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1048         }
1049         if (ndr_flags & NDR_BUFFERS) {
1050                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1051                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1052                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1053                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1054                 if (r->uptodateness_vector) {
1055                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1056                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1057                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1058                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1059                 }
1060         }
1061         return NDR_ERR_SUCCESS;
1062 }
1063
1064 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1065 {
1066         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1067         ndr->depth++;
1068         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1069         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1070         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1071         ndr->depth++;
1072         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1073         ndr->depth--;
1074         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1075         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1076         ndr->depth++;
1077         if (r->uptodateness_vector) {
1078                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1079         }
1080         ndr->depth--;
1081         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1082         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1083         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1084         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1085         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1086         ndr->depth--;
1087 }
1088
1089 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
1090 {
1091         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
1092         ndr->depth++;
1093         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaOID_oid(r->oid, 0):r->__ndr_size);
1094         ndr_print_ptr(ndr, "oid", r->oid);
1095         ndr->depth++;
1096         if (r->oid) {
1097                 ndr_print_string(ndr, "oid", r->oid);
1098         }
1099         ndr->depth--;
1100         ndr->depth--;
1101 }
1102
1103 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1104 {
1105         if (ndr_flags & NDR_SCALARS) {
1106                 NDR_CHECK(ndr_push_align(ndr, 4));
1107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1108                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1109         }
1110         if (ndr_flags & NDR_BUFFERS) {
1111                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1112         }
1113         return NDR_ERR_SUCCESS;
1114 }
1115
1116 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1117 {
1118         if (ndr_flags & NDR_SCALARS) {
1119                 NDR_CHECK(ndr_pull_align(ndr, 4));
1120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1121                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1122         }
1123         if (ndr_flags & NDR_BUFFERS) {
1124                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1125         }
1126         return NDR_ERR_SUCCESS;
1127 }
1128
1129 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1130 {
1131         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1132         ndr->depth++;
1133         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1134         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1135         ndr->depth--;
1136 }
1137
1138 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1139 {
1140         uint32_t cntr_mappings_1;
1141         if (ndr_flags & NDR_SCALARS) {
1142                 NDR_CHECK(ndr_push_align(ndr, 4));
1143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1144                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1145         }
1146         if (ndr_flags & NDR_BUFFERS) {
1147                 if (r->mappings) {
1148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1149                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1150                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1151                         }
1152                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1153                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1154                         }
1155                 }
1156         }
1157         return NDR_ERR_SUCCESS;
1158 }
1159
1160 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1161 {
1162         uint32_t _ptr_mappings;
1163         uint32_t cntr_mappings_1;
1164         TALLOC_CTX *_mem_save_mappings_0;
1165         TALLOC_CTX *_mem_save_mappings_1;
1166         if (ndr_flags & NDR_SCALARS) {
1167                 NDR_CHECK(ndr_pull_align(ndr, 4));
1168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1169                 if (r->num_mappings < 0 || 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_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1265                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1266                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1267                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1268                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1269                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1270                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1271                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1272                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1273                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1274                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1275                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1276                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1277                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1278                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1279                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1280                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1281                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1282                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1283                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1284                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1285                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1286                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1287                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1288                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1289                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1290                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1291                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1292                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1293                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1294                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1295                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1296                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1297                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1298                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1299                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1300                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1301                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1302                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1303                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1304                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1305                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1306                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1307                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1308                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1309                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1310                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1311                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1312                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1313                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1314                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1315                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1316                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1317                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1318                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1319                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1320                 }
1321                 ndr_print_enum(ndr, name, "ENUM", val, r);
1322                 ndr->flags = _flags_save_ENUM;
1323         }
1324 }
1325
1326 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1327 {
1328         uint32_t cntr_attids_0;
1329         if (ndr_flags & NDR_SCALARS) {
1330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1331                 NDR_CHECK(ndr_push_align(ndr, 4));
1332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1335                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1336                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1337                 }
1338         }
1339         if (ndr_flags & NDR_BUFFERS) {
1340         }
1341         return NDR_ERR_SUCCESS;
1342 }
1343
1344 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1345 {
1346         uint32_t cntr_attids_0;
1347         TALLOC_CTX *_mem_save_attids_0;
1348         if (ndr_flags & NDR_SCALARS) {
1349                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1350                 NDR_CHECK(ndr_pull_align(ndr, 4));
1351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1354                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1355                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1356                 }
1357                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1358                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1359                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1360                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1361                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1362                 }
1363                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1364                 if (r->attids) {
1365                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1366                 }
1367         }
1368         if (ndr_flags & NDR_BUFFERS) {
1369         }
1370         return NDR_ERR_SUCCESS;
1371 }
1372
1373 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1374 {
1375         uint32_t cntr_attids_0;
1376         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1377         ndr->depth++;
1378         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1379         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1380         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1381         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1382         ndr->depth++;
1383         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1384                 char *idx_0=NULL;
1385                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1386                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1387                         free(idx_0);
1388                 }
1389         }
1390         ndr->depth--;
1391         ndr->depth--;
1392 }
1393
1394 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1395 {
1396         if (ndr_flags & NDR_SCALARS) {
1397                 NDR_CHECK(ndr_push_align(ndr, 8));
1398                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1399                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1400                 if (r->naming_context == NULL) {
1401                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1402                 }
1403                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1404                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1406                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1409                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1410                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1413                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1414         }
1415         if (ndr_flags & NDR_BUFFERS) {
1416                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1417                 if (r->uptodateness_vector) {
1418                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1419                 }
1420                 if (r->partial_attribute_set) {
1421                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1422                 }
1423                 if (r->partial_attribute_set_ex) {
1424                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1425                 }
1426                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1427         }
1428         return NDR_ERR_SUCCESS;
1429 }
1430
1431 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1432 {
1433         uint32_t _ptr_naming_context;
1434         TALLOC_CTX *_mem_save_naming_context_0;
1435         uint32_t _ptr_uptodateness_vector;
1436         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1437         uint32_t _ptr_partial_attribute_set;
1438         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1439         uint32_t _ptr_partial_attribute_set_ex;
1440         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1441         if (ndr_flags & NDR_SCALARS) {
1442                 NDR_CHECK(ndr_pull_align(ndr, 8));
1443                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1444                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1445                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1446                 if (_ptr_naming_context) {
1447                         NDR_PULL_ALLOC(ndr, r->naming_context);
1448                 } else {
1449                         r->naming_context = NULL;
1450                 }
1451                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1453                 if (_ptr_uptodateness_vector) {
1454                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1455                 } else {
1456                         r->uptodateness_vector = NULL;
1457                 }
1458                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1461                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1462                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1464                 if (_ptr_partial_attribute_set) {
1465                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1466                 } else {
1467                         r->partial_attribute_set = NULL;
1468                 }
1469                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1470                 if (_ptr_partial_attribute_set_ex) {
1471                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1472                 } else {
1473                         r->partial_attribute_set_ex = NULL;
1474                 }
1475                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1476         }
1477         if (ndr_flags & NDR_BUFFERS) {
1478                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1479                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1480                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1482                 if (r->uptodateness_vector) {
1483                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1484                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1485                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1486                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1487                 }
1488                 if (r->partial_attribute_set) {
1489                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1490                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1491                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1493                 }
1494                 if (r->partial_attribute_set_ex) {
1495                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1496                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1497                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1499                 }
1500                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1501         }
1502         return NDR_ERR_SUCCESS;
1503 }
1504
1505 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1506 {
1507         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1508         ndr->depth++;
1509         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1510         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1511         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1512         ndr->depth++;
1513         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1514         ndr->depth--;
1515         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1516         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1517         ndr->depth++;
1518         if (r->uptodateness_vector) {
1519                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1520         }
1521         ndr->depth--;
1522         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1523         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1524         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1525         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1526         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1527         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1528         ndr->depth++;
1529         if (r->partial_attribute_set) {
1530                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1531         }
1532         ndr->depth--;
1533         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1534         ndr->depth++;
1535         if (r->partial_attribute_set_ex) {
1536                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1537         }
1538         ndr->depth--;
1539         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1540         ndr->depth--;
1541 }
1542
1543 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1544 {
1545         if (ndr_flags & NDR_SCALARS) {
1546                 int level = ndr_push_get_switch_value(ndr, r);
1547                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1548                 switch (level) {
1549                         case 5: {
1550                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1551                         break; }
1552
1553                         case 8: {
1554                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1555                         break; }
1556
1557                         default:
1558                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1559                 }
1560         }
1561         if (ndr_flags & NDR_BUFFERS) {
1562                 int level = ndr_push_get_switch_value(ndr, r);
1563                 switch (level) {
1564                         case 5:
1565                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1566                         break;
1567
1568                         case 8:
1569                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1570                         break;
1571
1572                         default:
1573                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1574                 }
1575         }
1576         return NDR_ERR_SUCCESS;
1577 }
1578
1579 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1580 {
1581         int level;
1582         int32_t _level;
1583         level = ndr_pull_get_switch_value(ndr, r);
1584         if (ndr_flags & NDR_SCALARS) {
1585                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1586                 if (_level != level) {
1587                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1588                 }
1589                 switch (level) {
1590                         case 5: {
1591                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1592                         break; }
1593
1594                         case 8: {
1595                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1596                         break; }
1597
1598                         default:
1599                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1600                 }
1601         }
1602         if (ndr_flags & NDR_BUFFERS) {
1603                 switch (level) {
1604                         case 5:
1605                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1606                         break;
1607
1608                         case 8:
1609                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1610                         break;
1611
1612                         default:
1613                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1614                 }
1615         }
1616         return NDR_ERR_SUCCESS;
1617 }
1618
1619 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1620 {
1621         int level;
1622         level = ndr_print_get_switch_value(ndr, r);
1623         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1624         switch (level) {
1625                 case 5:
1626                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1627                 break;
1628
1629                 case 8:
1630                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1631                 break;
1632
1633                 default:
1634                         ndr_print_bad_level(ndr, name, level);
1635         }
1636 }
1637
1638 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1639 {
1640         if (ndr_flags & NDR_SCALARS) {
1641                 NDR_CHECK(ndr_push_align(ndr, 8));
1642                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1643                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1644                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1645         }
1646         if (ndr_flags & NDR_BUFFERS) {
1647         }
1648         return NDR_ERR_SUCCESS;
1649 }
1650
1651 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1652 {
1653         if (ndr_flags & NDR_SCALARS) {
1654                 NDR_CHECK(ndr_pull_align(ndr, 8));
1655                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1656                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1657                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1658         }
1659         if (ndr_flags & NDR_BUFFERS) {
1660         }
1661         return NDR_ERR_SUCCESS;
1662 }
1663
1664 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1665 {
1666         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1667         ndr->depth++;
1668         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1669         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1670         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1671         ndr->depth--;
1672 }
1673
1674 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1675 {
1676         uint32_t cntr_cursors_0;
1677         if (ndr_flags & NDR_SCALARS) {
1678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1679                 NDR_CHECK(ndr_push_align(ndr, 8));
1680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1684                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1685                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1686                 }
1687         }
1688         if (ndr_flags & NDR_BUFFERS) {
1689         }
1690         return NDR_ERR_SUCCESS;
1691 }
1692
1693 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1694 {
1695         uint32_t cntr_cursors_0;
1696         TALLOC_CTX *_mem_save_cursors_0;
1697         if (ndr_flags & NDR_SCALARS) {
1698                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1699                 NDR_CHECK(ndr_pull_align(ndr, 8));
1700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1703                 if (r->count < 0 || r->count > 0x100000) {
1704                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1705                 }
1706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1707                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1708                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1709                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1710                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1711                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1712                 }
1713                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
1714                 if (r->cursors) {
1715                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
1716                 }
1717         }
1718         if (ndr_flags & NDR_BUFFERS) {
1719         }
1720         return NDR_ERR_SUCCESS;
1721 }
1722
1723 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1724 {
1725         uint32_t cntr_cursors_0;
1726         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
1727         ndr->depth++;
1728         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
1729         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1730         ndr_print_uint32(ndr, "count", r->count);
1731         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
1732         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
1733         ndr->depth++;
1734         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
1735                 char *idx_0=NULL;
1736                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
1737                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
1738                         free(idx_0);
1739                 }
1740         }
1741         ndr->depth--;
1742         ndr->depth--;
1743 }
1744
1745 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
1746 {
1747         if (ndr_flags & NDR_SCALARS) {
1748                 NDR_CHECK(ndr_push_align(ndr, 4));
1749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
1750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
1751         }
1752         if (ndr_flags & NDR_BUFFERS) {
1753                 if (r->blob) {
1754                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
1755                 }
1756         }
1757         return NDR_ERR_SUCCESS;
1758 }
1759
1760 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
1761 {
1762         uint32_t _ptr_blob;
1763         TALLOC_CTX *_mem_save_blob_0;
1764         if (ndr_flags & NDR_SCALARS) {
1765                 NDR_CHECK(ndr_pull_align(ndr, 4));
1766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1767                 if (r->__ndr_size < 0 || r->__ndr_size > 10485760) {
1768                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1769                 }
1770                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
1771                 if (_ptr_blob) {
1772                         NDR_PULL_ALLOC(ndr, r->blob);
1773                 } else {
1774                         r->blob = NULL;
1775                 }
1776         }
1777         if (ndr_flags & NDR_BUFFERS) {
1778                 if (r->blob) {
1779                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
1780                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
1781                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
1782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
1783                 }
1784         }
1785         return NDR_ERR_SUCCESS;
1786 }
1787
1788 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
1789 {
1790         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
1791         ndr->depth++;
1792         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
1793         ndr_print_ptr(ndr, "blob", r->blob);
1794         ndr->depth++;
1795         if (r->blob) {
1796                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
1797         }
1798         ndr->depth--;
1799         ndr->depth--;
1800 }
1801
1802 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
1803 {
1804         uint32_t cntr_values_1;
1805         if (ndr_flags & NDR_SCALARS) {
1806                 NDR_CHECK(ndr_push_align(ndr, 4));
1807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
1808                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
1809         }
1810         if (ndr_flags & NDR_BUFFERS) {
1811                 if (r->values) {
1812                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
1813                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1814                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
1815                         }
1816                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1817                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
1818                         }
1819                 }
1820         }
1821         return NDR_ERR_SUCCESS;
1822 }
1823
1824 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
1825 {
1826         uint32_t _ptr_values;
1827         uint32_t cntr_values_1;
1828         TALLOC_CTX *_mem_save_values_0;
1829         TALLOC_CTX *_mem_save_values_1;
1830         if (ndr_flags & NDR_SCALARS) {
1831                 NDR_CHECK(ndr_pull_align(ndr, 4));
1832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
1833                 if (r->num_values < 0 || r->num_values > 10485760) {
1834                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1835                 }
1836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
1837                 if (_ptr_values) {
1838                         NDR_PULL_ALLOC(ndr, r->values);
1839                 } else {
1840                         r->values = NULL;
1841                 }
1842         }
1843         if (ndr_flags & NDR_BUFFERS) {
1844                 if (r->values) {
1845                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
1846                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
1847                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
1848                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
1849                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
1850                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
1851                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1852                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
1853                         }
1854                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1855                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
1856                         }
1857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
1858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
1859                 }
1860                 if (r->values) {
1861                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
1862                 }
1863         }
1864         return NDR_ERR_SUCCESS;
1865 }
1866
1867 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
1868 {
1869         uint32_t cntr_values_1;
1870         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
1871         ndr->depth++;
1872         ndr_print_uint32(ndr, "num_values", r->num_values);
1873         ndr_print_ptr(ndr, "values", r->values);
1874         ndr->depth++;
1875         if (r->values) {
1876                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
1877                 ndr->depth++;
1878                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
1879                         char *idx_1=NULL;
1880                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
1881                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
1882                                 free(idx_1);
1883                         }
1884                 }
1885                 ndr->depth--;
1886         }
1887         ndr->depth--;
1888         ndr->depth--;
1889 }
1890
1891 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
1892 {
1893         if (ndr_flags & NDR_SCALARS) {
1894                 NDR_CHECK(ndr_push_align(ndr, 4));
1895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->flags)));
1896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
1897                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
1898                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
1900                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
1901         }
1902         if (ndr_flags & NDR_BUFFERS) {
1903                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1904         }
1905         return NDR_ERR_SUCCESS;
1906 }
1907
1908 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
1909 {
1910         if (ndr_flags & NDR_SCALARS) {
1911                 NDR_CHECK(ndr_pull_align(ndr, 4));
1912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
1914                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
1915                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
1917                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
1918         }
1919         if (ndr_flags & NDR_BUFFERS) {
1920                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1921         }
1922         return NDR_ERR_SUCCESS;
1923 }
1924
1925 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
1926 {
1927         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
1928         ndr->depth++;
1929         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->flags):r->__ndr_size);
1930         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);
1931         ndr_print_GUID(ndr, "guid", &r->guid);
1932         ndr_print_dom_sid28(ndr, "sid", &r->sid);
1933         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
1934         ndr_print_string(ndr, "dn", r->dn);
1935         ndr->depth--;
1936 }
1937
1938 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, int flags)
1939 {
1940         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1941 }
1942
1943 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
1944 {
1945         if (ndr_flags & NDR_SCALARS) {
1946                 NDR_CHECK(ndr_push_align(ndr, 4));
1947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(r, ndr->flags)));
1948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
1949                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
1950                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
1952                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
1953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
1954                 {
1955                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1957                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
1958                         ndr->flags = _flags_save_DATA_BLOB;
1959                 }
1960         }
1961         if (ndr_flags & NDR_BUFFERS) {
1962                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1963         }
1964         return NDR_ERR_SUCCESS;
1965 }
1966
1967 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
1968 {
1969         if (ndr_flags & NDR_SCALARS) {
1970                 NDR_CHECK(ndr_pull_align(ndr, 4));
1971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
1973                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
1974                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
1976                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
1977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
1978                 {
1979                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1981                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
1982                         ndr->flags = _flags_save_DATA_BLOB;
1983                 }
1984         }
1985         if (ndr_flags & NDR_BUFFERS) {
1986                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1987         }
1988         return NDR_ERR_SUCCESS;
1989 }
1990
1991 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
1992 {
1993         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
1994         ndr->depth++;
1995         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(r, ndr->flags):r->__ndr_size);
1996         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);
1997         ndr_print_GUID(ndr, "guid", &r->guid);
1998         ndr_print_dom_sid28(ndr, "sid", &r->sid);
1999         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2000         ndr_print_string(ndr, "dn", r->dn);
2001         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2002         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2003         ndr->depth--;
2004 }
2005
2006 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, int flags)
2007 {
2008         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
2009 }
2010
2011 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2012 {
2013         if (ndr_flags & NDR_SCALARS) {
2014                 NDR_CHECK(ndr_push_align(ndr, 4));
2015                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2016                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2017         }
2018         if (ndr_flags & NDR_BUFFERS) {
2019                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2020         }
2021         return NDR_ERR_SUCCESS;
2022 }
2023
2024 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2025 {
2026         if (ndr_flags & NDR_SCALARS) {
2027                 NDR_CHECK(ndr_pull_align(ndr, 4));
2028                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2029                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2030         }
2031         if (ndr_flags & NDR_BUFFERS) {
2032                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2033         }
2034         return NDR_ERR_SUCCESS;
2035 }
2036
2037 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2038 {
2039         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2040         ndr->depth++;
2041         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2042         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2043         ndr->depth--;
2044 }
2045
2046 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2047 {
2048         uint32_t cntr_attributes_1;
2049         if (ndr_flags & NDR_SCALARS) {
2050                 NDR_CHECK(ndr_push_align(ndr, 4));
2051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2052                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2053         }
2054         if (ndr_flags & NDR_BUFFERS) {
2055                 if (r->attributes) {
2056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2057                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2058                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2059                         }
2060                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2061                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2062                         }
2063                 }
2064         }
2065         return NDR_ERR_SUCCESS;
2066 }
2067
2068 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2069 {
2070         uint32_t _ptr_attributes;
2071         uint32_t cntr_attributes_1;
2072         TALLOC_CTX *_mem_save_attributes_0;
2073         TALLOC_CTX *_mem_save_attributes_1;
2074         if (ndr_flags & NDR_SCALARS) {
2075                 NDR_CHECK(ndr_pull_align(ndr, 4));
2076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2077                 if (r->num_attributes < 0 || r->num_attributes > 1048576) {
2078                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2079                 }
2080                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2081                 if (_ptr_attributes) {
2082                         NDR_PULL_ALLOC(ndr, r->attributes);
2083                 } else {
2084                         r->attributes = NULL;
2085                 }
2086         }
2087         if (ndr_flags & NDR_BUFFERS) {
2088                 if (r->attributes) {
2089                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2090                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2091                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2092                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2093                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2094                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2095                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2096                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2097                         }
2098                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2099                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2100                         }
2101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2103                 }
2104                 if (r->attributes) {
2105                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2106                 }
2107         }
2108         return NDR_ERR_SUCCESS;
2109 }
2110
2111 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2112 {
2113         uint32_t cntr_attributes_1;
2114         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2115         ndr->depth++;
2116         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2117         ndr_print_ptr(ndr, "attributes", r->attributes);
2118         ndr->depth++;
2119         if (r->attributes) {
2120                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2121                 ndr->depth++;
2122                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2123                         char *idx_1=NULL;
2124                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2125                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2126                                 free(idx_1);
2127                         }
2128                 }
2129                 ndr->depth--;
2130         }
2131         ndr->depth--;
2132         ndr->depth--;
2133 }
2134
2135 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2136 {
2137         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2138         return NDR_ERR_SUCCESS;
2139 }
2140
2141 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2142 {
2143         uint32_t v;
2144         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2145         *r = v;
2146         return NDR_ERR_SUCCESS;
2147 }
2148
2149 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2150 {
2151         ndr_print_uint32(ndr, name, r);
2152         ndr->depth++;
2153         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2154         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2155         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2156         ndr->depth--;
2157 }
2158
2159 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2160 {
2161         if (ndr_flags & NDR_SCALARS) {
2162                 NDR_CHECK(ndr_push_align(ndr, 4));
2163                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2164                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2165                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2166         }
2167         if (ndr_flags & NDR_BUFFERS) {
2168                 if (r->identifier) {
2169                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2170                 }
2171                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2172         }
2173         return NDR_ERR_SUCCESS;
2174 }
2175
2176 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2177 {
2178         uint32_t _ptr_identifier;
2179         TALLOC_CTX *_mem_save_identifier_0;
2180         if (ndr_flags & NDR_SCALARS) {
2181                 NDR_CHECK(ndr_pull_align(ndr, 4));
2182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2183                 if (_ptr_identifier) {
2184                         NDR_PULL_ALLOC(ndr, r->identifier);
2185                 } else {
2186                         r->identifier = NULL;
2187                 }
2188                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2189                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2190         }
2191         if (ndr_flags & NDR_BUFFERS) {
2192                 if (r->identifier) {
2193                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2194                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2195                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2197                 }
2198                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2199         }
2200         return NDR_ERR_SUCCESS;
2201 }
2202
2203 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2204 {
2205         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2206         ndr->depth++;
2207         ndr_print_ptr(ndr, "identifier", r->identifier);
2208         ndr->depth++;
2209         if (r->identifier) {
2210                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2211         }
2212         ndr->depth--;
2213         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2214         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2215         ndr->depth--;
2216 }
2217
2218 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2219 {
2220         if (ndr_flags & NDR_SCALARS) {
2221                 NDR_CHECK(ndr_push_align(ndr, 8));
2222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2223                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2224                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2225                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2226         }
2227         if (ndr_flags & NDR_BUFFERS) {
2228         }
2229         return NDR_ERR_SUCCESS;
2230 }
2231
2232 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2233 {
2234         if (ndr_flags & NDR_SCALARS) {
2235                 NDR_CHECK(ndr_pull_align(ndr, 8));
2236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2237                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2238                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2239                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2240         }
2241         if (ndr_flags & NDR_BUFFERS) {
2242         }
2243         return NDR_ERR_SUCCESS;
2244 }
2245
2246 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2247 {
2248         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2249         ndr->depth++;
2250         ndr_print_uint32(ndr, "version", r->version);
2251         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2252         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2253         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2254         ndr->depth--;
2255 }
2256
2257 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2258 {
2259         uint32_t cntr_meta_data_0;
2260         if (ndr_flags & NDR_SCALARS) {
2261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2262                 NDR_CHECK(ndr_push_align(ndr, 8));
2263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2264                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2265                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2266                 }
2267         }
2268         if (ndr_flags & NDR_BUFFERS) {
2269         }
2270         return NDR_ERR_SUCCESS;
2271 }
2272
2273 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2274 {
2275         uint32_t cntr_meta_data_0;
2276         TALLOC_CTX *_mem_save_meta_data_0;
2277         if (ndr_flags & NDR_SCALARS) {
2278                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2279                 NDR_CHECK(ndr_pull_align(ndr, 8));
2280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2281                 if (r->count < 0 || r->count > 1048576) {
2282                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2283                 }
2284                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2285                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2286                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2287                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2288                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2289                 }
2290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2291                 if (r->meta_data) {
2292                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2293                 }
2294         }
2295         if (ndr_flags & NDR_BUFFERS) {
2296         }
2297         return NDR_ERR_SUCCESS;
2298 }
2299
2300 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2301 {
2302         uint32_t cntr_meta_data_0;
2303         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2304         ndr->depth++;
2305         ndr_print_uint32(ndr, "count", r->count);
2306         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2307         ndr->depth++;
2308         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2309                 char *idx_0=NULL;
2310                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2311                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2312                         free(idx_0);
2313                 }
2314         }
2315         ndr->depth--;
2316         ndr->depth--;
2317 }
2318
2319 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2320 {
2321         if (ndr_flags & NDR_SCALARS) {
2322                 NDR_CHECK(ndr_push_align(ndr, 4));
2323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2324                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2328         }
2329         if (ndr_flags & NDR_BUFFERS) {
2330                 if (r->next_object) {
2331                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2332                 }
2333                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2334                 if (r->parent_object_guid) {
2335                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2336                 }
2337                 if (r->meta_data_ctr) {
2338                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2339                 }
2340         }
2341         return NDR_ERR_SUCCESS;
2342 }
2343
2344 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2345 {
2346         uint32_t _ptr_next_object;
2347         TALLOC_CTX *_mem_save_next_object_0;
2348         uint32_t _ptr_parent_object_guid;
2349         TALLOC_CTX *_mem_save_parent_object_guid_0;
2350         uint32_t _ptr_meta_data_ctr;
2351         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2352         if (ndr_flags & NDR_SCALARS) {
2353                 NDR_CHECK(ndr_pull_align(ndr, 4));
2354                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2355                 if (_ptr_next_object) {
2356                         NDR_PULL_ALLOC(ndr, r->next_object);
2357                 } else {
2358                         r->next_object = NULL;
2359                 }
2360                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2362                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2363                 if (_ptr_parent_object_guid) {
2364                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2365                 } else {
2366                         r->parent_object_guid = NULL;
2367                 }
2368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2369                 if (_ptr_meta_data_ctr) {
2370                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2371                 } else {
2372                         r->meta_data_ctr = NULL;
2373                 }
2374         }
2375         if (ndr_flags & NDR_BUFFERS) {
2376                 if (r->next_object) {
2377                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2378                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2379                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2380                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2381                 }
2382                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2383                 if (r->parent_object_guid) {
2384                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2385                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2386                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2388                 }
2389                 if (r->meta_data_ctr) {
2390                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2391                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2392                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2394                 }
2395         }
2396         return NDR_ERR_SUCCESS;
2397 }
2398
2399 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2400 {
2401         if (ndr_flags & NDR_SCALARS) {
2402                 NDR_CHECK(ndr_push_align(ndr, 8));
2403                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2404                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2406                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2407                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2408                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2409                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2410                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->flags) + 55));
2413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2415         }
2416         if (ndr_flags & NDR_BUFFERS) {
2417                 if (r->naming_context) {
2418                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2419                 }
2420                 if (r->uptodateness_vector) {
2421                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2422                 }
2423                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2424                 if (r->first_object) {
2425                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2426                 }
2427         }
2428         return NDR_ERR_SUCCESS;
2429 }
2430
2431 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2432 {
2433         uint32_t _ptr_naming_context;
2434         TALLOC_CTX *_mem_save_naming_context_0;
2435         uint32_t _ptr_uptodateness_vector;
2436         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2437         uint32_t _ptr_first_object;
2438         TALLOC_CTX *_mem_save_first_object_0;
2439         if (ndr_flags & NDR_SCALARS) {
2440                 NDR_CHECK(ndr_pull_align(ndr, 8));
2441                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2442                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2443                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2444                 if (_ptr_naming_context) {
2445                         NDR_PULL_ALLOC(ndr, r->naming_context);
2446                 } else {
2447                         r->naming_context = NULL;
2448                 }
2449                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2450                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2452                 if (_ptr_uptodateness_vector) {
2453                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2454                 } else {
2455                         r->uptodateness_vector = NULL;
2456                 }
2457                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2458                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2462                 if (_ptr_first_object) {
2463                         NDR_PULL_ALLOC(ndr, r->first_object);
2464                 } else {
2465                         r->first_object = NULL;
2466                 }
2467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2468         }
2469         if (ndr_flags & NDR_BUFFERS) {
2470                 if (r->naming_context) {
2471                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2472                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2473                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2475                 }
2476                 if (r->uptodateness_vector) {
2477                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2478                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2479                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2481                 }
2482                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2483                 if (r->first_object) {
2484                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2485                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2486                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2487                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2488                 }
2489         }
2490         return NDR_ERR_SUCCESS;
2491 }
2492
2493 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2494 {
2495         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2496         ndr->depth++;
2497         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2498         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2499         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2500         ndr->depth++;
2501         if (r->naming_context) {
2502                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2503         }
2504         ndr->depth--;
2505         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2506         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2507         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2508         ndr->depth++;
2509         if (r->uptodateness_vector) {
2510                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2511         }
2512         ndr->depth--;
2513         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2514         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2515         ndr_print_uint32(ndr, "object_count", r->object_count);
2516         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->flags) + 55:r->__ndr_size);
2517         ndr_print_ptr(ndr, "first_object", r->first_object);
2518         ndr->depth++;
2519         if (r->first_object) {
2520                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2521         }
2522         ndr->depth--;
2523         ndr_print_uint32(ndr, "more_data", r->more_data);
2524         ndr->depth--;
2525 }
2526
2527 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, int flags)
2528 {
2529         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1);
2530 }
2531
2532 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2533 {
2534         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2535         return NDR_ERR_SUCCESS;
2536 }
2537
2538 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2539 {
2540         uint32_t v;
2541         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2542         *r = v;
2543         return NDR_ERR_SUCCESS;
2544 }
2545
2546 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2547 {
2548         ndr_print_uint32(ndr, name, r);
2549         ndr->depth++;
2550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2551         ndr->depth--;
2552 }
2553
2554 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2555 {
2556         if (ndr_flags & NDR_SCALARS) {
2557                 NDR_CHECK(ndr_push_align(ndr, 8));
2558                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2559                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2560                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2561                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2562                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2563                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2564         }
2565         if (ndr_flags & NDR_BUFFERS) {
2566                 if (r->identifier) {
2567                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2568                 }
2569                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2570         }
2571         return NDR_ERR_SUCCESS;
2572 }
2573
2574 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2575 {
2576         uint32_t _ptr_identifier;
2577         TALLOC_CTX *_mem_save_identifier_0;
2578         if (ndr_flags & NDR_SCALARS) {
2579                 NDR_CHECK(ndr_pull_align(ndr, 8));
2580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2581                 if (_ptr_identifier) {
2582                         NDR_PULL_ALLOC(ndr, r->identifier);
2583                 } else {
2584                         r->identifier = NULL;
2585                 }
2586                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2587                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2588                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2589                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2590                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2591         }
2592         if (ndr_flags & NDR_BUFFERS) {
2593                 if (r->identifier) {
2594                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2595                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2596                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2597                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2598                 }
2599                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2600         }
2601         return NDR_ERR_SUCCESS;
2602 }
2603
2604 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2605 {
2606         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2607         ndr->depth++;
2608         ndr_print_ptr(ndr, "identifier", r->identifier);
2609         ndr->depth++;
2610         if (r->identifier) {
2611                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2612         }
2613         ndr->depth--;
2614         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2615         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2616         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2617         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2618         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2619         ndr->depth--;
2620 }
2621
2622 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2623 {
2624         uint32_t cntr_linked_attributes_1;
2625         if (ndr_flags & NDR_SCALARS) {
2626                 NDR_CHECK(ndr_push_align(ndr, 8));
2627                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2628                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2629                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2630                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2631                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2632                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2633                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2634                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->flags) + 55));
2637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2642                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2643                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2644         }
2645         if (ndr_flags & NDR_BUFFERS) {
2646                 if (r->naming_context) {
2647                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2648                 }
2649                 if (r->uptodateness_vector) {
2650                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2651                 }
2652                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2653                 if (r->first_object) {
2654                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2655                 }
2656                 if (r->linked_attributes) {
2657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2658                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2659                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2660                         }
2661                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2662                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2663                         }
2664                 }
2665         }
2666         return NDR_ERR_SUCCESS;
2667 }
2668
2669 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2670 {
2671         uint32_t _ptr_naming_context;
2672         TALLOC_CTX *_mem_save_naming_context_0;
2673         uint32_t _ptr_uptodateness_vector;
2674         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2675         uint32_t _ptr_first_object;
2676         TALLOC_CTX *_mem_save_first_object_0;
2677         uint32_t _ptr_linked_attributes;
2678         uint32_t cntr_linked_attributes_1;
2679         TALLOC_CTX *_mem_save_linked_attributes_0;
2680         TALLOC_CTX *_mem_save_linked_attributes_1;
2681         if (ndr_flags & NDR_SCALARS) {
2682                 NDR_CHECK(ndr_pull_align(ndr, 8));
2683                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2684                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2686                 if (_ptr_naming_context) {
2687                         NDR_PULL_ALLOC(ndr, r->naming_context);
2688                 } else {
2689                         r->naming_context = NULL;
2690                 }
2691                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2692                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2694                 if (_ptr_uptodateness_vector) {
2695                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2696                 } else {
2697                         r->uptodateness_vector = NULL;
2698                 }
2699                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2700                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2704                 if (_ptr_first_object) {
2705                         NDR_PULL_ALLOC(ndr, r->first_object);
2706                 } else {
2707                         r->first_object = NULL;
2708                 }
2709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
2711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
2712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
2713                 if (r->linked_attributes_count < 0 || r->linked_attributes_count > 1048576) {
2714                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2715                 }
2716                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
2717                 if (_ptr_linked_attributes) {
2718                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
2719                 } else {
2720                         r->linked_attributes = NULL;
2721                 }
2722                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
2723         }
2724         if (ndr_flags & NDR_BUFFERS) {
2725                 if (r->naming_context) {
2726                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2727                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2728                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2730                 }
2731                 if (r->uptodateness_vector) {
2732                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2733                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2734                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2736                 }
2737                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2738                 if (r->first_object) {
2739                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2740                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2741                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2742                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2743                 }
2744                 if (r->linked_attributes) {
2745                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2746                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2747                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
2748                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
2749                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2750                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2751                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2752                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2753                         }
2754                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2755                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2756                         }
2757                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
2758                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
2759                 }
2760                 if (r->linked_attributes) {
2761                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
2762                 }
2763         }
2764         return NDR_ERR_SUCCESS;
2765 }
2766
2767 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
2768 {
2769         uint32_t cntr_linked_attributes_1;
2770         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
2771         ndr->depth++;
2772         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2773         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2774         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2775         ndr->depth++;
2776         if (r->naming_context) {
2777                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2778         }
2779         ndr->depth--;
2780         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2781         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2782         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2783         ndr->depth++;
2784         if (r->uptodateness_vector) {
2785                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2786         }
2787         ndr->depth--;
2788         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2789         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2790         ndr_print_uint32(ndr, "object_count", r->object_count);
2791         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->flags) + 55:r->__ndr_size);
2792         ndr_print_ptr(ndr, "first_object", r->first_object);
2793         ndr->depth++;
2794         if (r->first_object) {
2795                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2796         }
2797         ndr->depth--;
2798         ndr_print_uint32(ndr, "more_data", r->more_data);
2799         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
2800         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
2801         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
2802         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
2803         ndr->depth++;
2804         if (r->linked_attributes) {
2805                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
2806                 ndr->depth++;
2807                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
2808                         char *idx_1=NULL;
2809                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
2810                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
2811                                 free(idx_1);
2812                         }
2813                 }
2814                 ndr->depth--;
2815         }
2816         ndr->depth--;
2817         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
2818         ndr->depth--;
2819 }
2820
2821 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, int flags)
2822 {
2823         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6);
2824 }
2825
2826 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
2827 {
2828         if (ndr_flags & NDR_SCALARS) {
2829                 NDR_CHECK(ndr_push_align(ndr, 4));
2830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->decompressed_length));
2831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->compressed_length));
2832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
2833         }
2834         if (ndr_flags & NDR_BUFFERS) {
2835                 if (r->ctr1) {
2836                         {
2837                                 struct ndr_push *_ndr_ctr1;
2838                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 4, r->compressed_length));
2839                                 {
2840                                         struct ndr_push *_ndr_ctr1_compressed;
2841                                         NDR_CHECK(ndr_push_compression_start(_ndr_ctr1, &_ndr_ctr1_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2842                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1_compressed, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
2843                                         NDR_CHECK(ndr_push_compression_end(_ndr_ctr1, _ndr_ctr1_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2844                                 }
2845                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 4, r->compressed_length));
2846                         }
2847                 }
2848         }
2849         return NDR_ERR_SUCCESS;
2850 }
2851
2852 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
2853 {
2854         uint32_t _ptr_ctr1;
2855         TALLOC_CTX *_mem_save_ctr1_0;
2856         if (ndr_flags & NDR_SCALARS) {
2857                 NDR_CHECK(ndr_pull_align(ndr, 4));
2858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
2859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
2860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
2861                 if (_ptr_ctr1) {
2862                         NDR_PULL_ALLOC(ndr, r->ctr1);
2863                 } else {
2864                         r->ctr1 = NULL;
2865                 }
2866         }
2867         if (ndr_flags & NDR_BUFFERS) {
2868                 if (r->ctr1) {
2869                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
2870                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
2871                         {
2872                                 struct ndr_pull *_ndr_ctr1;
2873                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 4, r->compressed_length));
2874                                 {
2875                                         struct ndr_pull *_ndr_ctr1_compressed;
2876                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ctr1, &_ndr_ctr1_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2877                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1_compressed, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
2878                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ctr1, _ndr_ctr1_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2879                                 }
2880                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 4, r->compressed_length));
2881                         }
2882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
2883                 }
2884         }
2885         return NDR_ERR_SUCCESS;
2886 }
2887
2888 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
2889 {
2890         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
2891         ndr->depth++;
2892         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
2893         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
2894         ndr_print_ptr(ndr, "ctr1", r->ctr1);
2895         ndr->depth++;
2896         if (r->ctr1) {
2897                 ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", r->ctr1);
2898         }
2899         ndr->depth--;
2900         ndr->depth--;
2901 }
2902
2903 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
2904 {
2905         if (ndr_flags & NDR_SCALARS) {
2906                 NDR_CHECK(ndr_push_align(ndr, 4));
2907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->decompressed_length));
2908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->compressed_length));
2909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr6));
2910         }
2911         if (ndr_flags & NDR_BUFFERS) {
2912                 if (r->ctr6) {
2913                         {
2914                                 struct ndr_push *_ndr_ctr6;
2915                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 4, r->compressed_length));
2916                                 {
2917                                         struct ndr_push *_ndr_ctr6_compressed;
2918                                         NDR_CHECK(ndr_push_compression_start(_ndr_ctr6, &_ndr_ctr6_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2919                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6_compressed, NDR_SCALARS|NDR_BUFFERS, r->ctr6));
2920                                         NDR_CHECK(ndr_push_compression_end(_ndr_ctr6, _ndr_ctr6_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2921                                 }
2922                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 4, r->compressed_length));
2923                         }
2924                 }
2925         }
2926         return NDR_ERR_SUCCESS;
2927 }
2928
2929 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
2930 {
2931         uint32_t _ptr_ctr6;
2932         TALLOC_CTX *_mem_save_ctr6_0;
2933         if (ndr_flags & NDR_SCALARS) {
2934                 NDR_CHECK(ndr_pull_align(ndr, 4));
2935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
2936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
2937                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr6));
2938                 if (_ptr_ctr6) {
2939                         NDR_PULL_ALLOC(ndr, r->ctr6);
2940                 } else {
2941                         r->ctr6 = NULL;
2942                 }
2943         }
2944         if (ndr_flags & NDR_BUFFERS) {
2945                 if (r->ctr6) {
2946                         _mem_save_ctr6_0 = NDR_PULL_GET_MEM_CTX(ndr);
2947                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr6, 0);
2948                         {
2949                                 struct ndr_pull *_ndr_ctr6;
2950                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 4, r->compressed_length));
2951                                 {
2952                                         struct ndr_pull *_ndr_ctr6_compressed;
2953                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ctr6, &_ndr_ctr6_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2954                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6_compressed, NDR_SCALARS|NDR_BUFFERS, r->ctr6));
2955                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ctr6, _ndr_ctr6_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2956                                 }
2957                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 4, r->compressed_length));
2958                         }
2959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr6_0, 0);
2960                 }
2961         }
2962         return NDR_ERR_SUCCESS;
2963 }
2964
2965 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
2966 {
2967         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
2968         ndr->depth++;
2969         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
2970         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
2971         ndr_print_ptr(ndr, "ctr6", r->ctr6);
2972         ndr->depth++;
2973         if (r->ctr6) {
2974                 ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", r->ctr6);
2975         }
2976         ndr->depth--;
2977         ndr->depth--;
2978 }
2979
2980 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
2981 {
2982         if (ndr_flags & NDR_SCALARS) {
2983                 NDR_CHECK(ndr_push_align(ndr, 4));
2984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->decompressed_length));
2985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->compressed_length));
2986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
2987         }
2988         if (ndr_flags & NDR_BUFFERS) {
2989                 if (r->ctr1) {
2990                         {
2991                                 struct ndr_push *_ndr_ctr1;
2992                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 4, r->compressed_length));
2993                                 {
2994                                         struct ndr_push *_ndr_ctr1_compressed;
2995                                         NDR_CHECK(ndr_push_compression_start(_ndr_ctr1, &_ndr_ctr1_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
2996                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1_compressed, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
2997                                         NDR_CHECK(ndr_push_compression_end(_ndr_ctr1, _ndr_ctr1_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
2998                                 }
2999                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 4, r->compressed_length));
3000                         }
3001                 }
3002         }
3003         return NDR_ERR_SUCCESS;
3004 }
3005
3006 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3007 {
3008         uint32_t _ptr_ctr1;
3009         TALLOC_CTX *_mem_save_ctr1_0;
3010         if (ndr_flags & NDR_SCALARS) {
3011                 NDR_CHECK(ndr_pull_align(ndr, 4));
3012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3014                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
3015                 if (_ptr_ctr1) {
3016                         NDR_PULL_ALLOC(ndr, r->ctr1);
3017                 } else {
3018                         r->ctr1 = NULL;
3019                 }
3020         }
3021         if (ndr_flags & NDR_BUFFERS) {
3022                 if (r->ctr1) {
3023                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3024                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
3025                         {
3026                                 struct ndr_pull *_ndr_ctr1;
3027                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 4, r->compressed_length));
3028                                 {
3029                                         struct ndr_pull *_ndr_ctr1_compressed;
3030                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ctr1, &_ndr_ctr1_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3031                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1_compressed, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
3032                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ctr1, _ndr_ctr1_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3033                                 }
3034                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 4, r->compressed_length));
3035                         }
3036                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
3037                 }
3038         }
3039         return NDR_ERR_SUCCESS;
3040 }
3041
3042 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3043 {
3044         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3045         ndr->depth++;
3046         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3047         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3048         ndr_print_ptr(ndr, "ctr1", r->ctr1);
3049         ndr->depth++;
3050         if (r->ctr1) {
3051                 ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", r->ctr1);
3052         }
3053         ndr->depth--;
3054         ndr->depth--;
3055 }
3056
3057 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3058 {
3059         if (ndr_flags & NDR_SCALARS) {
3060                 NDR_CHECK(ndr_push_align(ndr, 4));
3061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->decompressed_length));
3062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->compressed_length));
3063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr6));
3064         }
3065         if (ndr_flags & NDR_BUFFERS) {
3066                 if (r->ctr6) {
3067                         {
3068                                 struct ndr_push *_ndr_ctr6;
3069                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 4, r->compressed_length));
3070                                 {
3071                                         struct ndr_push *_ndr_ctr6_compressed;
3072                                         NDR_CHECK(ndr_push_compression_start(_ndr_ctr6, &_ndr_ctr6_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3073                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6_compressed, NDR_SCALARS|NDR_BUFFERS, r->ctr6));
3074                                         NDR_CHECK(ndr_push_compression_end(_ndr_ctr6, _ndr_ctr6_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3075                                 }
3076                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 4, r->compressed_length));
3077                         }
3078                 }
3079         }
3080         return NDR_ERR_SUCCESS;
3081 }
3082
3083 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3084 {
3085         uint32_t _ptr_ctr6;
3086         TALLOC_CTX *_mem_save_ctr6_0;
3087         if (ndr_flags & NDR_SCALARS) {
3088                 NDR_CHECK(ndr_pull_align(ndr, 4));
3089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr6));
3092                 if (_ptr_ctr6) {
3093                         NDR_PULL_ALLOC(ndr, r->ctr6);
3094                 } else {
3095                         r->ctr6 = NULL;
3096                 }
3097         }
3098         if (ndr_flags & NDR_BUFFERS) {
3099                 if (r->ctr6) {
3100                         _mem_save_ctr6_0 = NDR_PULL_GET_MEM_CTX(ndr);
3101                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr6, 0);
3102                         {
3103                                 struct ndr_pull *_ndr_ctr6;
3104                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 4, r->compressed_length));
3105                                 {
3106                                         struct ndr_pull *_ndr_ctr6_compressed;
3107                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ctr6, &_ndr_ctr6_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3108                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6_compressed, NDR_SCALARS|NDR_BUFFERS, r->ctr6));
3109                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ctr6, _ndr_ctr6_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3110                                 }
3111                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 4, r->compressed_length));
3112                         }
3113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr6_0, 0);
3114                 }
3115         }
3116         return NDR_ERR_SUCCESS;
3117 }
3118
3119 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3120 {
3121         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3122         ndr->depth++;
3123         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3124         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3125         ndr_print_ptr(ndr, "ctr6", r->ctr6);
3126         ndr->depth++;
3127         if (r->ctr6) {
3128                 ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", r->ctr6);
3129         }
3130         ndr->depth--;
3131         ndr->depth--;
3132 }
3133
3134 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3135 {
3136         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
3137         return NDR_ERR_SUCCESS;
3138 }
3139
3140 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3141 {
3142         uint16_t v;
3143         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
3144         *r = v;
3145         return NDR_ERR_SUCCESS;
3146 }
3147
3148 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3149 {
3150         const char *val = NULL;
3151
3152         switch (r) {
3153                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3154                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3155         }
3156         ndr_print_enum(ndr, name, "ENUM", val, r);
3157 }
3158
3159 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3160 {
3161         {
3162                 uint32_t _flags_save_UNION = ndr->flags;
3163                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3164                 if (ndr_flags & NDR_SCALARS) {
3165                         int level = ndr_push_get_switch_value(ndr, r);
3166                         switch (level) {
3167                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3168                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3169                                 break; }
3170
3171                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3172                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3173                                 break; }
3174
3175                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3176                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3177                                 break; }
3178
3179                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3180                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3181                                 break; }
3182
3183                                 default:
3184                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3185                         }
3186                 }
3187                 if (ndr_flags & NDR_BUFFERS) {
3188                         int level = ndr_push_get_switch_value(ndr, r);
3189                         switch (level) {
3190                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3191                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3192                                 break;
3193
3194                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3195                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3196                                 break;
3197
3198                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3199                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3200                                 break;
3201
3202                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3203                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3204                                 break;
3205
3206                                 default:
3207                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3208                         }
3209                 }
3210                 ndr->flags = _flags_save_UNION;
3211         }
3212         return NDR_ERR_SUCCESS;
3213 }
3214
3215 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3216 {
3217         int level;
3218         {
3219                 uint32_t _flags_save_UNION = ndr->flags;
3220                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3221                 level = ndr_pull_get_switch_value(ndr, r);
3222                 if (ndr_flags & NDR_SCALARS) {
3223                         switch (level) {
3224                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3225                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3226                                 break; }
3227
3228                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3229                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3230                                 break; }
3231
3232                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3233                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3234                                 break; }
3235
3236                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3237                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3238                                 break; }
3239
3240                                 default:
3241                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3242                         }
3243                 }
3244                 if (ndr_flags & NDR_BUFFERS) {
3245                         switch (level) {
3246                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3247                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3248                                 break;
3249
3250                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3251                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3252                                 break;
3253
3254                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3255                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3256                                 break;
3257
3258                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3259                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3260                                 break;
3261
3262                                 default:
3263                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3264                         }
3265                 }
3266                 ndr->flags = _flags_save_UNION;
3267         }
3268         return NDR_ERR_SUCCESS;
3269 }
3270
3271 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3272 {
3273         int level;
3274         {
3275                 uint32_t _flags_save_UNION = ndr->flags;
3276                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3277                 level = ndr_print_get_switch_value(ndr, r);
3278                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3279                 switch (level) {
3280                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3281                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3282                         break;
3283
3284                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3285                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3286                         break;
3287
3288                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3289                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3290                         break;
3291
3292                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3293                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3294                         break;
3295
3296                         default:
3297                                 ndr_print_bad_level(ndr, name, level);
3298                 }
3299                 ndr->flags = _flags_save_UNION;
3300         }
3301 }
3302
3303 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3304 {
3305         if (ndr_flags & NDR_SCALARS) {
3306                 NDR_CHECK(ndr_push_align(ndr, 4));
3307                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, 1 | (DRSUAPI_COMPRESSION_TYPE_MSZIP << 16)));
3308                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3309         }
3310         if (ndr_flags & NDR_BUFFERS) {
3311                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3312         }
3313         return NDR_ERR_SUCCESS;
3314 }
3315
3316 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3317 {
3318         if (ndr_flags & NDR_SCALARS) {
3319                 NDR_CHECK(ndr_pull_align(ndr, 4));
3320                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, 1 | (DRSUAPI_COMPRESSION_TYPE_MSZIP << 16)));
3321                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3322         }
3323         if (ndr_flags & NDR_BUFFERS) {
3324                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3325         }
3326         return NDR_ERR_SUCCESS;
3327 }
3328
3329 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3330 {
3331         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3332         ndr->depth++;
3333         ndr_print_set_switch_value(ndr, &r->ctr, 1 | (DRSUAPI_COMPRESSION_TYPE_MSZIP << 16));
3334         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3335         ndr->depth--;
3336 }
3337
3338 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3339 {
3340         if (ndr_flags & NDR_SCALARS) {
3341                 NDR_CHECK(ndr_push_align(ndr, 4));
3342                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3343                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3344                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3345                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3346         }
3347         if (ndr_flags & NDR_BUFFERS) {
3348                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3349         }
3350         return NDR_ERR_SUCCESS;
3351 }
3352
3353 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3354 {
3355         if (ndr_flags & NDR_SCALARS) {
3356                 NDR_CHECK(ndr_pull_align(ndr, 4));
3357                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3358                 if (r->level < 0 || r->level > 6) {
3359                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3360                 }
3361                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3362                 if (r->type < 2 || r->type > 3) {
3363                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3364                 }
3365                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3366                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3367         }
3368         if (ndr_flags & NDR_BUFFERS) {
3369                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3370         }
3371         return NDR_ERR_SUCCESS;
3372 }
3373
3374 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3375 {
3376         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3377         ndr->depth++;
3378         ndr_print_int32(ndr, "level", r->level);
3379         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3380         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3381         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3382         ndr->depth--;
3383 }
3384
3385 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3386 {
3387         if (ndr_flags & NDR_SCALARS) {
3388                 int level = ndr_push_get_switch_value(ndr, r);
3389                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3390                 switch (level) {
3391                         case 1: {
3392                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3393                         break; }
3394
3395                         case 2: {
3396                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3397                         break; }
3398
3399                         case 6: {
3400                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3401                         break; }
3402
3403                         case 7: {
3404                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3405                         break; }
3406
3407                         default:
3408                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3409                 }
3410         }
3411         if (ndr_flags & NDR_BUFFERS) {
3412                 int level = ndr_push_get_switch_value(ndr, r);
3413                 switch (level) {
3414                         case 1:
3415                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3416                         break;
3417
3418                         case 2:
3419                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3420                         break;
3421
3422                         case 6:
3423                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3424                         break;
3425
3426                         case 7:
3427                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3428                         break;
3429
3430                         default:
3431                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3432                 }
3433         }
3434         return NDR_ERR_SUCCESS;
3435 }
3436
3437 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3438 {
3439         int level;
3440         int32_t _level;
3441         level = ndr_pull_get_switch_value(ndr, r);
3442         if (ndr_flags & NDR_SCALARS) {
3443                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3444                 if (_level != level) {
3445                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3446                 }
3447                 switch (level) {
3448                         case 1: {
3449                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3450                         break; }
3451
3452                         case 2: {
3453                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3454                         break; }
3455
3456                         case 6: {
3457                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3458                         break; }
3459
3460                         case 7: {
3461                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3462                         break; }
3463
3464                         default:
3465                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3466                 }
3467         }
3468         if (ndr_flags & NDR_BUFFERS) {
3469                 switch (level) {
3470                         case 1:
3471                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3472                         break;
3473
3474                         case 2:
3475                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3476                         break;
3477
3478                         case 6:
3479                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3480                         break;
3481
3482                         case 7:
3483                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3484                         break;
3485
3486                         default:
3487                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3488                 }
3489         }
3490         return NDR_ERR_SUCCESS;
3491 }
3492
3493 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3494 {
3495         int level;
3496         level = ndr_print_get_switch_value(ndr, r);
3497         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3498         switch (level) {
3499                 case 1:
3500                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3501                 break;
3502
3503                 case 2:
3504                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3505                 break;
3506
3507                 case 6:
3508                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3509                 break;
3510
3511                 case 7:
3512                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3513                 break;
3514
3515                 default:
3516                         ndr_print_bad_level(ndr, name, level);
3517         }
3518 }
3519
3520 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3521 {
3522         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3523         return NDR_ERR_SUCCESS;
3524 }
3525
3526 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3527 {
3528         uint32_t v;
3529         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3530         *r = v;
3531         return NDR_ERR_SUCCESS;
3532 }
3533
3534 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3535 {
3536         ndr_print_uint32(ndr, name, r);
3537         ndr->depth++;
3538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION, r);
3539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE", DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE, r);
3540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE, r);
3541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE, r);
3542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_0x00000010", DRSUAPI_DS_REPLICA_UPDATE_0x00000010, r);
3543         ndr->depth--;
3544 }
3545
3546 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3547 {
3548         if (ndr_flags & NDR_SCALARS) {
3549                 NDR_CHECK(ndr_push_align(ndr, 4));
3550                 if (r->naming_context == NULL) {
3551                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3552                 }
3553                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3554                 if (r->dest_dsa_dns_name == NULL) {
3555                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3556                 }
3557                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3558                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3559                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
3560         }
3561         if (ndr_flags & NDR_BUFFERS) {
3562                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3566                 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));
3567         }
3568         return NDR_ERR_SUCCESS;
3569 }
3570
3571 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3572 {
3573         uint32_t _ptr_naming_context;
3574         TALLOC_CTX *_mem_save_naming_context_0;
3575         uint32_t _ptr_dest_dsa_dns_name;
3576         if (ndr_flags & NDR_SCALARS) {
3577                 NDR_CHECK(ndr_pull_align(ndr, 4));
3578                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3579                 if (_ptr_naming_context) {
3580                         NDR_PULL_ALLOC(ndr, r->naming_context);
3581                 } else {
3582                         r->naming_context = NULL;
3583                 }
3584                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3585                 if (_ptr_dest_dsa_dns_name) {
3586                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3587                 } else {
3588                         r->dest_dsa_dns_name = NULL;
3589                 }
3590                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3591                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
3592         }
3593         if (ndr_flags & NDR_BUFFERS) {
3594                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3595                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3596                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3597                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3598                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3599                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3600                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3601                         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));
3602                 }
3603                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3604                 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));
3605         }
3606         return NDR_ERR_SUCCESS;
3607 }
3608
3609 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3610 {
3611         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3612         ndr->depth++;
3613         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3614         ndr->depth++;
3615         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3616         ndr->depth--;
3617         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3618         ndr->depth++;
3619         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3620         ndr->depth--;
3621         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3622         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "options", r->options);
3623         ndr->depth--;
3624 }
3625
3626 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3627 {
3628         if (ndr_flags & NDR_SCALARS) {
3629                 int level = ndr_push_get_switch_value(ndr, r);
3630                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3631                 switch (level) {
3632                         case 1: {
3633                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3634                         break; }
3635
3636                         default:
3637                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3638                 }
3639         }
3640         if (ndr_flags & NDR_BUFFERS) {
3641                 int level = ndr_push_get_switch_value(ndr, r);
3642                 switch (level) {
3643                         case 1:
3644                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3645                         break;
3646
3647                         default:
3648                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3649                 }
3650         }
3651         return NDR_ERR_SUCCESS;
3652 }
3653
3654 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3655 {
3656         int level;
3657         int32_t _level;
3658         level = ndr_pull_get_switch_value(ndr, r);
3659         if (ndr_flags & NDR_SCALARS) {
3660                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3661                 if (_level != level) {
3662                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3663                 }
3664                 switch (level) {
3665                         case 1: {
3666                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3667                         break; }
3668
3669                         default:
3670                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3671                 }
3672         }
3673         if (ndr_flags & NDR_BUFFERS) {
3674                 switch (level) {
3675                         case 1:
3676                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3677                         break;
3678
3679                         default:
3680                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3681                 }
3682         }
3683         return NDR_ERR_SUCCESS;
3684 }
3685
3686 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3687 {
3688         int level;
3689         level = ndr_print_get_switch_value(ndr, r);
3690         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3691         switch (level) {
3692                 case 1:
3693                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3694                 break;
3695
3696                 default:
3697                         ndr_print_bad_level(ndr, name, level);
3698         }
3699 }
3700
3701 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3702 {
3703         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3704         return NDR_ERR_SUCCESS;
3705 }
3706
3707 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3708 {
3709         uint32_t v;
3710         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3711         *r = v;
3712         return NDR_ERR_SUCCESS;
3713 }
3714
3715 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3716 {
3717         ndr_print_uint32(ndr, name, r);
3718         ndr->depth++;
3719         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
3720         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
3721         ndr->depth--;
3722 }
3723
3724 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3725 {
3726         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3727         return NDR_ERR_SUCCESS;
3728 }
3729
3730 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3731 {
3732         uint32_t v;
3733         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3734         *r = v;
3735         return NDR_ERR_SUCCESS;
3736 }
3737
3738 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3739 {
3740         ndr_print_uint32(ndr, name, r);
3741         ndr->depth++;
3742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION, r);
3743         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_DELETE_WRITEABLE", DRSUAPI_DS_REPLICA_DELETE_WRITEABLE, r);
3744         ndr->depth--;
3745 }
3746
3747 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3748 {
3749         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3750         return NDR_ERR_SUCCESS;
3751 }
3752
3753 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModifyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3754 {
3755         uint32_t v;
3756         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3757         *r = v;
3758         return NDR_ERR_SUCCESS;
3759 }
3760
3761 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3762 {
3763         ndr_print_uint32(ndr, name, r);
3764         ndr->depth++;
3765         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION, r);
3766         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE", DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE, r);
3767         ndr->depth--;
3768 }
3769
3770 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
3771 {
3772         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3773         return NDR_ERR_SUCCESS;
3774 }
3775
3776 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
3777 {
3778         uint32_t v;
3779         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3780         *r = v;
3781         return NDR_ERR_SUCCESS;
3782 }
3783
3784 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
3785 {
3786         const char *val = NULL;
3787
3788         switch (r) {
3789                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
3790                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
3791                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
3792                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
3793                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
3794                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
3795                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
3796         }
3797         ndr_print_enum(ndr, name, "ENUM", val, r);
3798 }
3799
3800 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
3801 {
3802         uint32_t cntr_info_array_1;
3803         uint32_t cntr_group_attrs_1;
3804         uint32_t cntr_sids_1;
3805         if (ndr_flags & NDR_SCALARS) {
3806                 NDR_CHECK(ndr_push_align(ndr, 4));
3807                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
3808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
3809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
3810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
3811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
3812                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
3813         }
3814         if (ndr_flags & NDR_BUFFERS) {
3815                 if (r->info_array) {
3816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
3817                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
3818                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
3819                         }
3820                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
3821                                 if (r->info_array[cntr_info_array_1]) {
3822                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
3823                                 }
3824                         }
3825                 }
3826                 if (r->group_attrs) {
3827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
3828                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
3829                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
3830                         }
3831                 }
3832                 if (r->sids) {
3833                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
3834                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
3835                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
3836                         }
3837                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
3838                                 if (r->sids[cntr_sids_1]) {
3839                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
3840                                 }
3841                         }
3842                 }
3843         }
3844         return NDR_ERR_SUCCESS;
3845 }
3846
3847 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
3848 {
3849         uint32_t _ptr_info_array;
3850         uint32_t cntr_info_array_1;
3851         TALLOC_CTX *_mem_save_info_array_0;
3852         TALLOC_CTX *_mem_save_info_array_1;
3853         TALLOC_CTX *_mem_save_info_array_2;
3854         uint32_t _ptr_group_attrs;
3855         uint32_t cntr_group_attrs_1;
3856         TALLOC_CTX *_mem_save_group_attrs_0;
3857         TALLOC_CTX *_mem_save_group_attrs_1;
3858         uint32_t _ptr_sids;
3859         uint32_t cntr_sids_1;
3860         TALLOC_CTX *_mem_save_sids_0;
3861         TALLOC_CTX *_mem_save_sids_1;
3862         TALLOC_CTX *_mem_save_sids_2;
3863         if (ndr_flags & NDR_SCALARS) {
3864                 NDR_CHECK(ndr_pull_align(ndr, 4));
3865                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
3866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
3867                 if (r->num_memberships < 0 || r->num_memberships > 10000) {
3868                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3869                 }
3870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
3871                 if (r->num_sids < 0 || r->num_sids > 10000) {
3872                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3873                 }
3874                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
3875                 if (_ptr_info_array) {
3876                         NDR_PULL_ALLOC(ndr, r->info_array);
3877                 } else {
3878                         r->info_array = NULL;
3879                 }
3880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
3881                 if (_ptr_group_attrs) {
3882                         NDR_PULL_ALLOC(ndr, r->group_attrs);
3883                 } else {
3884                         r->group_attrs = NULL;
3885                 }
3886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
3887                 if (_ptr_sids) {
3888                         NDR_PULL_ALLOC(ndr, r->sids);
3889                 } else {
3890                         r->sids = NULL;
3891                 }
3892         }
3893         if (ndr_flags & NDR_BUFFERS) {
3894                 if (r->info_array) {
3895                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3896                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
3897                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
3898                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
3899                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3900                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
3901                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
3902                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
3903                                 if (_ptr_info_array) {
3904                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
3905                                 } else {
3906                                         r->info_array[cntr_info_array_1] = NULL;
3907                                 }
3908                         }
3909                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
3910                                 if (r->info_array[cntr_info_array_1]) {
3911                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
3912                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
3913                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
3914                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
3915                                 }
3916                         }
3917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
3918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
3919                 }
3920                 if (r->group_attrs) {
3921                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
3922                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
3923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
3924                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
3925                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
3926                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
3927                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
3928                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
3929                         }
3930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
3931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
3932                 }
3933                 if (r->sids) {
3934                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3935                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3936                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
3937                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
3938                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3939                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3940                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
3941                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
3942                                 if (_ptr_sids) {
3943                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
3944                                 } else {
3945                                         r->sids[cntr_sids_1] = NULL;
3946                                 }
3947                         }
3948                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
3949                                 if (r->sids[cntr_sids_1]) {
3950                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
3951                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
3952                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
3953                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
3954                                 }
3955                         }
3956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
3957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
3958                 }
3959                 if (r->info_array) {
3960                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
3961                 }
3962                 if (r->group_attrs) {
3963                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
3964                 }
3965                 if (r->sids) {
3966                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
3967                 }
3968         }
3969         return NDR_ERR_SUCCESS;
3970 }
3971
3972 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
3973 {
3974         uint32_t cntr_info_array_1;
3975         uint32_t cntr_group_attrs_1;
3976         uint32_t cntr_sids_1;
3977         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
3978         ndr->depth++;
3979         ndr_print_NTSTATUS(ndr, "status", r->status);
3980         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
3981         ndr_print_uint32(ndr, "num_sids", r->num_sids);
3982         ndr_print_ptr(ndr, "info_array", r->info_array);
3983         ndr->depth++;
3984         if (r->info_array) {
3985                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
3986                 ndr->depth++;
3987                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
3988                         char *idx_1=NULL;
3989                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
3990                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
3991                                 ndr->depth++;
3992                                 if (r->info_array[cntr_info_array_1]) {
3993                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
3994                                 }
3995                                 ndr->depth--;
3996                                 free(idx_1);
3997                         }
3998                 }
3999                 ndr->depth--;
4000         }
4001         ndr->depth--;
4002         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4003         ndr->depth++;
4004         if (r->group_attrs) {
4005                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4006                 ndr->depth++;
4007                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4008                         char *idx_1=NULL;
4009                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4010                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4011                                 free(idx_1);
4012                         }
4013                 }
4014                 ndr->depth--;
4015         }
4016         ndr->depth--;
4017         ndr_print_ptr(ndr, "sids", r->sids);
4018         ndr->depth++;
4019         if (r->sids) {
4020                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4021                 ndr->depth++;
4022                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4023                         char *idx_1=NULL;
4024                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4025                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4026                                 ndr->depth++;
4027                                 if (r->sids[cntr_sids_1]) {
4028                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4029                                 }
4030                                 ndr->depth--;
4031                                 free(idx_1);
4032                         }
4033                 }
4034                 ndr->depth--;
4035         }
4036         ndr->depth--;
4037         ndr->depth--;
4038 }
4039
4040 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4041 {
4042         if (ndr_flags & NDR_SCALARS) {
4043                 int level = ndr_push_get_switch_value(ndr, r);
4044                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4045                 switch (level) {
4046                         case 1: {
4047                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4048                         break; }
4049
4050                         default:
4051                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4052                 }
4053         }
4054         if (ndr_flags & NDR_BUFFERS) {
4055                 int level = ndr_push_get_switch_value(ndr, r);
4056                 switch (level) {
4057                         case 1:
4058                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4059                         break;
4060
4061                         default:
4062                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4063                 }
4064         }
4065         return NDR_ERR_SUCCESS;
4066 }
4067
4068 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4069 {
4070         int level;
4071         int32_t _level;
4072         level = ndr_pull_get_switch_value(ndr, r);
4073         if (ndr_flags & NDR_SCALARS) {
4074                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4075                 if (_level != level) {
4076                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4077                 }
4078                 switch (level) {
4079                         case 1: {
4080                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4081                         break; }
4082
4083                         default:
4084                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4085                 }
4086         }
4087         if (ndr_flags & NDR_BUFFERS) {
4088                 switch (level) {
4089                         case 1:
4090                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4091                         break;
4092
4093                         default:
4094                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4095                 }
4096         }
4097         return NDR_ERR_SUCCESS;
4098 }
4099
4100 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
4101 {
4102         int level;
4103         level = ndr_print_get_switch_value(ndr, r);
4104         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
4105         switch (level) {
4106                 case 1:
4107                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
4108                 break;
4109
4110                 default:
4111                         ndr_print_bad_level(ndr, name, level);
4112         }
4113 }
4114
4115 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
4116 {
4117         uint32_t cntr_info_array_1;
4118         if (ndr_flags & NDR_SCALARS) {
4119                 NDR_CHECK(ndr_push_align(ndr, 4));
4120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4123                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
4124                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
4125         }
4126         if (ndr_flags & NDR_BUFFERS) {
4127                 if (r->info_array) {
4128                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4129                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4130                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4131                         }
4132                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4133                                 if (r->info_array[cntr_info_array_1]) {
4134                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4135                                 }
4136                         }
4137                 }
4138                 if (r->domain) {
4139                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
4140                 }
4141         }
4142         return NDR_ERR_SUCCESS;
4143 }
4144
4145 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
4146 {
4147         uint32_t _ptr_info_array;
4148         uint32_t cntr_info_array_1;
4149         TALLOC_CTX *_mem_save_info_array_0;
4150         TALLOC_CTX *_mem_save_info_array_1;
4151         TALLOC_CTX *_mem_save_info_array_2;
4152         uint32_t _ptr_domain;
4153         TALLOC_CTX *_mem_save_domain_0;
4154         if (ndr_flags & NDR_SCALARS) {
4155                 NDR_CHECK(ndr_pull_align(ndr, 4));
4156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4157                 if (r->count < 1 || r->count > 10000) {
4158                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4159                 }
4160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4161                 if (_ptr_info_array) {
4162                         NDR_PULL_ALLOC(ndr, r->info_array);
4163                 } else {
4164                         r->info_array = NULL;
4165                 }
4166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4167                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
4168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
4169                 if (_ptr_domain) {
4170                         NDR_PULL_ALLOC(ndr, r->domain);
4171                 } else {
4172                         r->domain = NULL;
4173                 }
4174         }
4175         if (ndr_flags & NDR_BUFFERS) {
4176                 if (r->info_array) {
4177                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4178                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4180                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4181                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4182                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4183                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4184                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4185                                 if (_ptr_info_array) {
4186                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4187                                 } else {
4188                                         r->info_array[cntr_info_array_1] = NULL;
4189                                 }
4190                         }
4191                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4192                                 if (r->info_array[cntr_info_array_1]) {
4193                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4194                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4195                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4196                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4197                                 }
4198                         }
4199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4201                 }
4202                 if (r->domain) {
4203                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
4204                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
4205                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
4206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
4207                 }
4208                 if (r->info_array) {
4209                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
4210                 }
4211         }
4212         return NDR_ERR_SUCCESS;
4213 }
4214
4215 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
4216 {
4217         uint32_t cntr_info_array_1;
4218         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
4219         ndr->depth++;
4220         ndr_print_uint32(ndr, "count", r->count);
4221         ndr_print_ptr(ndr, "info_array", r->info_array);
4222         ndr->depth++;
4223         if (r->info_array) {
4224                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
4225                 ndr->depth++;
4226                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
4227                         char *idx_1=NULL;
4228                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4229                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4230                                 ndr->depth++;
4231                                 if (r->info_array[cntr_info_array_1]) {
4232                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4233                                 }
4234                                 ndr->depth--;
4235                                 free(idx_1);
4236                         }
4237                 }
4238                 ndr->depth--;
4239         }
4240         ndr->depth--;
4241         ndr_print_uint32(ndr, "flags", r->flags);
4242         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
4243         ndr_print_ptr(ndr, "domain", r->domain);
4244         ndr->depth++;
4245         if (r->domain) {
4246                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
4247         }
4248         ndr->depth--;
4249         ndr->depth--;
4250 }
4251
4252 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
4253 {
4254         if (ndr_flags & NDR_SCALARS) {
4255                 int level = ndr_push_get_switch_value(ndr, r);
4256                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4257                 switch (level) {
4258                         case 1: {
4259                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
4260                         break; }
4261
4262                         default:
4263                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4264                 }
4265         }
4266         if (ndr_flags & NDR_BUFFERS) {
4267                 int level = ndr_push_get_switch_value(ndr, r);
4268                 switch (level) {
4269                         case 1:
4270                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
4271                         break;
4272
4273                         default:
4274                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4275                 }
4276         }
4277         return NDR_ERR_SUCCESS;
4278 }
4279
4280 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
4281 {
4282         int level;
4283         int32_t _level;
4284         level = ndr_pull_get_switch_value(ndr, r);
4285         if (ndr_flags & NDR_SCALARS) {
4286                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4287                 if (_level != level) {
4288                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4289                 }
4290                 switch (level) {
4291                         case 1: {
4292                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
4293                         break; }
4294
4295                         default:
4296                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4297                 }
4298         }
4299         if (ndr_flags & NDR_BUFFERS) {
4300                 switch (level) {
4301                         case 1:
4302                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
4303                         break;
4304
4305                         default:
4306                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4307                 }
4308         }
4309         return NDR_ERR_SUCCESS;
4310 }
4311
4312 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
4313 {
4314         int level;
4315         level = ndr_print_get_switch_value(ndr, r);
4316         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
4317         switch (level) {
4318                 case 1:
4319                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
4320                 break;
4321
4322                 default:
4323                         ndr_print_bad_level(ndr, name, level);
4324         }
4325 }
4326
4327 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
4328 {
4329         if (ndr_flags & NDR_SCALARS) {
4330                 NDR_CHECK(ndr_push_align(ndr, 4));
4331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
4332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4335         }
4336         if (ndr_flags & NDR_BUFFERS) {
4337                 if (r->data) {
4338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4339                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4340                 }
4341         }
4342         return NDR_ERR_SUCCESS;
4343 }
4344
4345 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
4346 {
4347         uint32_t _ptr_data;
4348         TALLOC_CTX *_mem_save_data_0;
4349         if (ndr_flags & NDR_SCALARS) {
4350                 NDR_CHECK(ndr_pull_align(ndr, 4));
4351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
4352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4354                 if (r->length < 0 || r->length > 0x00A00000) {
4355                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4356                 }
4357                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4358                 if (_ptr_data) {
4359                         NDR_PULL_ALLOC(ndr, r->data);
4360                 } else {
4361                         r->data = NULL;
4362                 }
4363         }
4364         if (ndr_flags & NDR_BUFFERS) {
4365                 if (r->data) {
4366                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4367                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4368                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4369                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
4370                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
4371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
4372                 }
4373                 if (r->data) {
4374                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
4375                 }
4376         }
4377         return NDR_ERR_SUCCESS;
4378 }
4379
4380 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
4381 {
4382         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
4383         ndr->depth++;
4384         ndr_print_uint32(ndr, "unknown1", r->unknown1);
4385         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4386         ndr_print_uint32(ndr, "length", r->length);
4387         ndr_print_ptr(ndr, "data", r->data);
4388         ndr->depth++;
4389         if (r->data) {
4390                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
4391         }
4392         ndr->depth--;
4393         ndr->depth--;
4394 }
4395
4396 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
4397 {
4398         if (ndr_flags & NDR_SCALARS) {
4399                 int level = ndr_push_get_switch_value(ndr, r);
4400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4401                 switch (level) {
4402                         case 1: {
4403                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
4404                         break; }
4405
4406                         default:
4407                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4408                 }
4409         }
4410         if (ndr_flags & NDR_BUFFERS) {
4411                 int level = ndr_push_get_switch_value(ndr, r);
4412                 switch (level) {
4413                         case 1:
4414                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
4415                         break;
4416
4417                         default:
4418                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4419                 }
4420         }
4421         return NDR_ERR_SUCCESS;
4422 }
4423
4424 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
4425 {
4426         int level;
4427         uint32_t _level;
4428         level = ndr_pull_get_switch_value(ndr, r);
4429         if (ndr_flags & NDR_SCALARS) {
4430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4431                 if (_level != level) {
4432                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4433                 }
4434                 switch (level) {
4435                         case 1: {
4436                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
4437                         break; }
4438
4439                         default:
4440                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4441                 }
4442         }
4443         if (ndr_flags & NDR_BUFFERS) {
4444                 switch (level) {
4445                         case 1:
4446                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
4447                         break;
4448
4449                         default:
4450                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4451                 }
4452         }
4453         return NDR_ERR_SUCCESS;
4454 }
4455
4456 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
4457 {
4458         int level;
4459         level = ndr_print_get_switch_value(ndr, r);
4460         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
4461         switch (level) {
4462                 case 1:
4463                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
4464                 break;
4465
4466                 default:
4467                         ndr_print_bad_level(ndr, name, level);
4468         }
4469 }
4470
4471 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
4472 {
4473         if (ndr_flags & NDR_SCALARS) {
4474                 NDR_CHECK(ndr_push_align(ndr, 8));
4475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
4476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
4477                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
4478                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
4479                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
4480                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
4481                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
4482                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
4483                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4484                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
4485                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
4486         }
4487         if (ndr_flags & NDR_BUFFERS) {
4488                 if (r->data1) {
4489                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
4490                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
4491                 }
4492                 if (r->data2) {
4493                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
4494                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
4495                 }
4496         }
4497         return NDR_ERR_SUCCESS;
4498 }
4499
4500 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
4501 {
4502         uint32_t _ptr_data1;
4503         TALLOC_CTX *_mem_save_data1_0;
4504         uint32_t _ptr_data2;
4505         TALLOC_CTX *_mem_save_data2_0;
4506         if (ndr_flags & NDR_SCALARS) {
4507                 NDR_CHECK(ndr_pull_align(ndr, 8));
4508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
4509                 if (r->length1 < 0 || r->length1 > 0x00A00000) {
4510                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4511                 }
4512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
4513                 if (r->length2 < 0 || r->length2 > 0x00A00000) {
4514                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4515                 }
4516                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
4517                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
4518                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
4519                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
4520                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
4521                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
4522                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4523                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
4524                 if (_ptr_data1) {
4525                         NDR_PULL_ALLOC(ndr, r->data1);
4526                 } else {
4527                         r->data1 = NULL;
4528                 }
4529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
4530                 if (_ptr_data2) {
4531                         NDR_PULL_ALLOC(ndr, r->data2);
4532                 } else {
4533                         r->data2 = NULL;
4534                 }
4535         }
4536         if (ndr_flags & NDR_BUFFERS) {
4537                 if (r->data1) {
4538                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4539                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
4540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
4541                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
4542                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
4543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
4544                 }
4545                 if (r->data2) {
4546                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4547                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
4548                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
4549                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
4550                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
4551                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
4552                 }
4553                 if (r->data1) {
4554                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
4555                 }
4556                 if (r->data2) {
4557                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
4558                 }
4559         }
4560         return NDR_ERR_SUCCESS;
4561 }
4562
4563 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
4564 {
4565         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
4566         ndr->depth++;
4567         ndr_print_uint32(ndr, "length1", r->length1);
4568         ndr_print_uint32(ndr, "length2", r->length2);
4569         ndr_print_hyper(ndr, "unknown1", r->unknown1);
4570         ndr_print_NTTIME(ndr, "time2", r->time2);
4571         ndr_print_hyper(ndr, "unknown3", r->unknown3);
4572         ndr_print_NTTIME(ndr, "time4", r->time4);
4573         ndr_print_hyper(ndr, "unknown5", r->unknown5);
4574         ndr_print_NTTIME(ndr, "time6", r->time6);
4575         ndr_print_NTSTATUS(ndr, "status", r->status);
4576         ndr_print_ptr(ndr, "data1", r->data1);
4577         ndr->depth++;
4578         if (r->data1) {
4579                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
4580         }
4581         ndr->depth--;
4582         ndr_print_ptr(ndr, "data2", r->data2);
4583         ndr->depth++;
4584         if (r->data2) {
4585                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
4586         }
4587         ndr->depth--;
4588         ndr->depth--;
4589 }
4590
4591 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
4592 {
4593         if (ndr_flags & NDR_SCALARS) {
4594                 int level = ndr_push_get_switch_value(ndr, r);
4595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4596                 switch (level) {
4597                         case 1: {
4598                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
4599                         break; }
4600
4601                         default:
4602                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4603                 }
4604         }
4605         if (ndr_flags & NDR_BUFFERS) {
4606                 int level = ndr_push_get_switch_value(ndr, r);
4607                 switch (level) {
4608                         case 1:
4609                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
4610                         break;
4611
4612                         default:
4613                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4614                 }
4615         }
4616         return NDR_ERR_SUCCESS;
4617 }
4618
4619 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
4620 {
4621         int level;
4622         uint32_t _level;
4623         level = ndr_pull_get_switch_value(ndr, r);
4624         if (ndr_flags & NDR_SCALARS) {
4625                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4626                 if (_level != level) {
4627                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4628                 }
4629                 switch (level) {
4630                         case 1: {
4631                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
4632                         break; }
4633
4634                         default:
4635                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4636                 }
4637         }
4638         if (ndr_flags & NDR_BUFFERS) {
4639                 switch (level) {
4640                         case 1:
4641                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
4642                         break;
4643
4644                         default:
4645                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4646                 }
4647         }
4648         return NDR_ERR_SUCCESS;
4649 }
4650
4651 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
4652 {
4653         int level;
4654         level = ndr_print_get_switch_value(ndr, r);
4655         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
4656         switch (level) {
4657                 case 1:
4658                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
4659                 break;
4660
4661                 default:
4662                         ndr_print_bad_level(ndr, name, level);
4663         }
4664 }
4665
4666 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
4667 {
4668         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4669         return NDR_ERR_SUCCESS;
4670 }
4671
4672 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
4673 {
4674         uint32_t v;
4675         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4676         *r = v;
4677         return NDR_ERR_SUCCESS;
4678 }
4679
4680 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
4681 {
4682         const char *val = NULL;
4683
4684         switch (r) {
4685                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
4686                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
4687                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
4688                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
4689                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
4690                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
4691                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
4692                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
4693         }
4694         ndr_print_enum(ndr, name, "ENUM", val, r);
4695 }
4696
4697 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
4698 {
4699         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4700         return NDR_ERR_SUCCESS;
4701 }
4702
4703 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
4704 {
4705         uint32_t v;
4706         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4707         *r = v;
4708         return NDR_ERR_SUCCESS;
4709 }
4710
4711 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
4712 {
4713         const char *val = NULL;
4714
4715         switch (r) {
4716                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
4717                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
4718                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
4719                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
4720                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
4721         }
4722         ndr_print_enum(ndr, name, "ENUM", val, r);
4723 }
4724
4725 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
4726 {
4727         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4728         return NDR_ERR_SUCCESS;
4729 }
4730
4731 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
4732 {
4733         uint32_t v;
4734         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4735         *r = v;
4736         return NDR_ERR_SUCCESS;
4737 }
4738
4739 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
4740 {
4741         const char *val = NULL;
4742
4743         switch (r) {
4744                 case DRSUAPI_DS_NAME_FORMAT_UKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UKNOWN"; break;
4745                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
4746                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
4747                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
4748                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
4749                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
4750                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
4751                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
4752                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
4753                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
4754                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
4755         }
4756         ndr_print_enum(ndr, name, "ENUM", val, r);
4757 }
4758
4759 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
4760 {
4761         if (ndr_flags & NDR_SCALARS) {
4762                 NDR_CHECK(ndr_push_align(ndr, 4));
4763                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
4764         }
4765         if (ndr_flags & NDR_BUFFERS) {
4766                 if (r->str) {
4767                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
4768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4769                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
4770                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4771                 }
4772         }
4773         return NDR_ERR_SUCCESS;
4774 }
4775
4776 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
4777 {
4778         uint32_t _ptr_str;
4779         TALLOC_CTX *_mem_save_str_0;
4780         if (ndr_flags & NDR_SCALARS) {
4781                 NDR_CHECK(ndr_pull_align(ndr, 4));
4782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
4783                 if (_ptr_str) {
4784                         NDR_PULL_ALLOC(ndr, r->str);
4785                 } else {
4786                         r->str = NULL;
4787                 }
4788         }
4789         if (ndr_flags & NDR_BUFFERS) {
4790                 if (r->str) {
4791                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
4792                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
4793                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
4794                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
4795                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
4796                                 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));
4797                         }
4798                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
4799                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
4800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
4801                 }
4802         }
4803         return NDR_ERR_SUCCESS;
4804 }
4805
4806 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
4807 {
4808         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
4809         ndr->depth++;
4810         ndr_print_ptr(ndr, "str", r->str);
4811         ndr->depth++;
4812         if (r->str) {
4813                 ndr_print_string(ndr, "str", r->str);
4814         }
4815         ndr->depth--;
4816         ndr->depth--;
4817 }
4818
4819 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
4820 {
4821         uint32_t cntr_names_1;
4822         if (ndr_flags & NDR_SCALARS) {
4823                 NDR_CHECK(ndr_push_align(ndr, 4));
4824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
4825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
4826                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
4827                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
4828                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
4829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4830                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
4831         }
4832         if (ndr_flags & NDR_BUFFERS) {
4833                 if (r->names) {
4834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4835                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4836                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
4837                         }
4838                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4839                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
4840                         }
4841                 }
4842         }
4843         return NDR_ERR_SUCCESS;
4844 }
4845
4846 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
4847 {
4848         uint32_t _ptr_names;
4849         uint32_t cntr_names_1;
4850         TALLOC_CTX *_mem_save_names_0;
4851         TALLOC_CTX *_mem_save_names_1;
4852         if (ndr_flags & NDR_SCALARS) {
4853                 NDR_CHECK(ndr_pull_align(ndr, 4));
4854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
4855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
4856                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
4857                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
4858                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
4859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4860                 if (r->count < 1 || r->count > 10000) {
4861                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4862                 }
4863                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
4864                 if (_ptr_names) {
4865                         NDR_PULL_ALLOC(ndr, r->names);
4866                 } else {
4867                         r->names = NULL;
4868                 }
4869         }
4870         if (ndr_flags & NDR_BUFFERS) {
4871                 if (r->names) {
4872                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
4873                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
4874                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
4875                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
4876                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
4877                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
4878                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4879                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
4880                         }
4881                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4882                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
4883                         }
4884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
4885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
4886                 }
4887                 if (r->names) {
4888                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
4889                 }
4890         }
4891         return NDR_ERR_SUCCESS;
4892 }
4893
4894 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
4895 {
4896         uint32_t cntr_names_1;
4897         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
4898         ndr->depth++;
4899         ndr_print_uint32(ndr, "codepage", r->codepage);
4900         ndr_print_uint32(ndr, "language", r->language);
4901         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
4902         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
4903         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
4904         ndr_print_uint32(ndr, "count", r->count);
4905         ndr_print_ptr(ndr, "names", r->names);
4906         ndr->depth++;
4907         if (r->names) {
4908                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
4909                 ndr->depth++;
4910                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
4911                         char *idx_1=NULL;
4912                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
4913                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
4914                                 free(idx_1);
4915                         }
4916                 }
4917                 ndr->depth--;
4918         }
4919         ndr->depth--;
4920         ndr->depth--;
4921 }
4922
4923 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
4924 {
4925         if (ndr_flags & NDR_SCALARS) {
4926                 int level = ndr_push_get_switch_value(ndr, r);
4927                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4928                 switch (level) {
4929                         case 1: {
4930                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
4931                         break; }
4932
4933                         default:
4934                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4935                 }
4936         }
4937         if (ndr_flags & NDR_BUFFERS) {
4938                 int level = ndr_push_get_switch_value(ndr, r);
4939                 switch (level) {
4940                         case 1:
4941                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
4942                         break;
4943
4944                         default:
4945                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4946                 }
4947         }
4948         return NDR_ERR_SUCCESS;
4949 }
4950
4951 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
4952 {
4953         int level;
4954         int32_t _level;
4955         level = ndr_pull_get_switch_value(ndr, r);
4956         if (ndr_flags & NDR_SCALARS) {
4957                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4958                 if (_level != level) {
4959                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4960                 }
4961                 switch (level) {
4962                         case 1: {
4963                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
4964                         break; }
4965
4966                         default:
4967                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4968                 }
4969         }
4970         if (ndr_flags & NDR_BUFFERS) {
4971                 switch (level) {
4972                         case 1:
4973                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
4974                         break;
4975
4976                         default:
4977                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4978                 }
4979         }
4980         return NDR_ERR_SUCCESS;
4981 }
4982
4983 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
4984 {
4985         int level;
4986         level = ndr_print_get_switch_value(ndr, r);
4987         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
4988         switch (level) {
4989                 case 1:
4990                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
4991                 break;
4992
4993                 default:
4994                         ndr_print_bad_level(ndr, name, level);
4995         }
4996 }
4997
4998 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
4999 {
5000         if (ndr_flags & NDR_SCALARS) {
5001                 NDR_CHECK(ndr_push_align(ndr, 4));
5002                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5003                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5005         }
5006         if (ndr_flags & NDR_BUFFERS) {
5007                 if (r->dns_domain_name) {
5008                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5011                         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));
5012                 }
5013                 if (r->result_name) {
5014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5015                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5017                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5018                 }
5019         }
5020         return NDR_ERR_SUCCESS;
5021 }
5022
5023 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5024 {
5025         uint32_t _ptr_dns_domain_name;
5026         TALLOC_CTX *_mem_save_dns_domain_name_0;
5027         uint32_t _ptr_result_name;
5028         TALLOC_CTX *_mem_save_result_name_0;
5029         if (ndr_flags & NDR_SCALARS) {
5030                 NDR_CHECK(ndr_pull_align(ndr, 4));
5031                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5033                 if (_ptr_dns_domain_name) {
5034                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5035                 } else {
5036                         r->dns_domain_name = NULL;
5037                 }
5038                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5039                 if (_ptr_result_name) {
5040                         NDR_PULL_ALLOC(ndr, r->result_name);
5041                 } else {
5042                         r->result_name = NULL;
5043                 }
5044         }
5045         if (ndr_flags & NDR_BUFFERS) {
5046                 if (r->dns_domain_name) {
5047                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5048                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5049                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5050                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5051                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5052                                 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));
5053                         }
5054                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5055                         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));
5056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5057                 }
5058                 if (r->result_name) {
5059                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5060                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5062                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5063                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5064                                 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));
5065                         }
5066                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5067                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5069                 }
5070         }
5071         return NDR_ERR_SUCCESS;
5072 }
5073
5074 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5075 {
5076         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5077         ndr->depth++;
5078         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5079         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5080         ndr->depth++;
5081         if (r->dns_domain_name) {
5082                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5083         }
5084         ndr->depth--;
5085         ndr_print_ptr(ndr, "result_name", r->result_name);
5086         ndr->depth++;
5087         if (r->result_name) {
5088                 ndr_print_string(ndr, "result_name", r->result_name);
5089         }
5090         ndr->depth--;
5091         ndr->depth--;
5092 }
5093
5094 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5095 {
5096         uint32_t cntr_array_1;
5097         if (ndr_flags & NDR_SCALARS) {
5098                 NDR_CHECK(ndr_push_align(ndr, 4));
5099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5101         }
5102         if (ndr_flags & NDR_BUFFERS) {
5103                 if (r->array) {
5104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5105                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5106                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5107                         }
5108                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5109                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5110                         }
5111                 }
5112         }
5113         return NDR_ERR_SUCCESS;
5114 }
5115
5116 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
5117 {
5118         uint32_t _ptr_array;
5119         uint32_t cntr_array_1;
5120         TALLOC_CTX *_mem_save_array_0;
5121         TALLOC_CTX *_mem_save_array_1;
5122         if (ndr_flags & NDR_SCALARS) {
5123                 NDR_CHECK(ndr_pull_align(ndr, 4));
5124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5126                 if (_ptr_array) {
5127                         NDR_PULL_ALLOC(ndr, r->array);
5128                 } else {
5129                         r->array = NULL;
5130                 }
5131         }
5132         if (ndr_flags & NDR_BUFFERS) {
5133                 if (r->array) {
5134                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5135                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5136                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5137                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5138                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5139                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5140                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5141                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5142                         }
5143                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5144                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5145                         }
5146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5148                 }
5149                 if (r->array) {
5150                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5151                 }
5152         }
5153         return NDR_ERR_SUCCESS;
5154 }
5155
5156 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
5157 {
5158         uint32_t cntr_array_1;
5159         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
5160         ndr->depth++;
5161         ndr_print_uint32(ndr, "count", r->count);
5162         ndr_print_ptr(ndr, "array", r->array);
5163         ndr->depth++;
5164         if (r->array) {
5165                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5166                 ndr->depth++;
5167                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5168                         char *idx_1=NULL;
5169                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5170                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
5171                                 free(idx_1);
5172                         }
5173                 }
5174                 ndr->depth--;
5175         }
5176         ndr->depth--;
5177         ndr->depth--;
5178 }
5179
5180 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
5181 {
5182         if (ndr_flags & NDR_SCALARS) {
5183                 int level = ndr_push_get_switch_value(ndr, r);
5184                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5185                 switch (level) {
5186                         case 1: {
5187                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5188                         break; }
5189
5190                         default:
5191                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5192                 }
5193         }
5194         if (ndr_flags & NDR_BUFFERS) {
5195                 int level = ndr_push_get_switch_value(ndr, r);
5196                 switch (level) {
5197                         case 1:
5198                                 if (r->ctr1) {
5199                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5200                                 }
5201                         break;
5202
5203                         default:
5204                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5205                 }
5206         }
5207         return NDR_ERR_SUCCESS;
5208 }
5209
5210 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
5211 {
5212         int level;
5213         int32_t _level;
5214         TALLOC_CTX *_mem_save_ctr1_0;
5215         level = ndr_pull_get_switch_value(ndr, r);
5216         if (ndr_flags & NDR_SCALARS) {
5217                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5218                 if (_level != level) {
5219                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5220                 }
5221                 switch (level) {
5222                         case 1: {
5223                                 uint32_t _ptr_ctr1;
5224                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
5225                                 if (_ptr_ctr1) {
5226                                         NDR_PULL_ALLOC(ndr, r->ctr1);
5227                                 } else {
5228                                         r->ctr1 = NULL;
5229                                 }
5230                         break; }
5231
5232                         default:
5233                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5234                 }
5235         }
5236         if (ndr_flags & NDR_BUFFERS) {
5237                 switch (level) {
5238                         case 1:
5239                                 if (r->ctr1) {
5240                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5241                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
5242                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5243                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
5244                                 }
5245                         break;
5246
5247                         default:
5248                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5249                 }
5250         }
5251         return NDR_ERR_SUCCESS;
5252 }
5253
5254 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
5255 {
5256         int level;
5257         level = ndr_print_get_switch_value(ndr, r);
5258         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
5259         switch (level) {
5260                 case 1:
5261                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
5262                         ndr->depth++;
5263                         if (r->ctr1) {
5264                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
5265                         }
5266                         ndr->depth--;
5267                 break;
5268
5269                 default:
5270                         ndr_print_bad_level(ndr, name, level);
5271         }
5272 }
5273
5274 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
5275 {
5276         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5277         return NDR_ERR_SUCCESS;
5278 }
5279
5280 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
5281 {
5282         uint32_t v;
5283         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5284         *r = v;
5285         return NDR_ERR_SUCCESS;
5286 }
5287
5288 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
5289 {
5290         const char *val = NULL;
5291
5292         switch (r) {
5293                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
5294                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
5295                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
5296         }
5297         ndr_print_enum(ndr, name, "ENUM", val, r);
5298 }
5299
5300 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
5301 {
5302         uint32_t cntr_spn_names_1;
5303         if (ndr_flags & NDR_SCALARS) {
5304                 NDR_CHECK(ndr_push_align(ndr, 4));
5305                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
5306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5307                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
5308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
5310         }
5311         if (ndr_flags & NDR_BUFFERS) {
5312                 if (r->object_dn) {
5313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
5314                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5315                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
5316                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5317                 }
5318                 if (r->spn_names) {
5319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5320                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
5321                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
5322                         }
5323                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
5324                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
5325                         }
5326                 }
5327         }
5328         return NDR_ERR_SUCCESS;
5329 }
5330
5331 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
5332 {
5333         uint32_t _ptr_object_dn;
5334         TALLOC_CTX *_mem_save_object_dn_0;
5335         uint32_t _ptr_spn_names;
5336         uint32_t cntr_spn_names_1;
5337         TALLOC_CTX *_mem_save_spn_names_0;
5338         TALLOC_CTX *_mem_save_spn_names_1;
5339         if (ndr_flags & NDR_SCALARS) {
5340                 NDR_CHECK(ndr_pull_align(ndr, 4));
5341                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
5342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5343                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
5344                 if (_ptr_object_dn) {
5345                         NDR_PULL_ALLOC(ndr, r->object_dn);
5346                 } else {
5347                         r->object_dn = NULL;
5348                 }
5349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5350                 if (r->count < 0 || r->count > 10000) {
5351                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5352                 }
5353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
5354                 if (_ptr_spn_names) {
5355                         NDR_PULL_ALLOC(ndr, r->spn_names);
5356                 } else {
5357                         r->spn_names = NULL;
5358                 }
5359         }
5360         if (ndr_flags & NDR_BUFFERS) {
5361                 if (r->object_dn) {
5362                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
5363                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
5364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
5365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
5366                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
5367                                 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));
5368                         }
5369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
5370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
5371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
5372                 }
5373                 if (r->spn_names) {
5374                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5375                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
5376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
5377                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
5378                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5379                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
5380                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
5381                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
5382                         }
5383                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
5384                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
5385                         }
5386                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
5387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
5388                 }
5389                 if (r->spn_names) {
5390                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
5391                 }
5392         }
5393         return NDR_ERR_SUCCESS;
5394 }
5395
5396 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
5397 {
5398         uint32_t cntr_spn_names_1;
5399         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
5400         ndr->depth++;
5401         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
5402         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5403         ndr_print_ptr(ndr, "object_dn", r->object_dn);
5404         ndr->depth++;
5405         if (r->object_dn) {
5406                 ndr_print_string(ndr, "object_dn", r->object_dn);
5407         }
5408         ndr->depth--;
5409         ndr_print_uint32(ndr, "count", r->count);
5410         ndr_print_ptr(ndr, "spn_names", r->spn_names);
5411         ndr->depth++;
5412         if (r->spn_names) {
5413                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
5414                 ndr->depth++;
5415                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
5416                         char *idx_1=NULL;
5417                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
5418                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
5419                                 free(idx_1);
5420                         }
5421                 }
5422                 ndr->depth--;
5423         }
5424         ndr->depth--;
5425         ndr->depth--;
5426 }
5427
5428 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
5429 {
5430         if (ndr_flags & NDR_SCALARS) {
5431                 int level = ndr_push_get_switch_value(ndr, r);
5432                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5433                 switch (level) {
5434                         case 1: {
5435                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
5436                         break; }
5437
5438                         default:
5439                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5440                 }
5441         }
5442         if (ndr_flags & NDR_BUFFERS) {
5443                 int level = ndr_push_get_switch_value(ndr, r);
5444                 switch (level) {
5445                         case 1:
5446                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
5447                         break;
5448
5449                         default:
5450                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5451                 }
5452         }
5453         return NDR_ERR_SUCCESS;
5454 }
5455
5456 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
5457 {
5458         int level;
5459         int32_t _level;
5460         level = ndr_pull_get_switch_value(ndr, r);
5461         if (ndr_flags & NDR_SCALARS) {
5462                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5463                 if (_level != level) {
5464                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5465                 }
5466                 switch (level) {
5467                         case 1: {
5468                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
5469                         break; }
5470
5471                         default:
5472                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5473                 }
5474         }
5475         if (ndr_flags & NDR_BUFFERS) {
5476                 switch (level) {
5477                         case 1:
5478                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
5479                         break;
5480
5481                         default:
5482                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5483                 }
5484         }
5485         return NDR_ERR_SUCCESS;
5486 }
5487
5488 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
5489 {
5490         int level;
5491         level = ndr_print_get_switch_value(ndr, r);
5492         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
5493         switch (level) {
5494                 case 1:
5495                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
5496                 break;
5497
5498                 default:
5499                         ndr_print_bad_level(ndr, name, level);
5500         }
5501 }
5502
5503 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
5504 {
5505         if (ndr_flags & NDR_SCALARS) {
5506                 NDR_CHECK(ndr_push_align(ndr, 4));
5507                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
5508         }
5509         if (ndr_flags & NDR_BUFFERS) {
5510         }
5511         return NDR_ERR_SUCCESS;
5512 }
5513
5514 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
5515 {
5516         if (ndr_flags & NDR_SCALARS) {
5517                 NDR_CHECK(ndr_pull_align(ndr, 4));
5518                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
5519         }
5520         if (ndr_flags & NDR_BUFFERS) {
5521         }
5522         return NDR_ERR_SUCCESS;
5523 }
5524
5525 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
5526 {
5527         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
5528         ndr->depth++;
5529         ndr_print_WERROR(ndr, "status", r->status);
5530         ndr->depth--;
5531 }
5532
5533 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
5534 {
5535         if (ndr_flags & NDR_SCALARS) {
5536                 int level = ndr_push_get_switch_value(ndr, r);
5537                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5538                 switch (level) {
5539                         case 1: {
5540                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
5541                         break; }
5542
5543                         default:
5544                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5545                 }
5546         }
5547         if (ndr_flags & NDR_BUFFERS) {
5548                 int level = ndr_push_get_switch_value(ndr, r);
5549                 switch (level) {
5550                         case 1:
5551                         break;
5552
5553                         default:
5554                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5555                 }
5556         }
5557         return NDR_ERR_SUCCESS;
5558 }
5559
5560 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
5561 {
5562         int level;
5563         int32_t _level;
5564         level = ndr_pull_get_switch_value(ndr, r);
5565         if (ndr_flags & NDR_SCALARS) {
5566                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5567                 if (_level != level) {
5568                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5569                 }
5570                 switch (level) {
5571                         case 1: {
5572                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
5573                         break; }
5574
5575                         default:
5576                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5577                 }
5578         }
5579         if (ndr_flags & NDR_BUFFERS) {
5580                 switch (level) {
5581                         case 1:
5582                         break;
5583
5584                         default:
5585                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5586                 }
5587         }
5588         return NDR_ERR_SUCCESS;
5589 }
5590
5591 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
5592 {
5593         int level;
5594         level = ndr_print_get_switch_value(ndr, r);
5595         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
5596         switch (level) {
5597                 case 1:
5598                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
5599                 break;
5600
5601                 default:
5602                         ndr_print_bad_level(ndr, name, level);
5603         }
5604 }
5605
5606 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
5607 {
5608         if (ndr_flags & NDR_SCALARS) {
5609                 NDR_CHECK(ndr_push_align(ndr, 4));
5610                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
5611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
5612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
5613         }
5614         if (ndr_flags & NDR_BUFFERS) {
5615                 if (r->server_dn) {
5616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
5617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
5619                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5620                 }
5621                 if (r->domain_dn) {
5622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
5623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
5625                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5626                 }
5627         }
5628         return NDR_ERR_SUCCESS;
5629 }
5630
5631 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
5632 {
5633         uint32_t _ptr_server_dn;
5634         TALLOC_CTX *_mem_save_server_dn_0;
5635         uint32_t _ptr_domain_dn;
5636         TALLOC_CTX *_mem_save_domain_dn_0;
5637         if (ndr_flags & NDR_SCALARS) {
5638                 NDR_CHECK(ndr_pull_align(ndr, 4));
5639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
5640                 if (_ptr_server_dn) {
5641                         NDR_PULL_ALLOC(ndr, r->server_dn);
5642                 } else {
5643                         r->server_dn = NULL;
5644                 }
5645                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
5646                 if (_ptr_domain_dn) {
5647                         NDR_PULL_ALLOC(ndr, r->domain_dn);
5648                 } else {
5649                         r->domain_dn = NULL;
5650                 }
5651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
5652         }
5653         if (ndr_flags & NDR_BUFFERS) {
5654                 if (r->server_dn) {
5655                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
5656                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
5657                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
5658                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
5659                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
5660                                 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));
5661                         }
5662                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
5663                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
5664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
5665                 }
5666                 if (r->domain_dn) {
5667                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
5668                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
5669                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
5670                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
5671                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
5672                                 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));
5673                         }
5674                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
5675                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
5676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
5677                 }
5678         }
5679         return NDR_ERR_SUCCESS;
5680 }
5681
5682 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
5683 {
5684         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
5685         ndr->depth++;
5686         ndr_print_ptr(ndr, "server_dn", r->server_dn);
5687         ndr->depth++;
5688         if (r->server_dn) {
5689                 ndr_print_string(ndr, "server_dn", r->server_dn);
5690         }
5691         ndr->depth--;
5692         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
5693         ndr->depth++;
5694         if (r->domain_dn) {
5695                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
5696         }
5697         ndr->depth--;
5698         ndr_print_uint32(ndr, "unknown", r->unknown);
5699         ndr->depth--;
5700 }
5701
5702 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
5703 {
5704         if (ndr_flags & NDR_SCALARS) {
5705                 int level = ndr_push_get_switch_value(ndr, r);
5706                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5707                 switch (level) {
5708                         case 1: {
5709                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
5710                         break; }
5711
5712                         default:
5713                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5714                 }
5715         }
5716         if (ndr_flags & NDR_BUFFERS) {
5717                 int level = ndr_push_get_switch_value(ndr, r);
5718                 switch (level) {
5719                         case 1:
5720                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
5721                         break;
5722
5723                         default:
5724                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5725                 }
5726         }
5727         return NDR_ERR_SUCCESS;
5728 }
5729
5730 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
5731 {
5732         int level;
5733         int32_t _level;
5734         level = ndr_pull_get_switch_value(ndr, r);
5735         if (ndr_flags & NDR_SCALARS) {
5736                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5737                 if (_level != level) {
5738                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5739                 }
5740                 switch (level) {
5741                         case 1: {
5742                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
5743                         break; }
5744
5745                         default:
5746                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5747                 }
5748         }
5749         if (ndr_flags & NDR_BUFFERS) {
5750                 switch (level) {
5751                         case 1:
5752                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
5753                         break;
5754
5755                         default:
5756                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5757                 }
5758         }
5759         return NDR_ERR_SUCCESS;
5760 }
5761
5762 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
5763 {
5764         int level;
5765         level = ndr_print_get_switch_value(ndr, r);
5766         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
5767         switch (level) {
5768                 case 1:
5769                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
5770                 break;
5771
5772                 default:
5773                         ndr_print_bad_level(ndr, name, level);
5774         }
5775 }
5776
5777 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
5778 {
5779         if (ndr_flags & NDR_SCALARS) {
5780                 NDR_CHECK(ndr_push_align(ndr, 4));
5781                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
5782         }
5783         if (ndr_flags & NDR_BUFFERS) {
5784         }
5785         return NDR_ERR_SUCCESS;
5786 }
5787
5788 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
5789 {
5790         if (ndr_flags & NDR_SCALARS) {
5791                 NDR_CHECK(ndr_pull_align(ndr, 4));
5792                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
5793         }
5794         if (ndr_flags & NDR_BUFFERS) {
5795         }
5796         return NDR_ERR_SUCCESS;
5797 }
5798
5799 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
5800 {
5801         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
5802         ndr->depth++;
5803         ndr_print_WERROR(ndr, "status", r->status);
5804         ndr->depth--;
5805 }
5806
5807 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
5808 {
5809         if (ndr_flags & NDR_SCALARS) {
5810                 int level = ndr_push_get_switch_value(ndr, r);
5811                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5812                 switch (level) {
5813                         case 1: {
5814                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
5815                         break; }
5816
5817                         default:
5818                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5819                 }
5820         }
5821         if (ndr_flags & NDR_BUFFERS) {
5822                 int level = ndr_push_get_switch_value(ndr, r);
5823                 switch (level) {
5824                         case 1:
5825                         break;
5826
5827                         default:
5828                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5829                 }
5830         }
5831         return NDR_ERR_SUCCESS;
5832 }
5833
5834 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
5835 {
5836         int level;
5837         int32_t _level;
5838         level = ndr_pull_get_switch_value(ndr, r);
5839         if (ndr_flags & NDR_SCALARS) {
5840                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5841                 if (_level != level) {
5842                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5843                 }
5844                 switch (level) {
5845                         case 1: {
5846                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
5847                         break; }
5848
5849                         default:
5850                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5851                 }
5852         }
5853         if (ndr_flags & NDR_BUFFERS) {
5854                 switch (level) {
5855                         case 1:
5856                         break;
5857
5858                         default:
5859                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5860                 }
5861         }
5862         return NDR_ERR_SUCCESS;
5863 }
5864
5865 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
5866 {
5867         int level;
5868         level = ndr_print_get_switch_value(ndr, r);
5869         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
5870         switch (level) {
5871                 case 1:
5872                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
5873                 break;
5874
5875                 default:
5876                         ndr_print_bad_level(ndr, name, level);
5877         }
5878 }
5879
5880 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
5881 {
5882         if (ndr_flags & NDR_SCALARS) {
5883                 NDR_CHECK(ndr_push_align(ndr, 4));
5884                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
5885                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
5886         }
5887         if (ndr_flags & NDR_BUFFERS) {
5888                 if (r->domain_name) {
5889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
5890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5891                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
5892                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5893                 }
5894         }
5895         return NDR_ERR_SUCCESS;
5896 }
5897
5898 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
5899 {
5900         uint32_t _ptr_domain_name;
5901         TALLOC_CTX *_mem_save_domain_name_0;
5902         if (ndr_flags & NDR_SCALARS) {
5903                 NDR_CHECK(ndr_pull_align(ndr, 4));
5904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
5905                 if (_ptr_domain_name) {
5906                         NDR_PULL_ALLOC(ndr, r->domain_name);
5907                 } else {
5908                         r->domain_name = NULL;
5909                 }
5910                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
5911         }
5912         if (ndr_flags & NDR_BUFFERS) {
5913                 if (r->domain_name) {
5914                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5915                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
5916                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
5917                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
5918                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
5919                                 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));
5920                         }
5921                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
5922                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
5923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
5924                 }
5925         }
5926         return NDR_ERR_SUCCESS;
5927 }
5928
5929 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
5930 {
5931         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
5932         ndr->depth++;
5933         ndr_print_ptr(ndr, "domain_name", r->domain_name);
5934         ndr->depth++;
5935         if (r->domain_name) {
5936                 ndr_print_string(ndr, "domain_name", r->domain_name);
5937         }
5938         ndr->depth--;
5939         ndr_print_int32(ndr, "level", r->level);
5940         ndr->depth--;
5941 }
5942
5943 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
5944 {
5945         if (ndr_flags & NDR_SCALARS) {
5946                 int level = ndr_push_get_switch_value(ndr, r);
5947                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5948                 switch (level) {
5949                         case 1: {
5950                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
5951                         break; }
5952
5953                         default:
5954                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5955                 }
5956         }
5957         if (ndr_flags & NDR_BUFFERS) {
5958                 int level = ndr_push_get_switch_value(ndr, r);
5959                 switch (level) {
5960                         case 1:
5961                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
5962                         break;
5963
5964                         default:
5965                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5966                 }
5967         }
5968         return NDR_ERR_SUCCESS;
5969 }
5970
5971 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
5972 {
5973         int level;
5974         int32_t _level;
5975         level = ndr_pull_get_switch_value(ndr, r);
5976         if (ndr_flags & NDR_SCALARS) {
5977                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5978                 if (_level != level) {
5979                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5980                 }
5981                 switch (level) {
5982                         case 1: {
5983                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
5984                         break; }
5985
5986                         default:
5987                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5988                 }
5989         }
5990         if (ndr_flags & NDR_BUFFERS) {
5991                 switch (level) {
5992                         case 1:
5993                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
5994                         break;
5995
5996                         default:
5997                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5998                 }
5999         }
6000         return NDR_ERR_SUCCESS;
6001 }
6002
6003 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6004 {
6005         int level;
6006         level = ndr_print_get_switch_value(ndr, r);
6007         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6008         switch (level) {
6009                 case 1:
6010                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6011                 break;
6012
6013                 default:
6014                         ndr_print_bad_level(ndr, name, level);
6015         }
6016 }
6017
6018 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6019 {
6020         if (ndr_flags & NDR_SCALARS) {
6021                 NDR_CHECK(ndr_push_align(ndr, 4));
6022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6023                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6025                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6026                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6029         }
6030         if (ndr_flags & NDR_BUFFERS) {
6031                 if (r->netbios_name) {
6032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6034                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6035                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6036                 }
6037                 if (r->dns_name) {
6038                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6039                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6040                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6041                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6042                 }
6043                 if (r->site_name) {
6044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6047                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6048                 }
6049                 if (r->computer_dn) {
6050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6053                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6054                 }
6055                 if (r->server_dn) {
6056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6059                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6060                 }
6061         }
6062         return NDR_ERR_SUCCESS;
6063 }
6064
6065 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6066 {
6067         uint32_t _ptr_netbios_name;
6068         TALLOC_CTX *_mem_save_netbios_name_0;
6069         uint32_t _ptr_dns_name;
6070         TALLOC_CTX *_mem_save_dns_name_0;
6071         uint32_t _ptr_site_name;
6072         TALLOC_CTX *_mem_save_site_name_0;
6073         uint32_t _ptr_computer_dn;
6074         TALLOC_CTX *_mem_save_computer_dn_0;
6075         uint32_t _ptr_server_dn;
6076         TALLOC_CTX *_mem_save_server_dn_0;
6077         if (ndr_flags & NDR_SCALARS) {
6078                 NDR_CHECK(ndr_pull_align(ndr, 4));
6079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6080                 if (_ptr_netbios_name) {
6081                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6082                 } else {
6083                         r->netbios_name = NULL;
6084                 }
6085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6086                 if (_ptr_dns_name) {
6087                         NDR_PULL_ALLOC(ndr, r->dns_name);
6088                 } else {
6089                         r->dns_name = NULL;
6090                 }
6091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6092                 if (_ptr_site_name) {
6093                         NDR_PULL_ALLOC(ndr, r->site_name);
6094                 } else {
6095                         r->site_name = NULL;
6096                 }
6097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6098                 if (_ptr_computer_dn) {
6099                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6100                 } else {
6101                         r->computer_dn = NULL;
6102                 }
6103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6104                 if (_ptr_server_dn) {
6105                         NDR_PULL_ALLOC(ndr, r->server_dn);
6106                 } else {
6107                         r->server_dn = NULL;
6108                 }
6109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
6110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
6111         }
6112         if (ndr_flags & NDR_BUFFERS) {
6113                 if (r->netbios_name) {
6114                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6115                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
6116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
6117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
6118                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
6119                                 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));
6120                         }
6121                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
6122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
6123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
6124                 }
6125                 if (r->dns_name) {
6126                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6127                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
6128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
6129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
6130                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
6131                                 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));
6132                         }
6133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
6134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
6135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
6136                 }
6137                 if (r->site_name) {
6138                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6139                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
6140                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
6141                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
6142                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
6143                                 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));
6144                         }
6145                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
6146                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
6147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
6148                 }
6149                 if (r->computer_dn) {
6150                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6151                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
6152                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
6153                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
6154                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
6155                                 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));
6156                         }
6157                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
6158                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
6159                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
6160                 }
6161                 if (r->server_dn) {
6162                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6163                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6166                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_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->server_dn), ndr_get_array_length(ndr, &r->server_dn));
6168                         }
6169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6172                 }
6173         }
6174         return NDR_ERR_SUCCESS;
6175 }
6176
6177 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
6178 {
6179         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
6180         ndr->depth++;
6181         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
6182         ndr->depth++;
6183         if (r->netbios_name) {
6184                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
6185         }
6186         ndr->depth--;
6187         ndr_print_ptr(ndr, "dns_name", r->dns_name);
6188         ndr->depth++;
6189         if (r->dns_name) {
6190                 ndr_print_string(ndr, "dns_name", r->dns_name);
6191         }
6192         ndr->depth--;
6193         ndr_print_ptr(ndr, "site_name", r->site_name);
6194         ndr->depth++;
6195         if (r->site_name) {
6196                 ndr_print_string(ndr, "site_name", r->site_name);
6197         }
6198         ndr->depth--;
6199         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
6200         ndr->depth++;
6201         if (r->computer_dn) {
6202                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
6203         }
6204         ndr->depth--;
6205         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6206         ndr->depth++;
6207         if (r->server_dn) {
6208                 ndr_print_string(ndr, "server_dn", r->server_dn);
6209         }
6210         ndr->depth--;
6211         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
6212         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
6213         ndr->depth--;
6214 }
6215
6216 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
6217 {
6218         uint32_t cntr_array_1;
6219         if (ndr_flags & NDR_SCALARS) {
6220                 NDR_CHECK(ndr_push_align(ndr, 4));
6221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6222                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6223         }
6224         if (ndr_flags & NDR_BUFFERS) {
6225                 if (r->array) {
6226                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6227                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6228                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6229                         }
6230                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6231                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6232                         }
6233                 }
6234         }
6235         return NDR_ERR_SUCCESS;
6236 }
6237
6238 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
6239 {
6240         uint32_t _ptr_array;
6241         uint32_t cntr_array_1;
6242         TALLOC_CTX *_mem_save_array_0;
6243         TALLOC_CTX *_mem_save_array_1;
6244         if (ndr_flags & NDR_SCALARS) {
6245                 NDR_CHECK(ndr_pull_align(ndr, 4));
6246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6247                 if (r->count < 0 || r->count > 10000) {
6248                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6249                 }
6250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6251                 if (_ptr_array) {
6252                         NDR_PULL_ALLOC(ndr, r->array);
6253                 } else {
6254                         r->array = NULL;
6255                 }
6256         }
6257         if (ndr_flags & NDR_BUFFERS) {
6258                 if (r->array) {
6259                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6260                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6261                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6262                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6263                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6264                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6265                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6266                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6267                         }
6268                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6269                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6270                         }
6271                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6273                 }
6274                 if (r->array) {
6275                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6276                 }
6277         }
6278         return NDR_ERR_SUCCESS;
6279 }
6280
6281 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
6282 {
6283         uint32_t cntr_array_1;
6284         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
6285         ndr->depth++;
6286         ndr_print_uint32(ndr, "count", r->count);
6287         ndr_print_ptr(ndr, "array", r->array);
6288         ndr->depth++;
6289         if (r->array) {
6290                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6291                 ndr->depth++;
6292                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6293                         char *idx_1=NULL;
6294                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6295                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
6296                                 free(idx_1);
6297                         }
6298                 }
6299                 ndr->depth--;
6300         }
6301         ndr->depth--;
6302         ndr->depth--;
6303 }
6304
6305 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
6306 {
6307         if (ndr_flags & NDR_SCALARS) {
6308                 NDR_CHECK(ndr_push_align(ndr, 4));
6309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6310                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6311                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6312                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
6313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6314                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6315                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
6316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
6319                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
6320                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
6321                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
6322                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
6323         }
6324         if (ndr_flags & NDR_BUFFERS) {
6325                 if (r->netbios_name) {
6326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6328                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6329                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6330                 }
6331                 if (r->dns_name) {
6332                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6333                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6334                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6335                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6336                 }
6337                 if (r->site_name) {
6338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6342                 }
6343                 if (r->site_dn) {
6344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6347                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6348                 }
6349                 if (r->computer_dn) {
6350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6352                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6353                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6354                 }
6355                 if (r->server_dn) {
6356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6359                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6360                 }
6361                 if (r->ntds_dn) {
6362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6365                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6366                 }
6367         }
6368         return NDR_ERR_SUCCESS;
6369 }
6370
6371 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
6372 {
6373         uint32_t _ptr_netbios_name;
6374         TALLOC_CTX *_mem_save_netbios_name_0;
6375         uint32_t _ptr_dns_name;
6376         TALLOC_CTX *_mem_save_dns_name_0;
6377         uint32_t _ptr_site_name;
6378         TALLOC_CTX *_mem_save_site_name_0;
6379         uint32_t _ptr_site_dn;
6380         TALLOC_CTX *_mem_save_site_dn_0;
6381         uint32_t _ptr_computer_dn;
6382         TALLOC_CTX *_mem_save_computer_dn_0;
6383         uint32_t _ptr_server_dn;
6384         TALLOC_CTX *_mem_save_server_dn_0;
6385         uint32_t _ptr_ntds_dn;
6386         TALLOC_CTX *_mem_save_ntds_dn_0;
6387         if (ndr_flags & NDR_SCALARS) {
6388                 NDR_CHECK(ndr_pull_align(ndr, 4));
6389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6390                 if (_ptr_netbios_name) {
6391                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6392                 } else {
6393                         r->netbios_name = NULL;
6394                 }
6395                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6396                 if (_ptr_dns_name) {
6397                         NDR_PULL_ALLOC(ndr, r->dns_name);
6398                 } else {
6399                         r->dns_name = NULL;
6400                 }
6401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6402                 if (_ptr_site_name) {
6403                         NDR_PULL_ALLOC(ndr, r->site_name);
6404                 } else {
6405                         r->site_name = NULL;
6406                 }
6407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
6408                 if (_ptr_site_dn) {
6409                         NDR_PULL_ALLOC(ndr, r->site_dn);
6410                 } else {
6411                         r->site_dn = NULL;
6412                 }
6413                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6414                 if (_ptr_computer_dn) {
6415                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6416                 } else {
6417                         r->computer_dn = NULL;
6418                 }
6419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6420                 if (_ptr_server_dn) {
6421                         NDR_PULL_ALLOC(ndr, r->server_dn);
6422                 } else {
6423                         r->server_dn = NULL;
6424                 }
6425                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
6426                 if (_ptr_ntds_dn) {
6427                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
6428                 } else {
6429                         r->ntds_dn = NULL;
6430                 }
6431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
6432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
6433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
6434                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
6435                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
6436                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
6437                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
6438         }
6439         if (ndr_flags & NDR_BUFFERS) {
6440                 if (r->netbios_name) {
6441                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6442                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
6443                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
6444                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
6445                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
6446                                 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));
6447                         }
6448                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
6449                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
6450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
6451                 }
6452                 if (r->dns_name) {
6453                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6454                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
6455                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
6456                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
6457                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
6458                                 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));
6459                         }
6460                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
6461                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
6462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
6463                 }
6464                 if (r->site_name) {
6465                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6466                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
6467                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
6468                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
6469                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
6470                                 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));
6471                         }
6472                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
6473                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
6474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
6475                 }
6476                 if (r->site_dn) {
6477                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6478                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
6479                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
6480                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
6481                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
6482                                 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));
6483                         }
6484                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
6485                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
6486                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
6487                 }
6488                 if (r->computer_dn) {
6489                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6490                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
6491                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
6492                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
6493                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
6494                                 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));
6495                         }
6496                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
6497                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
6498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
6499                 }
6500                 if (r->server_dn) {
6501                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6502                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6503                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6504                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6505                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6506                                 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));
6507                         }
6508                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6509                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6511                 }
6512                 if (r->ntds_dn) {
6513                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6514                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
6515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
6516                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
6517                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
6518                                 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));
6519                         }
6520                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
6521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
6522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
6523                 }
6524         }
6525         return NDR_ERR_SUCCESS;
6526 }
6527
6528 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
6529 {
6530         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
6531         ndr->depth++;
6532         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
6533         ndr->depth++;
6534         if (r->netbios_name) {
6535                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
6536         }
6537         ndr->depth--;
6538         ndr_print_ptr(ndr, "dns_name", r->dns_name);
6539         ndr->depth++;
6540         if (r->dns_name) {
6541                 ndr_print_string(ndr, "dns_name", r->dns_name);
6542         }
6543         ndr->depth--;
6544         ndr_print_ptr(ndr, "site_name", r->site_name);
6545         ndr->depth++;
6546         if (r->site_name) {
6547                 ndr_print_string(ndr, "site_name", r->site_name);
6548         }
6549         ndr->depth--;
6550         ndr_print_ptr(ndr, "site_dn", r->site_dn);
6551         ndr->depth++;
6552         if (r->site_dn) {
6553                 ndr_print_string(ndr, "site_dn", r->site_dn);
6554         }
6555         ndr->depth--;
6556         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
6557         ndr->depth++;
6558         if (r->computer_dn) {
6559                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
6560         }
6561         ndr->depth--;
6562         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6563         ndr->depth++;
6564         if (r->server_dn) {
6565                 ndr_print_string(ndr, "server_dn", r->server_dn);
6566         }
6567         ndr->depth--;
6568         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
6569         ndr->depth++;
6570         if (r->ntds_dn) {
6571                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
6572         }
6573         ndr->depth--;
6574         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
6575         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
6576         ndr_print_uint32(ndr, "is_gc", r->is_gc);
6577         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
6578         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
6579         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
6580         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
6581         ndr->depth--;
6582 }
6583
6584 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
6585 {
6586         uint32_t cntr_array_1;
6587         if (ndr_flags & NDR_SCALARS) {
6588                 NDR_CHECK(ndr_push_align(ndr, 4));
6589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6590                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6591         }
6592         if (ndr_flags & NDR_BUFFERS) {
6593                 if (r->array) {
6594                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6595                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6596                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6597                         }
6598                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6599                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6600                         }
6601                 }
6602         }
6603         return NDR_ERR_SUCCESS;
6604 }
6605
6606 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
6607 {
6608         uint32_t _ptr_array;
6609         uint32_t cntr_array_1;
6610         TALLOC_CTX *_mem_save_array_0;
6611         TALLOC_CTX *_mem_save_array_1;
6612         if (ndr_flags & NDR_SCALARS) {
6613                 NDR_CHECK(ndr_pull_align(ndr, 4));
6614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6615                 if (r->count < 0 || r->count > 10000) {
6616                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6617                 }
6618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6619                 if (_ptr_array) {
6620                         NDR_PULL_ALLOC(ndr, r->array);
6621                 } else {
6622                         r->array = NULL;
6623                 }
6624         }
6625         if (ndr_flags & NDR_BUFFERS) {
6626                 if (r->array) {
6627                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6628                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6629                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6630                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6631                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6632                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6633                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6634                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6635                         }
6636                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6637                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6638                         }
6639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6641                 }
6642                 if (r->array) {
6643                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6644                 }
6645         }
6646         return NDR_ERR_SUCCESS;
6647 }
6648
6649 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
6650 {
6651         uint32_t cntr_array_1;
6652         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
6653         ndr->depth++;
6654         ndr_print_uint32(ndr, "count", r->count);
6655         ndr_print_ptr(ndr, "array", r->array);
6656         ndr->depth++;
6657         if (r->array) {
6658                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6659                 ndr->depth++;
6660                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6661                         char *idx_1=NULL;
6662                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6663                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
6664                                 free(idx_1);
6665                         }
6666                 }
6667                 ndr->depth--;
6668         }
6669         ndr->depth--;
6670         ndr->depth--;
6671 }
6672
6673 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
6674 {
6675         if (ndr_flags & NDR_SCALARS) {
6676                 NDR_CHECK(ndr_push_align(ndr, 4));
6677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
6681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6682                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6683                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
6684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
6687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
6688                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
6689                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
6690                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
6691                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
6692         }
6693         if (ndr_flags & NDR_BUFFERS) {
6694                 if (r->netbios_name) {
6695                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6696                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6698                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6699                 }
6700                 if (r->dns_name) {
6701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6703                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6704                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6705                 }
6706                 if (r->site_name) {
6707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6710                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6711                 }
6712                 if (r->site_dn) {
6713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6716                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6717                 }
6718                 if (r->computer_dn) {
6719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6722                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6723                 }
6724                 if (r->server_dn) {
6725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6728                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6729                 }
6730                 if (r->ntds_dn) {
6731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6734                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6735                 }
6736         }
6737         return NDR_ERR_SUCCESS;
6738 }
6739
6740 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
6741 {
6742         uint32_t _ptr_netbios_name;
6743         TALLOC_CTX *_mem_save_netbios_name_0;
6744         uint32_t _ptr_dns_name;
6745         TALLOC_CTX *_mem_save_dns_name_0;
6746         uint32_t _ptr_site_name;
6747         TALLOC_CTX *_mem_save_site_name_0;
6748         uint32_t _ptr_site_dn;
6749         TALLOC_CTX *_mem_save_site_dn_0;
6750         uint32_t _ptr_computer_dn;
6751         TALLOC_CTX *_mem_save_computer_dn_0;
6752         uint32_t _ptr_server_dn;
6753         TALLOC_CTX *_mem_save_server_dn_0;
6754         uint32_t _ptr_ntds_dn;
6755         TALLOC_CTX *_mem_save_ntds_dn_0;
6756         if (ndr_flags & NDR_SCALARS) {
6757                 NDR_CHECK(ndr_pull_align(ndr, 4));
6758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6759                 if (_ptr_netbios_name) {
6760                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6761                 } else {
6762                         r->netbios_name = NULL;
6763                 }
6764                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6765                 if (_ptr_dns_name) {
6766                         NDR_PULL_ALLOC(ndr, r->dns_name);
6767                 } else {
6768                         r->dns_name = NULL;
6769                 }
6770                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6771                 if (_ptr_site_name) {
6772                         NDR_PULL_ALLOC(ndr, r->site_name);
6773                 } else {
6774                         r->site_name = NULL;
6775                 }
6776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
6777                 if (_ptr_site_dn) {
6778                         NDR_PULL_ALLOC(ndr, r->site_dn);
6779                 } else {
6780                         r->site_dn = NULL;
6781                 }
6782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6783                 if (_ptr_computer_dn) {
6784                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6785                 } else {
6786                         r->computer_dn = NULL;
6787                 }
6788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6789                 if (_ptr_server_dn) {
6790                         NDR_PULL_ALLOC(ndr, r->server_dn);
6791                 } else {
6792                         r->server_dn = NULL;
6793                 }
6794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
6795                 if (_ptr_ntds_dn) {
6796                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
6797                 } else {
6798                         r->ntds_dn = NULL;
6799                 }
6800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
6801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
6802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
6803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
6804                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
6805                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
6806                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
6807                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
6808         }
6809         if (ndr_flags & NDR_BUFFERS) {
6810                 if (r->netbios_name) {
6811                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6812                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
6813                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
6814                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
6815                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
6816                                 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));
6817                         }
6818                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
6819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
6820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
6821                 }
6822                 if (r->dns_name) {
6823                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6824                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
6825                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
6826                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
6827                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
6828                                 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));
6829                         }
6830                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
6831                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
6832                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
6833                 }
6834                 if (r->site_name) {
6835                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6836                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
6837                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
6838                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
6839                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
6840                                 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));
6841                         }
6842                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
6843                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
6844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
6845                 }
6846                 if (r->site_dn) {
6847                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6848                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
6849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
6850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
6851                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
6852                                 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));
6853                         }
6854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
6855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
6856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
6857                 }
6858                 if (r->computer_dn) {
6859                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6860                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
6861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
6862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
6863                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
6864                                 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));
6865                         }
6866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
6867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
6868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
6869                 }
6870                 if (r->server_dn) {
6871                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6872                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6875                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6876                                 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));
6877                         }
6878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6881                 }
6882                 if (r->ntds_dn) {
6883                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6884                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
6885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
6886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
6887                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
6888                                 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));
6889                         }
6890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
6891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
6892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
6893                 }
6894         }
6895         return NDR_ERR_SUCCESS;
6896 }
6897
6898 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
6899 {
6900         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
6901         ndr->depth++;
6902         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
6903         ndr->depth++;
6904         if (r->netbios_name) {
6905                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
6906         }
6907         ndr->depth--;
6908         ndr_print_ptr(ndr, "dns_name", r->dns_name);
6909         ndr->depth++;
6910         if (r->dns_name) {
6911                 ndr_print_string(ndr, "dns_name", r->dns_name);
6912         }
6913         ndr->depth--;
6914         ndr_print_ptr(ndr, "site_name", r->site_name);
6915         ndr->depth++;
6916         if (r->site_name) {
6917                 ndr_print_string(ndr, "site_name", r->site_name);
6918         }
6919         ndr->depth--;
6920         ndr_print_ptr(ndr, "site_dn", r->site_dn);
6921         ndr->depth++;
6922         if (r->site_dn) {
6923                 ndr_print_string(ndr, "site_dn", r->site_dn);
6924         }
6925         ndr->depth--;
6926         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
6927         ndr->depth++;
6928         if (r->computer_dn) {
6929                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
6930         }
6931         ndr->depth--;
6932         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6933         ndr->depth++;
6934         if (r->server_dn) {
6935                 ndr_print_string(ndr, "server_dn", r->server_dn);
6936         }
6937         ndr->depth--;
6938         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
6939         ndr->depth++;
6940         if (r->ntds_dn) {
6941                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
6942         }
6943         ndr->depth--;
6944         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
6945         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
6946         ndr_print_uint32(ndr, "is_gc", r->is_gc);
6947         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
6948         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
6949         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
6950         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
6951         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
6952         ndr->depth--;
6953 }
6954
6955 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
6956 {
6957         uint32_t cntr_array_1;
6958         if (ndr_flags & NDR_SCALARS) {
6959                 NDR_CHECK(ndr_push_align(ndr, 4));
6960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6962         }
6963         if (ndr_flags & NDR_BUFFERS) {
6964                 if (r->array) {
6965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6966                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6967                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6968                         }
6969                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6970                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6971                         }
6972                 }
6973         }
6974         return NDR_ERR_SUCCESS;
6975 }
6976
6977 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
6978 {
6979         uint32_t _ptr_array;
6980         uint32_t cntr_array_1;
6981         TALLOC_CTX *_mem_save_array_0;
6982         TALLOC_CTX *_mem_save_array_1;
6983         if (ndr_flags & NDR_SCALARS) {
6984                 NDR_CHECK(ndr_pull_align(ndr, 4));
6985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6986                 if (r->count < 0 || r->count > 10000) {
6987                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6988                 }
6989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6990                 if (_ptr_array) {
6991                         NDR_PULL_ALLOC(ndr, r->array);
6992                 } else {
6993                         r->array = NULL;
6994                 }
6995         }
6996         if (ndr_flags & NDR_BUFFERS) {
6997                 if (r->array) {
6998                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6999                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7001                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7002                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7003                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7004                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7005                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7006                         }
7007                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7008                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7009                         }
7010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7012                 }
7013                 if (r->array) {
7014                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7015                 }
7016         }
7017         return NDR_ERR_SUCCESS;
7018 }
7019
7020 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7021 {
7022         uint32_t cntr_array_1;
7023         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7024         ndr->depth++;
7025         ndr_print_uint32(ndr, "count", r->count);
7026         ndr_print_ptr(ndr, "array", r->array);
7027         ndr->depth++;
7028         if (r->array) {
7029                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7030                 ndr->depth++;
7031                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7032                         char *idx_1=NULL;
7033                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7034                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7035                                 free(idx_1);
7036                         }
7037                 }
7038                 ndr->depth--;
7039         }
7040         ndr->depth--;
7041         ndr->depth--;
7042 }
7043
7044 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7045 {
7046         if (ndr_flags & NDR_SCALARS) {
7047                 NDR_CHECK(ndr_push_align(ndr, 4));
7048                 {
7049                         uint32_t _flags_save_ipv4address = ndr->flags;
7050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7051                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7052                         ndr->flags = _flags_save_ipv4address;
7053                 }
7054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7060         }
7061         if (ndr_flags & NDR_BUFFERS) {
7062                 if (r->client_account) {
7063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7066                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7067                 }
7068         }
7069         return NDR_ERR_SUCCESS;
7070 }
7071
7072 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
7073 {
7074         uint32_t _ptr_client_account;
7075         TALLOC_CTX *_mem_save_client_account_0;
7076         if (ndr_flags & NDR_SCALARS) {
7077                 NDR_CHECK(ndr_pull_align(ndr, 4));
7078                 {
7079                         uint32_t _flags_save_ipv4address = ndr->flags;
7080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7081                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
7082                         ndr->flags = _flags_save_ipv4address;
7083                 }
7084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
7086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
7087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
7088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
7089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
7090                 if (_ptr_client_account) {
7091                         NDR_PULL_ALLOC(ndr, r->client_account);
7092                 } else {
7093                         r->client_account = NULL;
7094                 }
7095         }
7096         if (ndr_flags & NDR_BUFFERS) {
7097                 if (r->client_account) {
7098                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7099                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
7100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
7101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
7102                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
7103                                 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));
7104                         }
7105                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
7106                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
7107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
7108                 }
7109         }
7110         return NDR_ERR_SUCCESS;
7111 }
7112
7113 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
7114 {
7115         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
7116         ndr->depth++;
7117         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
7118         ndr_print_uint32(ndr, "unknown2", r->unknown2);
7119         ndr_print_uint32(ndr, "connection_time", r->connection_time);
7120         ndr_print_uint32(ndr, "unknown4", r->unknown4);
7121         ndr_print_uint32(ndr, "unknown5", r->unknown5);
7122         ndr_print_uint32(ndr, "unknown6", r->unknown6);
7123         ndr_print_ptr(ndr, "client_account", r->client_account);
7124         ndr->depth++;
7125         if (r->client_account) {
7126                 ndr_print_string(ndr, "client_account", r->client_account);
7127         }
7128         ndr->depth--;
7129         ndr->depth--;
7130 }
7131
7132 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
7133 {
7134         uint32_t cntr_array_1;
7135         if (ndr_flags & NDR_SCALARS) {
7136                 NDR_CHECK(ndr_push_align(ndr, 4));
7137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7139         }
7140         if (ndr_flags & NDR_BUFFERS) {
7141                 if (r->array) {
7142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7143                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7144                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7145                         }
7146                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7147                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7148                         }
7149                 }
7150         }
7151         return NDR_ERR_SUCCESS;
7152 }
7153
7154 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
7155 {
7156         uint32_t _ptr_array;
7157         uint32_t cntr_array_1;
7158         TALLOC_CTX *_mem_save_array_0;
7159         TALLOC_CTX *_mem_save_array_1;
7160         if (ndr_flags & NDR_SCALARS) {
7161                 NDR_CHECK(ndr_pull_align(ndr, 4));
7162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7163                 if (r->count < 0 || r->count > 10000) {
7164                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7165                 }
7166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7167                 if (_ptr_array) {
7168                         NDR_PULL_ALLOC(ndr, r->array);
7169                 } else {
7170                         r->array = NULL;
7171                 }
7172         }
7173         if (ndr_flags & NDR_BUFFERS) {
7174                 if (r->array) {
7175                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7176                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7178                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7179                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7180                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7181                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7182                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7183                         }
7184                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7185                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7186                         }
7187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7189                 }
7190                 if (r->array) {
7191                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7192                 }
7193         }
7194         return NDR_ERR_SUCCESS;
7195 }
7196
7197 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
7198 {
7199         uint32_t cntr_array_1;
7200         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
7201         ndr->depth++;
7202         ndr_print_uint32(ndr, "count", r->count);
7203         ndr_print_ptr(ndr, "array", r->array);
7204         ndr->depth++;
7205         if (r->array) {
7206                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7207                 ndr->depth++;
7208                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7209                         char *idx_1=NULL;
7210                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7211                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
7212                                 free(idx_1);
7213                         }
7214                 }
7215                 ndr->depth--;
7216         }
7217         ndr->depth--;
7218         ndr->depth--;
7219 }
7220
7221 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
7222 {
7223         if (ndr_flags & NDR_SCALARS) {
7224                 int level = ndr_push_get_switch_value(ndr, r);
7225                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
7226                 switch (level) {
7227                         case DRSUAPI_DC_INFO_CTR_1: {
7228                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
7229                         break; }
7230
7231                         case DRSUAPI_DC_INFO_CTR_2: {
7232                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
7233                         break; }
7234
7235                         case DRSUAPI_DC_INFO_CTR_3: {
7236                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
7237                         break; }
7238
7239                         case DRSUAPI_DC_CONNECTION_CTR_01: {
7240                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
7241                         break; }
7242
7243                         default:
7244                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7245                 }
7246         }
7247         if (ndr_flags & NDR_BUFFERS) {
7248                 int level = ndr_push_get_switch_value(ndr, r);
7249                 switch (level) {
7250                         case DRSUAPI_DC_INFO_CTR_1:
7251                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
7252                         break;
7253
7254                         case DRSUAPI_DC_INFO_CTR_2:
7255                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
7256                         break;
7257
7258                         case DRSUAPI_DC_INFO_CTR_3:
7259                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
7260                         break;
7261
7262                         case DRSUAPI_DC_CONNECTION_CTR_01:
7263                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
7264                         break;
7265
7266                         default:
7267                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7268                 }
7269         }
7270         return NDR_ERR_SUCCESS;
7271 }
7272
7273 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
7274 {
7275         int level;
7276         int32_t _level;
7277         level = ndr_pull_get_switch_value(ndr, r);
7278         if (ndr_flags & NDR_SCALARS) {
7279                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
7280                 if (_level != level) {
7281                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7282                 }
7283                 switch (level) {
7284                         case DRSUAPI_DC_INFO_CTR_1: {
7285                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
7286                         break; }
7287
7288                         case DRSUAPI_DC_INFO_CTR_2: {
7289                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
7290                         break; }
7291
7292                         case DRSUAPI_DC_INFO_CTR_3: {
7293                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
7294                         break; }
7295
7296                         case DRSUAPI_DC_CONNECTION_CTR_01: {
7297                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
7298                         break; }
7299
7300                         default:
7301                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7302                 }
7303         }
7304         if (ndr_flags & NDR_BUFFERS) {
7305                 switch (level) {
7306                         case DRSUAPI_DC_INFO_CTR_1:
7307                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
7308                         break;
7309
7310                         case DRSUAPI_DC_INFO_CTR_2:
7311                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
7312                         break;
7313
7314                         case DRSUAPI_DC_INFO_CTR_3:
7315                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
7316                         break;
7317
7318                         case DRSUAPI_DC_CONNECTION_CTR_01:
7319                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
7320                         break;
7321
7322                         default:
7323                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7324                 }
7325         }
7326         return NDR_ERR_SUCCESS;
7327 }
7328
7329 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
7330 {
7331         int level;
7332         level = ndr_print_get_switch_value(ndr, r);
7333         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
7334         switch (level) {
7335                 case DRSUAPI_DC_INFO_CTR_1:
7336                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
7337                 break;
7338
7339                 case DRSUAPI_DC_INFO_CTR_2:
7340                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
7341                 break;
7342
7343                 case DRSUAPI_DC_INFO_CTR_3:
7344                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
7345                 break;
7346
7347                 case DRSUAPI_DC_CONNECTION_CTR_01:
7348                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
7349                 break;
7350
7351                 default:
7352                         ndr_print_bad_level(ndr, name, level);
7353         }
7354 }
7355
7356 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
7357 {
7358         if (ndr_flags & NDR_SCALARS) {
7359                 NDR_CHECK(ndr_push_align(ndr, 4));
7360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
7361                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
7362         }
7363         if (ndr_flags & NDR_BUFFERS) {
7364                 if (r->next_object) {
7365                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
7366                 }
7367                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
7368         }
7369         return NDR_ERR_SUCCESS;
7370 }
7371
7372 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
7373 {
7374         uint32_t _ptr_next_object;
7375         TALLOC_CTX *_mem_save_next_object_0;
7376         if (ndr_flags & NDR_SCALARS) {
7377                 NDR_CHECK(ndr_pull_align(ndr, 4));
7378                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
7379                 if (_ptr_next_object) {
7380                         NDR_PULL_ALLOC(ndr, r->next_object);
7381                 } else {
7382                         r->next_object = NULL;
7383                 }
7384                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
7385         }
7386         if (ndr_flags & NDR_BUFFERS) {
7387                 if (r->next_object) {
7388                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
7389                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
7390                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
7391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
7392                 }
7393                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
7394         }
7395         return NDR_ERR_SUCCESS;
7396 }
7397
7398 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
7399 {
7400         if (ndr_flags & NDR_SCALARS) {
7401                 NDR_CHECK(ndr_push_align(ndr, 4));
7402                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
7403         }
7404         if (ndr_flags & NDR_BUFFERS) {
7405                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
7406         }
7407         return NDR_ERR_SUCCESS;
7408 }
7409
7410 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
7411 {
7412         if (ndr_flags & NDR_SCALARS) {
7413                 NDR_CHECK(ndr_pull_align(ndr, 4));
7414                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
7415         }
7416         if (ndr_flags & NDR_BUFFERS) {
7417                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
7418         }
7419         return NDR_ERR_SUCCESS;
7420 }
7421
7422 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
7423 {
7424         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
7425         ndr->depth++;
7426         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
7427         ndr->depth--;
7428 }
7429
7430 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
7431 {
7432         if (ndr_flags & NDR_SCALARS) {
7433                 int level = ndr_push_get_switch_value(ndr, r);
7434                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
7435                 switch (level) {
7436                         case 2: {
7437                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
7438                         break; }
7439
7440                         default:
7441                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7442                 }
7443         }
7444         if (ndr_flags & NDR_BUFFERS) {
7445                 int level = ndr_push_get_switch_value(ndr, r);
7446                 switch (level) {
7447                         case 2:
7448                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
7449                         break;
7450
7451                         default:
7452                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7453                 }
7454         }
7455         return NDR_ERR_SUCCESS;
7456 }
7457
7458 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
7459 {
7460         int level;
7461         int32_t _level;
7462         level = ndr_pull_get_switch_value(ndr, r);
7463         if (ndr_flags & NDR_SCALARS) {
7464                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
7465                 if (_level != level) {
7466                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7467                 }
7468                 switch (level) {
7469                         case 2: {
7470                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
7471                         break; }
7472
7473                         default:
7474                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7475                 }
7476         }
7477         if (ndr_flags & NDR_BUFFERS) {
7478                 switch (level) {
7479                         case 2:
7480                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
7481                         break;
7482
7483                         default:
7484                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7485                 }
7486         }
7487         return NDR_ERR_SUCCESS;
7488 }
7489
7490 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
7491 {
7492         int level;
7493         level = ndr_print_get_switch_value(ndr, r);
7494         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
7495         switch (level) {
7496                 case 2:
7497                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
7498                 break;
7499
7500                 default:
7501                         ndr_print_bad_level(ndr, name, level);
7502         }
7503 }
7504
7505 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
7506 {
7507         if (ndr_flags & NDR_SCALARS) {
7508                 NDR_CHECK(ndr_push_align(ndr, 4));
7509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
7510                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
7511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7512                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
7513         }
7514         if (ndr_flags & NDR_BUFFERS) {
7515         }
7516         return NDR_ERR_SUCCESS;
7517 }
7518
7519 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
7520 {
7521         if (ndr_flags & NDR_SCALARS) {
7522                 NDR_CHECK(ndr_pull_align(ndr, 4));
7523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
7524                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
7525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7526                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
7527         }
7528         if (ndr_flags & NDR_BUFFERS) {
7529         }
7530         return NDR_ERR_SUCCESS;
7531 }
7532
7533 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
7534 {
7535         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
7536         ndr->depth++;
7537         ndr_print_uint32(ndr, "unknown1", r->unknown1);
7538         ndr_print_WERROR(ndr, "status", r->status);
7539         ndr_print_uint32(ndr, "unknown2", r->unknown2);
7540         ndr_print_uint16(ndr, "unknown3", r->unknown3);
7541         ndr->depth--;
7542 }
7543
7544 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
7545 {
7546         if (ndr_flags & NDR_SCALARS) {
7547                 NDR_CHECK(ndr_push_align(ndr, 4));
7548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
7549                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
7550         }
7551         if (ndr_flags & NDR_BUFFERS) {
7552                 if (r->data) {
7553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
7554                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
7555                 }
7556         }
7557         return NDR_ERR_SUCCESS;
7558 }
7559
7560 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
7561 {
7562         uint32_t _ptr_data;
7563         TALLOC_CTX *_mem_save_data_0;
7564         if (ndr_flags & NDR_SCALARS) {
7565                 NDR_CHECK(ndr_pull_align(ndr, 4));
7566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
7567                 if (r->size < 0 || r->size > 10485760) {
7568                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7569                 }
7570                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
7571                 if (_ptr_data) {
7572                         NDR_PULL_ALLOC(ndr, r->data);
7573                 } else {
7574                         r->data = NULL;
7575                 }
7576         }
7577         if (ndr_flags & NDR_BUFFERS) {
7578                 if (r->data) {
7579                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
7580                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
7581                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
7582                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
7583                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
7584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
7585                 }
7586                 if (r->data) {
7587                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
7588                 }
7589         }
7590         return NDR_ERR_SUCCESS;
7591 }
7592
7593 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
7594 {
7595         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
7596         ndr->depth++;
7597         ndr_print_uint32(ndr, "size", r->size);
7598         ndr_print_ptr(ndr, "data", r->data);
7599         ndr->depth++;
7600         if (r->data) {
7601                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
7602         }
7603         ndr->depth--;
7604         ndr->depth--;
7605 }
7606
7607 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
7608 {
7609         if (ndr_flags & NDR_SCALARS) {
7610                 NDR_CHECK(ndr_push_align(ndr, 4));
7611                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
7612                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
7613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7614                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
7615         }
7616         if (ndr_flags & NDR_BUFFERS) {
7617                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
7618         }
7619         return NDR_ERR_SUCCESS;
7620 }
7621
7622 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
7623 {
7624         if (ndr_flags & NDR_SCALARS) {
7625                 NDR_CHECK(ndr_pull_align(ndr, 4));
7626                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
7627                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
7628                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7629                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
7630         }
7631         if (ndr_flags & NDR_BUFFERS) {
7632                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
7633         }
7634         return NDR_ERR_SUCCESS;
7635 }
7636
7637 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
7638 {
7639         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
7640         ndr->depth++;
7641         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
7642         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
7643         ndr_print_uint32(ndr, "unknown2", r->unknown2);
7644         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
7645         ndr->depth--;
7646 }
7647
7648 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
7649 {
7650         if (ndr_flags & NDR_SCALARS) {
7651                 NDR_CHECK(ndr_push_align(ndr, 4));
7652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
7653                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
7654         }
7655         if (ndr_flags & NDR_BUFFERS) {
7656                 if (r->next) {
7657                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
7658                 }
7659                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
7660         }
7661         return NDR_ERR_SUCCESS;
7662 }
7663
7664 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
7665 {
7666         uint32_t _ptr_next;
7667         TALLOC_CTX *_mem_save_next_0;
7668         if (ndr_flags & NDR_SCALARS) {
7669                 NDR_CHECK(ndr_pull_align(ndr, 4));
7670                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
7671                 if (_ptr_next) {
7672                         NDR_PULL_ALLOC(ndr, r->next);
7673                 } else {
7674                         r->next = NULL;
7675                 }
7676                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
7677         }
7678         if (ndr_flags & NDR_BUFFERS) {
7679                 if (r->next) {
7680                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
7681                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
7682                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
7683                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
7684                 }
7685                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
7686         }
7687         return NDR_ERR_SUCCESS;
7688 }
7689
7690 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
7691 {
7692         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
7693         ndr->depth++;
7694         ndr_print_ptr(ndr, "next", r->next);
7695         ndr->depth++;
7696         if (r->next) {
7697                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
7698         }
7699         ndr->depth--;
7700         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
7701         ndr->depth--;
7702 }
7703
7704 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
7705 {
7706         if (ndr_flags & NDR_SCALARS) {
7707                 NDR_CHECK(ndr_push_align(ndr, 4));
7708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
7709                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
7710                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
7711         }
7712         if (ndr_flags & NDR_BUFFERS) {
7713                 if (r->id) {
7714                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
7715                 }
7716                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
7717         }
7718         return NDR_ERR_SUCCESS;
7719 }
7720
7721 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
7722 {
7723         uint32_t _ptr_id;
7724         TALLOC_CTX *_mem_save_id_0;
7725         if (ndr_flags & NDR_SCALARS) {
7726                 NDR_CHECK(ndr_pull_align(ndr, 4));
7727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
7728                 if (_ptr_id) {
7729                         NDR_PULL_ALLOC(ndr, r->id);
7730                 } else {
7731                         r->id = NULL;
7732                 }
7733                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
7734                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
7735         }
7736         if (ndr_flags & NDR_BUFFERS) {
7737                 if (r->id) {
7738                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
7739                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
7740                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
7741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
7742                 }
7743                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
7744         }
7745         return NDR_ERR_SUCCESS;
7746 }
7747
7748 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
7749 {
7750         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
7751         ndr->depth++;
7752         ndr_print_ptr(ndr, "id", r->id);
7753         ndr->depth++;
7754         if (r->id) {
7755                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
7756         }
7757         ndr->depth--;
7758         ndr_print_WERROR(ndr, "status", r->status);
7759         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
7760         ndr->depth--;
7761 }
7762
7763 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
7764 {
7765         if (ndr_flags & NDR_SCALARS) {
7766                 int level = ndr_push_get_switch_value(ndr, r);
7767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7768                 switch (level) {
7769                         case 1: {
7770                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
7771                         break; }
7772
7773                         case 4: {
7774                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7775                         break; }
7776
7777                         case 5: {
7778                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7779                         break; }
7780
7781                         case 6: {
7782                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7783                         break; }
7784
7785                         case 7: {
7786                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7787                         break; }
7788
7789                         default:
7790                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7791                 }
7792         }
7793         if (ndr_flags & NDR_BUFFERS) {
7794                 int level = ndr_push_get_switch_value(ndr, r);
7795                 switch (level) {
7796                         case 1:
7797                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
7798                         break;
7799
7800                         case 4:
7801                         break;
7802
7803                         case 5:
7804                         break;
7805
7806                         case 6:
7807                         break;
7808
7809                         case 7:
7810                         break;
7811
7812                         default:
7813                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7814                 }
7815         }
7816         return NDR_ERR_SUCCESS;
7817 }
7818
7819 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
7820 {
7821         int level;
7822         uint32_t _level;
7823         level = ndr_pull_get_switch_value(ndr, r);
7824         if (ndr_flags & NDR_SCALARS) {
7825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7826                 if (_level != level) {
7827                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7828                 }
7829                 switch (level) {
7830                         case 1: {
7831                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
7832                         break; }
7833
7834                         case 4: {
7835                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7836                         break; }
7837
7838                         case 5: {
7839                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7840                         break; }
7841
7842                         case 6: {
7843                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7844                         break; }
7845
7846                         case 7: {
7847                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7848                         break; }
7849
7850                         default:
7851                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7852                 }
7853         }
7854         if (ndr_flags & NDR_BUFFERS) {
7855                 switch (level) {
7856                         case 1:
7857                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
7858                         break;
7859
7860                         case 4:
7861                         break;
7862
7863                         case 5:
7864                         break;
7865
7866                         case 6:
7867                         break;
7868
7869                         case 7:
7870                         break;
7871
7872                         default:
7873                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7874                 }
7875         }
7876         return NDR_ERR_SUCCESS;
7877 }
7878
7879 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
7880 {
7881         int level;
7882         level = ndr_print_get_switch_value(ndr, r);
7883         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
7884         switch (level) {
7885                 case 1:
7886                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
7887                 break;
7888
7889                 case 4:
7890                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
7891                 break;
7892
7893                 case 5:
7894                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
7895                 break;
7896
7897                 case 6:
7898                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
7899                 break;
7900
7901                 case 7:
7902                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
7903                 break;
7904
7905                 default:
7906                         ndr_print_bad_level(ndr, name, level);
7907         }
7908 }
7909
7910 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
7911 {
7912         if (ndr_flags & NDR_SCALARS) {
7913                 NDR_CHECK(ndr_push_align(ndr, 4));
7914                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
7915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7916                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
7917         }
7918         if (ndr_flags & NDR_BUFFERS) {
7919                 if (r->info) {
7920                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
7921                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
7922                 }
7923         }
7924         return NDR_ERR_SUCCESS;
7925 }
7926
7927 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
7928 {
7929         uint32_t _ptr_info;
7930         TALLOC_CTX *_mem_save_info_0;
7931         if (ndr_flags & NDR_SCALARS) {
7932                 NDR_CHECK(ndr_pull_align(ndr, 4));
7933                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
7934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7936                 if (_ptr_info) {
7937                         NDR_PULL_ALLOC(ndr, r->info);
7938                 } else {
7939                         r->info = NULL;
7940                 }
7941         }
7942         if (ndr_flags & NDR_BUFFERS) {
7943                 if (r->info) {
7944                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7945                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
7946                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
7947                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
7948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
7949                 }
7950         }
7951         return NDR_ERR_SUCCESS;
7952 }
7953
7954 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
7955 {
7956         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
7957         ndr->depth++;
7958         ndr_print_WERROR(ndr, "status", r->status);
7959         ndr_print_uint32(ndr, "level", r->level);
7960         ndr_print_ptr(ndr, "info", r->info);
7961         ndr->depth++;
7962         if (r->info) {
7963                 ndr_print_set_switch_value(ndr, r->info, r->level);
7964                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
7965         }
7966         ndr->depth--;
7967         ndr->depth--;
7968 }
7969
7970 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
7971 {
7972         if (ndr_flags & NDR_SCALARS) {
7973                 int level = ndr_push_get_switch_value(ndr, r);
7974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7975                 switch (level) {
7976                         case 1: {
7977                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
7978                         break; }
7979
7980                         default:
7981                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7982                 }
7983         }
7984         if (ndr_flags & NDR_BUFFERS) {
7985                 int level = ndr_push_get_switch_value(ndr, r);
7986                 switch (level) {
7987                         case 1:
7988                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
7989                         break;
7990
7991                         default:
7992                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7993                 }
7994         }
7995         return NDR_ERR_SUCCESS;
7996 }
7997
7998 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
7999 {
8000         int level;
8001         uint32_t _level;
8002         level = ndr_pull_get_switch_value(ndr, r);
8003         if (ndr_flags & NDR_SCALARS) {
8004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8005                 if (_level != level) {
8006                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8007                 }
8008                 switch (level) {
8009                         case 1: {
8010                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8011                         break; }
8012
8013                         default:
8014                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8015                 }
8016         }
8017         if (ndr_flags & NDR_BUFFERS) {
8018                 switch (level) {
8019                         case 1:
8020                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8021                         break;
8022
8023                         default:
8024                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8025                 }
8026         }
8027         return NDR_ERR_SUCCESS;
8028 }
8029
8030 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8031 {
8032         int level;
8033         level = ndr_print_get_switch_value(ndr, r);
8034         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8035         switch (level) {
8036                 case 1:
8037                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8038                 break;
8039
8040                 default:
8041                         ndr_print_bad_level(ndr, name, level);
8042         }
8043 }
8044
8045 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8046 {
8047         if (ndr_flags & NDR_SCALARS) {
8048                 NDR_CHECK(ndr_push_align(ndr, 4));
8049                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
8050                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8051         }
8052         if (ndr_flags & NDR_BUFFERS) {
8053                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8054         }
8055         return NDR_ERR_SUCCESS;
8056 }
8057
8058 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
8059 {
8060         if (ndr_flags & NDR_SCALARS) {
8061                 NDR_CHECK(ndr_pull_align(ndr, 4));
8062                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
8063                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8064         }
8065         if (ndr_flags & NDR_BUFFERS) {
8066                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8067         }
8068         return NDR_ERR_SUCCESS;
8069 }
8070
8071 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8072 {
8073         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
8074         ndr->depth++;
8075         ndr_print_GUID(ndr, "guid", &r->guid);
8076         ndr_print_dom_sid28(ndr, "sid", &r->sid);
8077         ndr->depth--;
8078 }
8079
8080 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
8081 {
8082         uint32_t cntr_objects_1;
8083         if (ndr_flags & NDR_SCALARS) {
8084                 NDR_CHECK(ndr_push_align(ndr, 4));
8085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8087                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8089                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
8090         }
8091         if (ndr_flags & NDR_BUFFERS) {
8092                 if (r->id) {
8093                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8094                 }
8095                 if (r->objects) {
8096                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8097                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8098                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8099                         }
8100                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8101                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8102                         }
8103                 }
8104         }
8105         return NDR_ERR_SUCCESS;
8106 }
8107
8108 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
8109 {
8110         uint32_t _ptr_id;
8111         TALLOC_CTX *_mem_save_id_0;
8112         uint32_t _ptr_objects;
8113         uint32_t cntr_objects_1;
8114         TALLOC_CTX *_mem_save_objects_0;
8115         TALLOC_CTX *_mem_save_objects_1;
8116         if (ndr_flags & NDR_SCALARS) {
8117                 NDR_CHECK(ndr_pull_align(ndr, 4));
8118                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8119                 if (_ptr_id) {
8120                         NDR_PULL_ALLOC(ndr, r->id);
8121                 } else {
8122                         r->id = NULL;
8123                 }
8124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8125                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8127                 if (r->count < 0 || r->count > 10000) {
8128                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8129                 }
8130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
8131                 if (_ptr_objects) {
8132                         NDR_PULL_ALLOC(ndr, r->objects);
8133                 } else {
8134                         r->objects = NULL;
8135                 }
8136         }
8137         if (ndr_flags & NDR_BUFFERS) {
8138                 if (r->id) {
8139                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8140                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8141                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8143                 }
8144                 if (r->objects) {
8145                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
8146                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8147                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
8148                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
8149                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
8150                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8151                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8152                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8153                         }
8154                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8155                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8156                         }
8157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
8158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
8159                 }
8160                 if (r->objects) {
8161                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
8162                 }
8163         }
8164         return NDR_ERR_SUCCESS;
8165 }
8166
8167 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
8168 {
8169         uint32_t cntr_objects_1;
8170         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
8171         ndr->depth++;
8172         ndr_print_ptr(ndr, "id", r->id);
8173         ndr->depth++;
8174         if (r->id) {
8175                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8176         }
8177         ndr->depth--;
8178         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8179         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8180         ndr_print_uint32(ndr, "count", r->count);
8181         ndr_print_ptr(ndr, "objects", r->objects);
8182         ndr->depth++;
8183         if (r->objects) {
8184                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
8185                 ndr->depth++;
8186                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
8187                         char *idx_1=NULL;
8188                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
8189                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
8190                                 free(idx_1);
8191                         }
8192                 }
8193                 ndr->depth--;
8194         }
8195         ndr->depth--;
8196         ndr->depth--;
8197 }
8198
8199 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
8200 {
8201         uint32_t cntr_objects_1;
8202         if (ndr_flags & NDR_SCALARS) {
8203                 NDR_CHECK(ndr_push_align(ndr, 4));
8204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
8207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
8209         }
8210         if (ndr_flags & NDR_BUFFERS) {
8211                 if (r->id) {
8212                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8213                 }
8214                 if (r->error) {
8215                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
8216                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
8217                 }
8218                 if (r->objects) {
8219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8220                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8221                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8222                         }
8223                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8224                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8225                         }
8226                 }
8227         }
8228         return NDR_ERR_SUCCESS;
8229 }
8230
8231 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
8232 {
8233         uint32_t _ptr_id;
8234         TALLOC_CTX *_mem_save_id_0;
8235         uint32_t _ptr_error;
8236         TALLOC_CTX *_mem_save_error_0;
8237         uint32_t _ptr_objects;
8238         uint32_t cntr_objects_1;
8239         TALLOC_CTX *_mem_save_objects_0;
8240         TALLOC_CTX *_mem_save_objects_1;
8241         if (ndr_flags & NDR_SCALARS) {
8242                 NDR_CHECK(ndr_pull_align(ndr, 4));
8243                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8244                 if (_ptr_id) {
8245                         NDR_PULL_ALLOC(ndr, r->id);
8246                 } else {
8247                         r->id = NULL;
8248                 }
8249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
8251                 if (_ptr_error) {
8252                         NDR_PULL_ALLOC(ndr, r->error);
8253                 } else {
8254                         r->error = NULL;
8255                 }
8256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8257                 if (r->count < 0 || r->count > 10000) {
8258                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8259                 }
8260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
8261                 if (_ptr_objects) {
8262                         NDR_PULL_ALLOC(ndr, r->objects);
8263                 } else {
8264                         r->objects = NULL;
8265                 }
8266         }
8267         if (ndr_flags & NDR_BUFFERS) {
8268                 if (r->id) {
8269                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8270                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8271                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8273                 }
8274                 if (r->error) {
8275                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
8276                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
8277                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
8278                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
8279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
8280                 }
8281                 if (r->objects) {
8282                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
8283                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8284                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
8285                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
8286                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
8287                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8288                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8289                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8290                         }
8291                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8292                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8293                         }
8294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
8295                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
8296                 }
8297                 if (r->objects) {
8298                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
8299                 }
8300         }
8301         return NDR_ERR_SUCCESS;
8302 }
8303
8304 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
8305 {
8306         uint32_t cntr_objects_1;
8307         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
8308         ndr->depth++;
8309         ndr_print_ptr(ndr, "id", r->id);
8310         ndr->depth++;
8311         if (r->id) {
8312                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8313         }
8314         ndr->depth--;
8315         ndr_print_uint32(ndr, "level", r->level);
8316         ndr_print_ptr(ndr, "error", r->error);
8317         ndr->depth++;
8318         if (r->error) {
8319                 ndr_print_set_switch_value(ndr, r->error, r->level);
8320                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
8321         }
8322         ndr->depth--;
8323         ndr_print_uint32(ndr, "count", r->count);
8324         ndr_print_ptr(ndr, "objects", r->objects);
8325         ndr->depth++;
8326         if (r->objects) {
8327                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
8328                 ndr->depth++;
8329                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
8330                         char *idx_1=NULL;
8331                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
8332                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
8333                                 free(idx_1);
8334                         }
8335                 }
8336                 ndr->depth--;
8337         }
8338         ndr->depth--;
8339         ndr->depth--;
8340 }
8341
8342 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
8343 {
8344         if (ndr_flags & NDR_SCALARS) {
8345                 int level = ndr_push_get_switch_value(ndr, r);
8346                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8347                 switch (level) {
8348                         case 2: {
8349                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
8350                         break; }
8351
8352                         case 3: {
8353                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
8354                         break; }
8355
8356                         default:
8357                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8358                 }
8359         }
8360         if (ndr_flags & NDR_BUFFERS) {
8361                 int level = ndr_push_get_switch_value(ndr, r);
8362                 switch (level) {
8363                         case 2:
8364                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8365                         break;
8366
8367                         case 3:
8368                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8369                         break;
8370
8371                         default:
8372                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8373                 }
8374         }
8375         return NDR_ERR_SUCCESS;
8376 }
8377
8378 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
8379 {
8380         int level;
8381         int32_t _level;
8382         level = ndr_pull_get_switch_value(ndr, r);
8383         if (ndr_flags & NDR_SCALARS) {
8384                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8385                 if (_level != level) {
8386                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8387                 }
8388                 switch (level) {
8389                         case 2: {
8390                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
8391                         break; }
8392
8393                         case 3: {
8394                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
8395                         break; }
8396
8397                         default:
8398                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8399                 }
8400         }
8401         if (ndr_flags & NDR_BUFFERS) {
8402                 switch (level) {
8403                         case 2:
8404                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8405                         break;
8406
8407                         case 3:
8408                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8409                         break;
8410
8411                         default:
8412                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8413                 }
8414         }
8415         return NDR_ERR_SUCCESS;
8416 }
8417
8418 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
8419 {
8420         int level;
8421         level = ndr_print_get_switch_value(ndr, r);
8422         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
8423         switch (level) {
8424                 case 2:
8425                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
8426                 break;
8427
8428                 case 3:
8429                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
8430                 break;
8431
8432                 default:
8433                         ndr_print_bad_level(ndr, name, level);
8434         }
8435 }
8436
8437 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
8438 {
8439         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8440         return NDR_ERR_SUCCESS;
8441 }
8442
8443 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
8444 {
8445         uint32_t v;
8446         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8447         *r = v;
8448         return NDR_ERR_SUCCESS;
8449 }
8450
8451 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
8452 {
8453         const char *val = NULL;
8454
8455         switch (r) {
8456                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
8457                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
8458         }
8459         ndr_print_enum(ndr, name, "ENUM", val, r);
8460 }
8461
8462 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
8463 {
8464         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8465         return NDR_ERR_SUCCESS;
8466 }
8467
8468 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
8469 {
8470         uint32_t v;
8471         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8472         *r = v;
8473         return NDR_ERR_SUCCESS;
8474 }
8475
8476 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
8477 {
8478         const char *val = NULL;
8479
8480         switch (r) {
8481                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
8482                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
8483                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
8484                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
8485                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
8486                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
8487                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
8488                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
8489                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
8490                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
8491                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
8492                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
8493                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
8494                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
8495                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
8496         }
8497         ndr_print_enum(ndr, name, "ENUM", val, r);
8498 }
8499
8500 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
8501 {
8502         if (ndr_flags & NDR_SCALARS) {
8503                 NDR_CHECK(ndr_push_align(ndr, 4));
8504                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
8505                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
8506                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
8507         }
8508         if (ndr_flags & NDR_BUFFERS) {
8509                 if (r->object_dn) {
8510                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
8511                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8512                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
8513                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8514                 }
8515         }
8516         return NDR_ERR_SUCCESS;
8517 }
8518
8519 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
8520 {
8521         uint32_t _ptr_object_dn;
8522         TALLOC_CTX *_mem_save_object_dn_0;
8523         if (ndr_flags & NDR_SCALARS) {
8524                 NDR_CHECK(ndr_pull_align(ndr, 4));
8525                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
8526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
8527                 if (_ptr_object_dn) {
8528                         NDR_PULL_ALLOC(ndr, r->object_dn);
8529                 } else {
8530                         r->object_dn = NULL;
8531                 }
8532                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
8533         }
8534         if (ndr_flags & NDR_BUFFERS) {
8535                 if (r->object_dn) {
8536                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
8537                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
8538                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
8539                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
8540                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
8541                                 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));
8542                         }
8543                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
8544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
8545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
8546                 }
8547         }
8548         return NDR_ERR_SUCCESS;
8549 }
8550
8551 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
8552 {
8553         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
8554         ndr->depth++;
8555         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
8556         ndr_print_ptr(ndr, "object_dn", r->object_dn);
8557         ndr->depth++;
8558         if (r->object_dn) {
8559                 ndr_print_string(ndr, "object_dn", r->object_dn);
8560         }
8561         ndr->depth--;
8562         ndr_print_GUID(ndr, "guid1", &r->guid1);
8563         ndr->depth--;
8564 }
8565
8566 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
8567 {
8568         if (ndr_flags & NDR_SCALARS) {
8569                 NDR_CHECK(ndr_push_align(ndr, 4));
8570                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
8571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
8572                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
8573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
8575                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
8576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8577         }
8578         if (ndr_flags & NDR_BUFFERS) {
8579                 if (r->object_dn) {
8580                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
8581                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8582                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
8583                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8584                 }
8585                 if (r->string1) {
8586                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
8587                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
8589                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8590                 }
8591                 if (r->string2) {
8592                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
8593                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8594                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
8595                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8596                 }
8597         }
8598         return NDR_ERR_SUCCESS;
8599 }
8600
8601 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
8602 {
8603         uint32_t _ptr_object_dn;
8604         TALLOC_CTX *_mem_save_object_dn_0;
8605         uint32_t _ptr_string1;
8606         TALLOC_CTX *_mem_save_string1_0;
8607         uint32_t _ptr_string2;
8608         TALLOC_CTX *_mem_save_string2_0;
8609         if (ndr_flags & NDR_SCALARS) {
8610                 NDR_CHECK(ndr_pull_align(ndr, 4));
8611                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
8612                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
8613                 if (_ptr_object_dn) {
8614                         NDR_PULL_ALLOC(ndr, r->object_dn);
8615                 } else {
8616                         r->object_dn = NULL;
8617                 }
8618                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
8619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
8621                 if (_ptr_string1) {
8622                         NDR_PULL_ALLOC(ndr, r->string1);
8623                 } else {
8624                         r->string1 = NULL;
8625                 }
8626                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
8627                 if (_ptr_string2) {
8628                         NDR_PULL_ALLOC(ndr, r->string2);
8629                 } else {
8630                         r->string2 = NULL;
8631                 }
8632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8633         }
8634         if (ndr_flags & NDR_BUFFERS) {
8635                 if (r->object_dn) {
8636                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
8637                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
8638                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
8639                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
8640                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
8641                                 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));
8642                         }
8643                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
8644                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
8645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
8646                 }
8647                 if (r->string1) {
8648                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
8649                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
8650                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
8651                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
8652                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
8653                                 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));
8654                         }
8655                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
8656                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
8657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
8658                 }
8659                 if (r->string2) {
8660                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
8661                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
8662                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
8663                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
8664                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
8665                                 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));
8666                         }
8667                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
8668                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
8669                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
8670                 }
8671         }
8672         return NDR_ERR_SUCCESS;
8673 }
8674
8675 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
8676 {
8677         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
8678         ndr->depth++;
8679         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
8680         ndr_print_ptr(ndr, "object_dn", r->object_dn);
8681         ndr->depth++;
8682         if (r->object_dn) {
8683                 ndr_print_string(ndr, "object_dn", r->object_dn);
8684         }
8685         ndr->depth--;
8686         ndr_print_GUID(ndr, "guid1", &r->guid1);
8687         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8688         ndr_print_ptr(ndr, "string1", r->string1);
8689         ndr->depth++;
8690         if (r->string1) {
8691                 ndr_print_string(ndr, "string1", r->string1);
8692         }
8693         ndr->depth--;
8694         ndr_print_ptr(ndr, "string2", r->string2);
8695         ndr->depth++;
8696         if (r->string2) {
8697                 ndr_print_string(ndr, "string2", r->string2);
8698         }
8699         ndr->depth--;
8700         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8701         ndr->depth--;
8702 }
8703
8704 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
8705 {
8706         if (ndr_flags & NDR_SCALARS) {
8707                 int level = ndr_push_get_switch_value(ndr, r);
8708                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
8709                 switch (level) {
8710                         case DRSUAPI_DS_REPLICA_GET_INFO: {
8711                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
8712                         break; }
8713
8714                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
8715                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
8716                         break; }
8717
8718                         default:
8719                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8720                 }
8721         }
8722         if (ndr_flags & NDR_BUFFERS) {
8723                 int level = ndr_push_get_switch_value(ndr, r);
8724                 switch (level) {
8725                         case DRSUAPI_DS_REPLICA_GET_INFO:
8726                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
8727                         break;
8728
8729                         case DRSUAPI_DS_REPLICA_GET_INFO2:
8730                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
8731                         break;
8732
8733                         default:
8734                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8735                 }
8736         }
8737         return NDR_ERR_SUCCESS;
8738 }
8739
8740 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
8741 {
8742         int level;
8743         uint32_t _level;
8744         level = ndr_pull_get_switch_value(ndr, r);
8745         if (ndr_flags & NDR_SCALARS) {
8746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8747                 if (_level != level) {
8748                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8749                 }
8750                 switch (level) {
8751                         case DRSUAPI_DS_REPLICA_GET_INFO: {
8752                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
8753                         break; }
8754
8755                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
8756                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
8757                         break; }
8758
8759                         default:
8760                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8761                 }
8762         }
8763         if (ndr_flags & NDR_BUFFERS) {
8764                 switch (level) {
8765                         case DRSUAPI_DS_REPLICA_GET_INFO:
8766                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
8767                         break;
8768
8769                         case DRSUAPI_DS_REPLICA_GET_INFO2:
8770                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
8771                         break;
8772
8773                         default:
8774                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8775                 }
8776         }
8777         return NDR_ERR_SUCCESS;
8778 }
8779
8780 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
8781 {
8782         int level;
8783         level = ndr_print_get_switch_value(ndr, r);
8784         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
8785         switch (level) {
8786                 case DRSUAPI_DS_REPLICA_GET_INFO:
8787                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
8788                 break;
8789
8790                 case DRSUAPI_DS_REPLICA_GET_INFO2:
8791                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
8792                 break;
8793
8794                 default:
8795                         ndr_print_bad_level(ndr, name, level);
8796         }
8797 }
8798
8799 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
8800 {
8801         if (ndr_flags & NDR_SCALARS) {
8802                 NDR_CHECK(ndr_push_align(ndr, 8));
8803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
8804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
8805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
8806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
8807                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
8808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
8809                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
8810                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
8811                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
8812                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
8813                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
8814                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
8815                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
8816                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
8817                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
8818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
8819         }
8820         if (ndr_flags & NDR_BUFFERS) {
8821                 if (r->naming_context_dn) {
8822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
8823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
8825                         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));
8826                 }
8827                 if (r->source_dsa_obj_dn) {
8828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
8829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8830                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
8831                         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));
8832                 }
8833                 if (r->source_dsa_address) {
8834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
8835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8836                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
8837                         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));
8838                 }
8839                 if (r->transport_obj_dn) {
8840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
8841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8842                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
8843                         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));
8844                 }
8845         }
8846         return NDR_ERR_SUCCESS;
8847 }
8848
8849 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
8850 {
8851         uint32_t _ptr_naming_context_dn;
8852         TALLOC_CTX *_mem_save_naming_context_dn_0;
8853         uint32_t _ptr_source_dsa_obj_dn;
8854         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
8855         uint32_t _ptr_source_dsa_address;
8856         TALLOC_CTX *_mem_save_source_dsa_address_0;
8857         uint32_t _ptr_transport_obj_dn;
8858         TALLOC_CTX *_mem_save_transport_obj_dn_0;
8859         if (ndr_flags & NDR_SCALARS) {
8860                 NDR_CHECK(ndr_pull_align(ndr, 8));
8861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
8862                 if (_ptr_naming_context_dn) {
8863                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
8864                 } else {
8865                         r->naming_context_dn = NULL;
8866                 }
8867                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
8868                 if (_ptr_source_dsa_obj_dn) {
8869                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
8870                 } else {
8871                         r->source_dsa_obj_dn = NULL;
8872                 }
8873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
8874                 if (_ptr_source_dsa_address) {
8875                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
8876                 } else {
8877                         r->source_dsa_address = NULL;
8878                 }
8879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
8880                 if (_ptr_transport_obj_dn) {
8881                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
8882                 } else {
8883                         r->transport_obj_dn = NULL;
8884                 }
8885                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
8886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
8887                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
8888                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
8889                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
8890                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
8891                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
8892                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
8893                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
8894                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
8895                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
8896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
8897         }
8898         if (ndr_flags & NDR_BUFFERS) {
8899                 if (r->naming_context_dn) {
8900                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
8901                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
8902                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
8903                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
8904                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
8905                                 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));
8906                         }
8907                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
8908                         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));
8909                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
8910                 }
8911                 if (r->source_dsa_obj_dn) {
8912                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
8913                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
8914                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
8915                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
8916                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
8917                                 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));
8918                         }
8919                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
8920                         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));
8921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
8922                 }
8923                 if (r->source_dsa_address) {
8924                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
8925                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
8926                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
8927                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
8928                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
8929                                 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));
8930                         }
8931                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
8932                         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));
8933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
8934                 }
8935                 if (r->transport_obj_dn) {
8936                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
8937                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
8938                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
8939                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
8940                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
8941                                 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));
8942                         }
8943                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
8944                         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));
8945                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
8946                 }
8947         }
8948         return NDR_ERR_SUCCESS;
8949 }
8950
8951 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
8952 {
8953         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
8954         ndr->depth++;
8955         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
8956         ndr->depth++;
8957         if (r->naming_context_dn) {
8958                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
8959         }
8960         ndr->depth--;
8961         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
8962         ndr->depth++;
8963         if (r->source_dsa_obj_dn) {
8964                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
8965         }
8966         ndr->depth--;
8967         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
8968         ndr->depth++;
8969         if (r->source_dsa_address) {
8970                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
8971         }
8972         ndr->depth--;
8973         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
8974         ndr->depth++;
8975         if (r->transport_obj_dn) {
8976                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
8977         }
8978         ndr->depth--;
8979         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
8980         ndr_print_uint32(ndr, "reserved", r->reserved);
8981         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
8982         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
8983         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
8984         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
8985         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
8986         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
8987         ndr_print_NTTIME(ndr, "last_success", r->last_success);
8988         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
8989         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
8990         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
8991         ndr->depth--;
8992 }
8993
8994 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
8995 {
8996         uint32_t cntr_array_0;
8997         if (ndr_flags & NDR_SCALARS) {
8998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8999                 NDR_CHECK(ndr_push_align(ndr, 8));
9000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9002                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9003                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9004                 }
9005         }
9006         if (ndr_flags & NDR_BUFFERS) {
9007                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9008                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9009                 }
9010         }
9011         return NDR_ERR_SUCCESS;
9012 }
9013
9014 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
9015 {
9016         uint32_t cntr_array_0;
9017         TALLOC_CTX *_mem_save_array_0;
9018         if (ndr_flags & NDR_SCALARS) {
9019                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9020                 NDR_CHECK(ndr_pull_align(ndr, 8));
9021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9023                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9024                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9025                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9026                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9027                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9028                 }
9029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9030                 if (r->array) {
9031                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9032                 }
9033         }
9034         if (ndr_flags & NDR_BUFFERS) {
9035                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9036                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9037                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9038                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9039                 }
9040                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9041         }
9042         return NDR_ERR_SUCCESS;
9043 }
9044
9045 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
9046 {
9047         uint32_t cntr_array_0;
9048         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
9049         ndr->depth++;
9050         ndr_print_uint32(ndr, "count", r->count);
9051         ndr_print_uint32(ndr, "reserved", r->reserved);
9052         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9053         ndr->depth++;
9054         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9055                 char *idx_0=NULL;
9056                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9057                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
9058                         free(idx_0);
9059                 }
9060         }
9061         ndr->depth--;
9062         ndr->depth--;
9063 }
9064
9065 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
9066 {
9067         uint32_t cntr_array_0;
9068         if (ndr_flags & NDR_SCALARS) {
9069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9070                 NDR_CHECK(ndr_push_align(ndr, 8));
9071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9073                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9074                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9075                 }
9076         }
9077         if (ndr_flags & NDR_BUFFERS) {
9078         }
9079         return NDR_ERR_SUCCESS;
9080 }
9081
9082 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
9083 {
9084         uint32_t cntr_array_0;
9085         TALLOC_CTX *_mem_save_array_0;
9086         if (ndr_flags & NDR_SCALARS) {
9087                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9088                 NDR_CHECK(ndr_pull_align(ndr, 8));
9089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9091                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9092                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9093                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9094                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9095                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9096                 }
9097                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9098                 if (r->array) {
9099                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9100                 }
9101         }
9102         if (ndr_flags & NDR_BUFFERS) {
9103         }
9104         return NDR_ERR_SUCCESS;
9105 }
9106
9107 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
9108 {
9109         uint32_t cntr_array_0;
9110         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
9111         ndr->depth++;
9112         ndr_print_uint32(ndr, "count", r->count);
9113         ndr_print_uint32(ndr, "reserved", r->reserved);
9114         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9115         ndr->depth++;
9116         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9117                 char *idx_0=NULL;
9118                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9119                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
9120                         free(idx_0);
9121                 }
9122         }
9123         ndr->depth--;
9124         ndr->depth--;
9125 }
9126
9127 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
9128 {
9129         if (ndr_flags & NDR_SCALARS) {
9130                 NDR_CHECK(ndr_push_align(ndr, 8));
9131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
9132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
9133                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
9134                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9135                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
9136                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
9137         }
9138         if (ndr_flags & NDR_BUFFERS) {
9139                 if (r->attribute_name) {
9140                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9143                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9144                 }
9145         }
9146         return NDR_ERR_SUCCESS;
9147 }
9148
9149 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
9150 {
9151         uint32_t _ptr_attribute_name;
9152         TALLOC_CTX *_mem_save_attribute_name_0;
9153         if (ndr_flags & NDR_SCALARS) {
9154                 NDR_CHECK(ndr_pull_align(ndr, 8));
9155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
9156                 if (_ptr_attribute_name) {
9157                         NDR_PULL_ALLOC(ndr, r->attribute_name);
9158                 } else {
9159                         r->attribute_name = NULL;
9160                 }
9161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
9162                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
9163                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9164                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
9165                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
9166         }
9167         if (ndr_flags & NDR_BUFFERS) {
9168                 if (r->attribute_name) {
9169                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9170                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
9171                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
9172                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
9173                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
9174                                 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));
9175                         }
9176                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
9177                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
9178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
9179                 }
9180         }
9181         return NDR_ERR_SUCCESS;
9182 }
9183
9184 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
9185 {
9186         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
9187         ndr->depth++;
9188         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
9189         ndr->depth++;
9190         if (r->attribute_name) {
9191                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
9192         }
9193         ndr->depth--;
9194         ndr_print_uint32(ndr, "version", r->version);
9195         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
9196         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
9197         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
9198         ndr_print_hyper(ndr, "local_usn", r->local_usn);
9199         ndr->depth--;
9200 }
9201
9202 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
9203 {
9204         uint32_t cntr_array_0;
9205         if (ndr_flags & NDR_SCALARS) {
9206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9207                 NDR_CHECK(ndr_push_align(ndr, 8));
9208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9210                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9211                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9212                 }
9213         }
9214         if (ndr_flags & NDR_BUFFERS) {
9215                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9216                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9217                 }
9218         }
9219         return NDR_ERR_SUCCESS;
9220 }
9221
9222 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
9223 {
9224         uint32_t cntr_array_0;
9225         TALLOC_CTX *_mem_save_array_0;
9226         if (ndr_flags & NDR_SCALARS) {
9227                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9228                 NDR_CHECK(ndr_pull_align(ndr, 8));
9229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9231                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9232                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9233                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9234                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9235                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9236                 }
9237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9238                 if (r->array) {
9239                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9240                 }
9241         }
9242         if (ndr_flags & NDR_BUFFERS) {
9243                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9245                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9246                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9247                 }
9248                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9249         }
9250         return NDR_ERR_SUCCESS;
9251 }
9252
9253 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
9254 {
9255         uint32_t cntr_array_0;
9256         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
9257         ndr->depth++;
9258         ndr_print_uint32(ndr, "count", r->count);
9259         ndr_print_uint32(ndr, "reserved", r->reserved);
9260         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9261         ndr->depth++;
9262         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9263                 char *idx_0=NULL;
9264                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9265                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
9266                         free(idx_0);
9267                 }
9268         }
9269         ndr->depth--;
9270         ndr->depth--;
9271 }
9272
9273 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
9274 {
9275         if (ndr_flags & NDR_SCALARS) {
9276                 NDR_CHECK(ndr_push_align(ndr, 4));
9277                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
9278                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
9279                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
9280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
9281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
9282         }
9283         if (ndr_flags & NDR_BUFFERS) {
9284                 if (r->dsa_obj_dn) {
9285                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
9286                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9287                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
9288                         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));
9289                 }
9290         }
9291         return NDR_ERR_SUCCESS;
9292 }
9293
9294 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
9295 {
9296         uint32_t _ptr_dsa_obj_dn;
9297         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
9298         if (ndr_flags & NDR_SCALARS) {
9299                 NDR_CHECK(ndr_pull_align(ndr, 4));
9300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
9301                 if (_ptr_dsa_obj_dn) {
9302                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
9303                 } else {
9304                         r->dsa_obj_dn = NULL;
9305                 }
9306                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
9307                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
9308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
9309                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
9310         }
9311         if (ndr_flags & NDR_BUFFERS) {
9312                 if (r->dsa_obj_dn) {
9313                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9314                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
9315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
9316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
9317                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
9318                                 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));
9319                         }
9320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
9321                         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));
9322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
9323                 }
9324         }
9325         return NDR_ERR_SUCCESS;
9326 }
9327
9328 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
9329 {
9330         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
9331         ndr->depth++;
9332         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
9333         ndr->depth++;
9334         if (r->dsa_obj_dn) {
9335                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
9336         }
9337         ndr->depth--;
9338         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
9339         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
9340         ndr_print_uint32(ndr, "num_failures", r->num_failures);
9341         ndr_print_WERROR(ndr, "last_result", r->last_result);
9342         ndr->depth--;
9343 }
9344
9345 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
9346 {
9347         uint32_t cntr_array_0;
9348         if (ndr_flags & NDR_SCALARS) {
9349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9350                 NDR_CHECK(ndr_push_align(ndr, 4));
9351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9353                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9354                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9355                 }
9356         }
9357         if (ndr_flags & NDR_BUFFERS) {
9358                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9359                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9360                 }
9361         }
9362         return NDR_ERR_SUCCESS;
9363 }
9364
9365 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
9366 {
9367         uint32_t cntr_array_0;
9368         TALLOC_CTX *_mem_save_array_0;
9369         if (ndr_flags & NDR_SCALARS) {
9370                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9371                 NDR_CHECK(ndr_pull_align(ndr, 4));
9372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9374                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9375                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9376                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9377                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9378                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9379                 }
9380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9381                 if (r->array) {
9382                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9383                 }
9384         }
9385         if (ndr_flags & NDR_BUFFERS) {
9386                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9387                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9388                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9389                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9390                 }
9391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9392         }
9393         return NDR_ERR_SUCCESS;
9394 }
9395
9396 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
9397 {
9398         uint32_t cntr_array_0;
9399         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
9400         ndr->depth++;
9401         ndr_print_uint32(ndr, "count", r->count);
9402         ndr_print_uint32(ndr, "reserved", r->reserved);
9403         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9404         ndr->depth++;
9405         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9406                 char *idx_0=NULL;
9407                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9408                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
9409                         free(idx_0);
9410                 }
9411         }
9412         ndr->depth--;
9413         ndr->depth--;
9414 }
9415
9416 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
9417 {
9418         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
9419         return NDR_ERR_SUCCESS;
9420 }
9421
9422 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
9423 {
9424         uint16_t v;
9425         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
9426         *r = v;
9427         return NDR_ERR_SUCCESS;
9428 }
9429
9430 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
9431 {
9432         const char *val = NULL;
9433
9434         switch (r) {
9435                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
9436                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
9437                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
9438                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
9439                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
9440         }
9441         ndr_print_enum(ndr, name, "ENUM", val, r);
9442 }
9443
9444 static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
9445 {
9446         if (ndr_flags & NDR_SCALARS) {
9447                 int level = ndr_push_get_switch_value(ndr, r);
9448                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
9449                 switch (level) {
9450                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
9451                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
9452                         break; }
9453
9454                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
9455                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
9456                         break; }
9457
9458                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
9459                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
9460                         break; }
9461
9462                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
9463                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
9464                         break; }
9465
9466                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
9467                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
9468                         break; }
9469
9470                         default: {
9471                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
9472                         break; }
9473
9474                 }
9475         }
9476         if (ndr_flags & NDR_BUFFERS) {
9477                 int level = ndr_push_get_switch_value(ndr, r);
9478                 switch (level) {
9479                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
9480                         break;
9481
9482                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
9483                         break;
9484
9485                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
9486                         break;
9487
9488                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
9489                         break;
9490
9491                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
9492                         break;
9493
9494                         default:
9495                         break;
9496
9497                 }
9498         }
9499         return NDR_ERR_SUCCESS;
9500 }
9501
9502 static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
9503 {
9504         int level;
9505         uint16_t _level;
9506         level = ndr_pull_get_switch_value(ndr, r);
9507         if (ndr_flags & NDR_SCALARS) {
9508                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
9509                 if (_level != level) {
9510                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9511                 }
9512                 switch (level) {
9513                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
9514                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
9515                         break; }
9516
9517                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
9518                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
9519                         break; }
9520
9521                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
9522                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
9523                         break; }
9524
9525                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
9526                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
9527                         break; }
9528
9529                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
9530                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
9531                         break; }
9532
9533                         default: {
9534                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
9535                         break; }
9536
9537                 }
9538         }
9539         if (ndr_flags & NDR_BUFFERS) {
9540                 switch (level) {
9541                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
9542                         break;
9543
9544                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
9545                         break;
9546
9547                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
9548                         break;
9549
9550                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
9551                         break;
9552
9553                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
9554                         break;
9555
9556                         default:
9557                         break;
9558
9559                 }
9560         }
9561         return NDR_ERR_SUCCESS;
9562 }
9563
9564 _PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
9565 {
9566         int level;
9567         level = ndr_print_get_switch_value(ndr, r);
9568         ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
9569         switch (level) {
9570                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
9571                         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
9572                 break;
9573
9574                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
9575                         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
9576                 break;
9577
9578                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
9579                         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
9580                 break;
9581
9582                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
9583                         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
9584                 break;
9585
9586                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
9587                         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
9588                 break;
9589
9590                 default:
9591                         ndr_print_uint32(ndr, "unknown", r->unknown);
9592                 break;
9593
9594         }
9595 }
9596
9597 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
9598 {
9599         if (ndr_flags & NDR_SCALARS) {
9600                 NDR_CHECK(ndr_push_align(ndr, 4));
9601                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
9602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
9603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
9604                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
9605                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
9606                 NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
9607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
9608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
9609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
9610                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
9611                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
9612         }
9613         if (ndr_flags & NDR_BUFFERS) {
9614                 if (r->nc_dn) {
9615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
9616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
9618                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9619                 }
9620                 if (r->remote_dsa_obj_dn) {
9621                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
9622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
9624                         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));
9625                 }
9626                 if (r->remote_dsa_address) {
9627                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
9628                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9629                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
9630                         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));
9631                 }
9632         }
9633         return NDR_ERR_SUCCESS;
9634 }
9635
9636 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
9637 {
9638         uint32_t _ptr_nc_dn;
9639         TALLOC_CTX *_mem_save_nc_dn_0;
9640         uint32_t _ptr_remote_dsa_obj_dn;
9641         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
9642         uint32_t _ptr_remote_dsa_address;
9643         TALLOC_CTX *_mem_save_remote_dsa_address_0;
9644         if (ndr_flags & NDR_SCALARS) {
9645                 NDR_CHECK(ndr_pull_align(ndr, 4));
9646                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
9647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
9648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
9649                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
9650                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
9651                 NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
9652                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
9653                 if (_ptr_nc_dn) {
9654                         NDR_PULL_ALLOC(ndr, r->nc_dn);
9655                 } else {
9656                         r->nc_dn = NULL;
9657                 }
9658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
9659                 if (_ptr_remote_dsa_obj_dn) {
9660                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
9661                 } else {
9662                         r->remote_dsa_obj_dn = NULL;
9663                 }
9664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
9665                 if (_ptr_remote_dsa_address) {
9666                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
9667                 } else {
9668                         r->remote_dsa_address = NULL;
9669                 }
9670                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
9671                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
9672         }
9673         if (ndr_flags & NDR_BUFFERS) {
9674                 if (r->nc_dn) {
9675                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9676                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
9677                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
9678                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
9679                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
9680                                 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));
9681                         }
9682                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
9683                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
9684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
9685                 }
9686                 if (r->remote_dsa_obj_dn) {
9687                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9688                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
9689                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
9690                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
9691                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
9692                                 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));
9693                         }
9694                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
9695                         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));
9696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
9697                 }
9698                 if (r->remote_dsa_address) {
9699                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
9700                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
9701                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
9702                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
9703                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
9704                                 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));
9705                         }
9706                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
9707                         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));
9708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
9709                 }
9710         }
9711         return NDR_ERR_SUCCESS;
9712 }
9713
9714 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
9715 {
9716         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
9717         ndr->depth++;
9718         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
9719         ndr_print_uint32(ndr, "serial_num", r->serial_num);
9720         ndr_print_uint32(ndr, "priority", r->priority);
9721         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
9722         ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
9723         ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
9724         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
9725         ndr->depth++;
9726         if (r->nc_dn) {
9727                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
9728         }
9729         ndr->depth--;
9730         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
9731         ndr->depth++;
9732         if (r->remote_dsa_obj_dn) {
9733                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
9734         }
9735         ndr->depth--;
9736         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
9737         ndr->depth++;
9738         if (r->remote_dsa_address) {
9739                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
9740         }
9741         ndr->depth--;
9742         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
9743         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
9744         ndr->depth--;
9745 }
9746
9747 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
9748 {
9749         uint32_t cntr_array_0;
9750         if (ndr_flags & NDR_SCALARS) {
9751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9752                 NDR_CHECK(ndr_push_align(ndr, 4));
9753                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
9754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9755                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9756                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9757                 }
9758         }
9759         if (ndr_flags & NDR_BUFFERS) {
9760                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9761                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9762                 }
9763         }
9764         return NDR_ERR_SUCCESS;
9765 }
9766
9767 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
9768 {
9769         uint32_t cntr_array_0;
9770         TALLOC_CTX *_mem_save_array_0;
9771         if (ndr_flags & NDR_SCALARS) {
9772                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9773                 NDR_CHECK(ndr_pull_align(ndr, 4));
9774                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
9775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9776                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9777                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9778                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9779                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9780                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9781                 }
9782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9783                 if (r->array) {
9784                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9785                 }
9786         }
9787         if (ndr_flags & NDR_BUFFERS) {
9788                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9789                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9790                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9791                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9792                 }
9793                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9794         }
9795         return NDR_ERR_SUCCESS;
9796 }
9797
9798 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
9799 {
9800         uint32_t cntr_array_0;
9801         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
9802         ndr->depth++;
9803         ndr_print_NTTIME(ndr, "time", r->time);
9804         ndr_print_uint32(ndr, "count", r->count);
9805         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9806         ndr->depth++;
9807         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9808                 char *idx_0=NULL;
9809                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9810                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
9811                         free(idx_0);
9812                 }
9813         }
9814         ndr->depth--;
9815         ndr->depth--;
9816 }
9817
9818 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
9819 {
9820         if (ndr_flags & NDR_SCALARS) {
9821                 NDR_CHECK(ndr_push_align(ndr, 8));
9822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
9823                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
9825                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
9826                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
9827                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
9828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
9829                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
9830                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9831                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
9832                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
9833         }
9834         if (ndr_flags & NDR_BUFFERS) {
9835                 if (r->attribute_name) {
9836                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9837                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9838                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9839                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9840                 }
9841                 if (r->object_dn) {
9842                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9843                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9845                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9846                 }
9847                 if (r->binary) {
9848                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
9849                 }
9850         }
9851         return NDR_ERR_SUCCESS;
9852 }
9853
9854 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
9855 {
9856         uint32_t _ptr_attribute_name;
9857         TALLOC_CTX *_mem_save_attribute_name_0;
9858         uint32_t _ptr_object_dn;
9859         TALLOC_CTX *_mem_save_object_dn_0;
9860         uint32_t _ptr_binary;
9861         TALLOC_CTX *_mem_save_binary_0;
9862         if (ndr_flags & NDR_SCALARS) {
9863                 NDR_CHECK(ndr_pull_align(ndr, 8));
9864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
9865                 if (_ptr_attribute_name) {
9866                         NDR_PULL_ALLOC(ndr, r->attribute_name);
9867                 } else {
9868                         r->attribute_name = NULL;
9869                 }
9870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9871                 if (_ptr_object_dn) {
9872                         NDR_PULL_ALLOC(ndr, r->object_dn);
9873                 } else {
9874                         r->object_dn = NULL;
9875                 }
9876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
9877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
9878                 if (_ptr_binary) {
9879                         NDR_PULL_ALLOC(ndr, r->binary);
9880                 } else {
9881                         r->binary = NULL;
9882                 }
9883                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
9884                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
9885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
9886                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
9887                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9888                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
9889                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
9890         }
9891         if (ndr_flags & NDR_BUFFERS) {
9892                 if (r->attribute_name) {
9893                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9894                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
9895                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
9896                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
9897                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
9898                                 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));
9899                         }
9900                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
9901                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
9902                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
9903                 }
9904                 if (r->object_dn) {
9905                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9906                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9907                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9908                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9909                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9910                                 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));
9911                         }
9912                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9913                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9914                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9915                 }
9916                 if (r->binary) {
9917                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
9918                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
9919                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
9920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
9921                 }
9922         }
9923         return NDR_ERR_SUCCESS;
9924 }
9925
9926 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
9927 {
9928         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
9929         ndr->depth++;
9930         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
9931         ndr->depth++;
9932         if (r->attribute_name) {
9933                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
9934         }
9935         ndr->depth--;
9936         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9937         ndr->depth++;
9938         if (r->object_dn) {
9939                 ndr_print_string(ndr, "object_dn", r->object_dn);
9940         }
9941         ndr->depth--;
9942         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);
9943         ndr_print_ptr(ndr, "binary", r->binary);
9944         ndr->depth++;
9945         if (r->binary) {
9946                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
9947         }
9948         ndr->depth--;
9949         ndr_print_NTTIME(ndr, "deleted", r->deleted);
9950         ndr_print_NTTIME(ndr, "created", r->created);
9951         ndr_print_uint32(ndr, "version", r->version);
9952         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
9953         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
9954         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
9955         ndr_print_hyper(ndr, "local_usn", r->local_usn);
9956         ndr->depth--;
9957 }
9958
9959 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
9960 {
9961         uint32_t cntr_array_0;
9962         if (ndr_flags & NDR_SCALARS) {
9963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9964                 NDR_CHECK(ndr_push_align(ndr, 8));
9965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9966                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
9967                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9968                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9969                 }
9970         }
9971         if (ndr_flags & NDR_BUFFERS) {
9972                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9973                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9974                 }
9975         }
9976         return NDR_ERR_SUCCESS;
9977 }
9978
9979 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
9980 {
9981         uint32_t cntr_array_0;
9982         TALLOC_CTX *_mem_save_array_0;
9983         if (ndr_flags & NDR_SCALARS) {
9984                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9985                 NDR_CHECK(ndr_pull_align(ndr, 8));
9986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9987                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
9988                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
9989                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9990                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9991                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9992                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9993                 }
9994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9995                 if (r->array) {
9996                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9997                 }
9998         }
9999         if (ndr_flags & NDR_BUFFERS) {
10000                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10001                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10002                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10003                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10004                 }
10005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10006         }
10007         return NDR_ERR_SUCCESS;
10008 }
10009
10010 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10011 {
10012         uint32_t cntr_array_0;
10013         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10014         ndr->depth++;
10015         ndr_print_uint32(ndr, "count", r->count);
10016         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10017         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10018         ndr->depth++;
10019         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10020                 char *idx_0=NULL;
10021                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10022                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10023                         free(idx_0);
10024                 }
10025         }
10026         ndr->depth--;
10027         ndr->depth--;
10028 }
10029
10030 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
10031 {
10032         uint32_t cntr_array_0;
10033         if (ndr_flags & NDR_SCALARS) {
10034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10035                 NDR_CHECK(ndr_push_align(ndr, 8));
10036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10037                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10038                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10039                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10040                 }
10041         }
10042         if (ndr_flags & NDR_BUFFERS) {
10043         }
10044         return NDR_ERR_SUCCESS;
10045 }
10046
10047 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
10048 {
10049         uint32_t cntr_array_0;
10050         TALLOC_CTX *_mem_save_array_0;
10051         if (ndr_flags & NDR_SCALARS) {
10052                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10053                 NDR_CHECK(ndr_pull_align(ndr, 8));
10054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10055                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10056                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10057                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10058                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10059                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10060                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10061                 }
10062                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10063                 if (r->array) {
10064                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10065                 }
10066         }
10067         if (ndr_flags & NDR_BUFFERS) {
10068         }
10069         return NDR_ERR_SUCCESS;
10070 }
10071
10072 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
10073 {
10074         uint32_t cntr_array_0;
10075         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
10076         ndr->depth++;
10077         ndr_print_uint32(ndr, "count", r->count);
10078         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10079         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10080         ndr->depth++;
10081         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10082                 char *idx_0=NULL;
10083                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10084                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
10085                         free(idx_0);
10086                 }
10087         }
10088         ndr->depth--;
10089         ndr->depth--;
10090 }
10091
10092 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
10093 {
10094         if (ndr_flags & NDR_SCALARS) {
10095                 NDR_CHECK(ndr_push_align(ndr, 8));
10096                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10097                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
10098                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
10099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
10100         }
10101         if (ndr_flags & NDR_BUFFERS) {
10102                 if (r->source_dsa_obj_dn) {
10103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10106                         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));
10107                 }
10108         }
10109         return NDR_ERR_SUCCESS;
10110 }
10111
10112 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
10113 {
10114         uint32_t _ptr_source_dsa_obj_dn;
10115         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
10116         if (ndr_flags & NDR_SCALARS) {
10117                 NDR_CHECK(ndr_pull_align(ndr, 8));
10118                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10119                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
10120                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
10121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
10122                 if (_ptr_source_dsa_obj_dn) {
10123                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
10124                 } else {
10125                         r->source_dsa_obj_dn = NULL;
10126                 }
10127         }
10128         if (ndr_flags & NDR_BUFFERS) {
10129                 if (r->source_dsa_obj_dn) {
10130                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10131                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10132                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10133                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10134                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10135                                 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));
10136                         }
10137                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10138                         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));
10139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10140                 }
10141         }
10142         return NDR_ERR_SUCCESS;
10143 }
10144
10145 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
10146 {
10147         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
10148         ndr->depth++;
10149         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10150         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10151         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
10152         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10153         ndr->depth++;
10154         if (r->source_dsa_obj_dn) {
10155                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10156         }
10157         ndr->depth--;
10158         ndr->depth--;
10159 }
10160
10161 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
10162 {
10163         uint32_t cntr_array_0;
10164         if (ndr_flags & NDR_SCALARS) {
10165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10166                 NDR_CHECK(ndr_push_align(ndr, 8));
10167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10168                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10169                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10170                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10171                 }
10172         }
10173         if (ndr_flags & NDR_BUFFERS) {
10174                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10175                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10176                 }
10177         }
10178         return NDR_ERR_SUCCESS;
10179 }
10180
10181 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
10182 {
10183         uint32_t cntr_array_0;
10184         TALLOC_CTX *_mem_save_array_0;
10185         if (ndr_flags & NDR_SCALARS) {
10186                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10187                 NDR_CHECK(ndr_pull_align(ndr, 8));
10188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10189                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10190                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10191                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10192                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10193                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10194                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10195                 }
10196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10197                 if (r->array) {
10198                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10199                 }
10200         }
10201         if (ndr_flags & NDR_BUFFERS) {
10202                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10203                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10204                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10205                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10206                 }
10207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10208         }
10209         return NDR_ERR_SUCCESS;
10210 }
10211
10212 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
10213 {
10214         uint32_t cntr_array_0;
10215         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
10216         ndr->depth++;
10217         ndr_print_uint32(ndr, "count", r->count);
10218         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10219         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10220         ndr->depth++;
10221         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10222                 char *idx_0=NULL;
10223                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10224                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
10225                         free(idx_0);
10226                 }
10227         }
10228         ndr->depth--;
10229         ndr->depth--;
10230 }
10231
10232 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
10233 {
10234         if (ndr_flags & NDR_SCALARS) {
10235                 NDR_CHECK(ndr_push_align(ndr, 8));
10236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10238                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10239                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10240                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10241                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10242                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
10243         }
10244         if (ndr_flags & NDR_BUFFERS) {
10245                 if (r->attribute_name) {
10246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10249                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10250                 }
10251                 if (r->originating_dsa_dn) {
10252                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10253                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10254                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10255                         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));
10256                 }
10257         }
10258         return NDR_ERR_SUCCESS;
10259 }
10260
10261 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
10262 {
10263         uint32_t _ptr_attribute_name;
10264         TALLOC_CTX *_mem_save_attribute_name_0;
10265         uint32_t _ptr_originating_dsa_dn;
10266         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
10267         if (ndr_flags & NDR_SCALARS) {
10268                 NDR_CHECK(ndr_pull_align(ndr, 8));
10269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10270                 if (_ptr_attribute_name) {
10271                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10272                 } else {
10273                         r->attribute_name = NULL;
10274                 }
10275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10276                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10277                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10278                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10279                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
10281                 if (_ptr_originating_dsa_dn) {
10282                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
10283                 } else {
10284                         r->originating_dsa_dn = NULL;
10285                 }
10286         }
10287         if (ndr_flags & NDR_BUFFERS) {
10288                 if (r->attribute_name) {
10289                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10290                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10291                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10292                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10293                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10294                                 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));
10295                         }
10296                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10297                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10299                 }
10300                 if (r->originating_dsa_dn) {
10301                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10302                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
10303                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
10304                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
10305                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
10306                                 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));
10307                         }
10308                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
10309                         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));
10310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
10311                 }
10312         }
10313         return NDR_ERR_SUCCESS;
10314 }
10315
10316 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
10317 {
10318         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
10319         ndr->depth++;
10320         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10321         ndr->depth++;
10322         if (r->attribute_name) {
10323                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10324         }
10325         ndr->depth--;
10326         ndr_print_uint32(ndr, "version", r->version);
10327         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10328         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10329         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10330         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10331         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10332         ndr->depth++;
10333         if (r->originating_dsa_dn) {
10334                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10335         }
10336         ndr->depth--;
10337         ndr->depth--;
10338 }
10339
10340 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
10341 {
10342         uint32_t cntr_array_0;
10343         if (ndr_flags & NDR_SCALARS) {
10344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10345                 NDR_CHECK(ndr_push_align(ndr, 8));
10346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10347                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10348                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10349                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10350                 }
10351         }
10352         if (ndr_flags & NDR_BUFFERS) {
10353                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10354                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10355                 }
10356         }
10357         return NDR_ERR_SUCCESS;
10358 }
10359
10360 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
10361 {
10362         uint32_t cntr_array_0;
10363         TALLOC_CTX *_mem_save_array_0;
10364         if (ndr_flags & NDR_SCALARS) {
10365                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10366                 NDR_CHECK(ndr_pull_align(ndr, 8));
10367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10368                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10369                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10370                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10371                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10372                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10373                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10374                 }
10375                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10376                 if (r->array) {
10377                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10378                 }
10379         }
10380         if (ndr_flags & NDR_BUFFERS) {
10381                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10382                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10383                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10384                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10385                 }
10386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10387         }
10388         return NDR_ERR_SUCCESS;
10389 }
10390
10391 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
10392 {
10393         uint32_t cntr_array_0;
10394         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
10395         ndr->depth++;
10396         ndr_print_uint32(ndr, "count", r->count);
10397         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10398         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10399         ndr->depth++;
10400         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10401                 char *idx_0=NULL;
10402                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10403                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
10404                         free(idx_0);
10405                 }
10406         }
10407         ndr->depth--;
10408         ndr->depth--;
10409 }
10410
10411 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
10412 {
10413         if (ndr_flags & NDR_SCALARS) {
10414                 NDR_CHECK(ndr_push_align(ndr, 8));
10415                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10416                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10419                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10420                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10422                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10423                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10424                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10425                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
10427         }
10428         if (ndr_flags & NDR_BUFFERS) {
10429                 if (r->attribute_name) {
10430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10434                 }
10435                 if (r->object_dn) {
10436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10440                 }
10441                 if (r->binary) {
10442                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10443                 }
10444                 if (r->originating_dsa_dn) {
10445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10448                         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));
10449                 }
10450         }
10451         return NDR_ERR_SUCCESS;
10452 }
10453
10454 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
10455 {
10456         uint32_t _ptr_attribute_name;
10457         TALLOC_CTX *_mem_save_attribute_name_0;
10458         uint32_t _ptr_object_dn;
10459         TALLOC_CTX *_mem_save_object_dn_0;
10460         uint32_t _ptr_binary;
10461         TALLOC_CTX *_mem_save_binary_0;
10462         uint32_t _ptr_originating_dsa_dn;
10463         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
10464         if (ndr_flags & NDR_SCALARS) {
10465                 NDR_CHECK(ndr_pull_align(ndr, 8));
10466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10467                 if (_ptr_attribute_name) {
10468                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10469                 } else {
10470                         r->attribute_name = NULL;
10471                 }
10472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10473                 if (_ptr_object_dn) {
10474                         NDR_PULL_ALLOC(ndr, r->object_dn);
10475                 } else {
10476                         r->object_dn = NULL;
10477                 }
10478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10480                 if (_ptr_binary) {
10481                         NDR_PULL_ALLOC(ndr, r->binary);
10482                 } else {
10483                         r->binary = NULL;
10484                 }
10485                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10486                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10488                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10489                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10490                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10491                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
10493                 if (_ptr_originating_dsa_dn) {
10494                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
10495                 } else {
10496                         r->originating_dsa_dn = NULL;
10497                 }
10498         }
10499         if (ndr_flags & NDR_BUFFERS) {
10500                 if (r->attribute_name) {
10501                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10502                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10503                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10504                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10505                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10506                                 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));
10507                         }
10508                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10509                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10511                 }
10512                 if (r->object_dn) {
10513                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10514                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10516                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10517                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10518                                 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));
10519                         }
10520                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10523                 }
10524                 if (r->binary) {
10525                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10526                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10527                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10529                 }
10530                 if (r->originating_dsa_dn) {
10531                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10532                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
10533                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
10534                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
10535                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
10536                                 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));
10537                         }
10538                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
10539                         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));
10540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
10541                 }
10542         }
10543         return NDR_ERR_SUCCESS;
10544 }
10545
10546 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
10547 {
10548         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
10549         ndr->depth++;
10550         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10551         ndr->depth++;
10552         if (r->attribute_name) {
10553                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10554         }
10555         ndr->depth--;
10556         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10557         ndr->depth++;
10558         if (r->object_dn) {
10559                 ndr_print_string(ndr, "object_dn", r->object_dn);
10560         }
10561         ndr->depth--;
10562         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);
10563         ndr_print_ptr(ndr, "binary", r->binary);
10564         ndr->depth++;
10565         if (r->binary) {
10566                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10567         }
10568         ndr->depth--;
10569         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10570         ndr_print_NTTIME(ndr, "created", r->created);
10571         ndr_print_uint32(ndr, "version", r->version);
10572         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10573         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10574         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10575         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10576         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10577         ndr->depth++;
10578         if (r->originating_dsa_dn) {
10579                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10580         }
10581         ndr->depth--;
10582         ndr->depth--;
10583 }
10584
10585 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
10586 {
10587         uint32_t cntr_array_0;
10588         if (ndr_flags & NDR_SCALARS) {
10589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10590                 NDR_CHECK(ndr_push_align(ndr, 8));
10591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10592                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10593                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10594                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10595                 }
10596         }
10597         if (ndr_flags & NDR_BUFFERS) {
10598                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10599                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10600                 }
10601         }
10602         return NDR_ERR_SUCCESS;
10603 }
10604
10605 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
10606 {
10607         uint32_t cntr_array_0;
10608         TALLOC_CTX *_mem_save_array_0;
10609         if (ndr_flags & NDR_SCALARS) {
10610                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10611                 NDR_CHECK(ndr_pull_align(ndr, 8));
10612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10613                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10614                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10615                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10616                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10617                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10618                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10619                 }
10620                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10621                 if (r->array) {
10622                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10623                 }
10624         }
10625         if (ndr_flags & NDR_BUFFERS) {
10626                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10627                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10628                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10629                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10630                 }
10631                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10632         }
10633         return NDR_ERR_SUCCESS;
10634 }
10635
10636 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
10637 {
10638         uint32_t cntr_array_0;
10639         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
10640         ndr->depth++;
10641         ndr_print_uint32(ndr, "count", r->count);
10642         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10643         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10644         ndr->depth++;
10645         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10646                 char *idx_0=NULL;
10647                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10648                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
10649                         free(idx_0);
10650                 }
10651         }
10652         ndr->depth--;
10653         ndr->depth--;
10654 }
10655
10656 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
10657 {
10658         if (ndr_flags & NDR_SCALARS) {
10659                 NDR_CHECK(ndr_push_align(ndr, 8));
10660                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
10661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
10662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
10663                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
10664                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
10665                 {
10666                         uint32_t _flags_save_ipv4address = ndr->flags;
10667                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
10668                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
10669                         ndr->flags = _flags_save_ipv4address;
10670                 }
10671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
10672         }
10673         if (ndr_flags & NDR_BUFFERS) {
10674         }
10675         return NDR_ERR_SUCCESS;
10676 }
10677
10678 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
10679 {
10680         if (ndr_flags & NDR_SCALARS) {
10681                 NDR_CHECK(ndr_pull_align(ndr, 8));
10682                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
10683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
10684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
10685                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
10686                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
10687                 {
10688                         uint32_t _flags_save_ipv4address = ndr->flags;
10689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
10690                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
10691                         ndr->flags = _flags_save_ipv4address;
10692                 }
10693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
10694         }
10695         if (ndr_flags & NDR_BUFFERS) {
10696         }
10697         return NDR_ERR_SUCCESS;
10698 }
10699
10700 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
10701 {
10702         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
10703         ndr->depth++;
10704         ndr_print_hyper(ndr, "u1", r->u1);
10705         ndr_print_uint32(ndr, "u2", r->u2);
10706         ndr_print_uint32(ndr, "u3", r->u3);
10707         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
10708         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
10709         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
10710         ndr_print_uint32(ndr, "u5", r->u5);
10711         ndr->depth--;
10712 }
10713
10714 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
10715 {
10716         uint32_t cntr_array_0;
10717         if (ndr_flags & NDR_SCALARS) {
10718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10719                 NDR_CHECK(ndr_push_align(ndr, 8));
10720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10722                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10723                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10724                 }
10725         }
10726         if (ndr_flags & NDR_BUFFERS) {
10727         }
10728         return NDR_ERR_SUCCESS;
10729 }
10730
10731 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
10732 {
10733         uint32_t cntr_array_0;
10734         TALLOC_CTX *_mem_save_array_0;
10735         if (ndr_flags & NDR_SCALARS) {
10736                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10737                 NDR_CHECK(ndr_pull_align(ndr, 8));
10738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10739                 if (r->count < 0 || r->count > 10000) {
10740                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
10741                 }
10742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10743                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10744                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10745                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10746                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10747                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10748                 }
10749                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10750                 if (r->array) {
10751                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10752                 }
10753         }
10754         if (ndr_flags & NDR_BUFFERS) {
10755         }
10756         return NDR_ERR_SUCCESS;
10757 }
10758
10759 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
10760 {
10761         uint32_t cntr_array_0;
10762         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
10763         ndr->depth++;
10764         ndr_print_uint32(ndr, "count", r->count);
10765         ndr_print_uint32(ndr, "reserved", r->reserved);
10766         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10767         ndr->depth++;
10768         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10769                 char *idx_0=NULL;
10770                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10771                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
10772                         free(idx_0);
10773                 }
10774         }
10775         ndr->depth--;
10776         ndr->depth--;
10777 }
10778
10779 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
10780 {
10781         if (ndr_flags & NDR_SCALARS) {
10782                 NDR_CHECK(ndr_push_align(ndr, 8));
10783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
10784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
10785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
10786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
10787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
10788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
10789                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
10790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
10791         }
10792         if (ndr_flags & NDR_BUFFERS) {
10793                 if (r->str1) {
10794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
10795                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10796                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
10797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10798                 }
10799         }
10800         return NDR_ERR_SUCCESS;
10801 }
10802
10803 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
10804 {
10805         uint32_t _ptr_str1;
10806         TALLOC_CTX *_mem_save_str1_0;
10807         if (ndr_flags & NDR_SCALARS) {
10808                 NDR_CHECK(ndr_pull_align(ndr, 8));
10809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
10810                 if (_ptr_str1) {
10811                         NDR_PULL_ALLOC(ndr, r->str1);
10812                 } else {
10813                         r->str1 = NULL;
10814                 }
10815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
10816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
10817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
10818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
10819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
10820                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
10821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
10822         }
10823         if (ndr_flags & NDR_BUFFERS) {
10824                 if (r->str1) {
10825                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10826                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
10827                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
10828                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
10829                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
10830                                 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));
10831                         }
10832                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
10833                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
10834                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
10835                 }
10836         }
10837         return NDR_ERR_SUCCESS;
10838 }
10839
10840 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
10841 {
10842         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
10843         ndr->depth++;
10844         ndr_print_ptr(ndr, "str1", r->str1);
10845         ndr->depth++;
10846         if (r->str1) {
10847                 ndr_print_string(ndr, "str1", r->str1);
10848         }
10849         ndr->depth--;
10850         ndr_print_uint32(ndr, "u1", r->u1);
10851         ndr_print_uint32(ndr, "u2", r->u2);
10852         ndr_print_uint32(ndr, "u3", r->u3);
10853         ndr_print_uint32(ndr, "u4", r->u4);
10854         ndr_print_uint32(ndr, "u5", r->u5);
10855         ndr_print_hyper(ndr, "u6", r->u6);
10856         ndr_print_uint32(ndr, "u7", r->u7);
10857         ndr->depth--;
10858 }
10859
10860 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
10861 {
10862         uint32_t cntr_array_0;
10863         if (ndr_flags & NDR_SCALARS) {
10864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10865                 NDR_CHECK(ndr_push_align(ndr, 8));
10866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10868                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10869                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10870                 }
10871         }
10872         if (ndr_flags & NDR_BUFFERS) {
10873                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10874                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10875                 }
10876         }
10877         return NDR_ERR_SUCCESS;
10878 }
10879
10880 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
10881 {
10882         uint32_t cntr_array_0;
10883         TALLOC_CTX *_mem_save_array_0;
10884         if (ndr_flags & NDR_SCALARS) {
10885                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10886                 NDR_CHECK(ndr_pull_align(ndr, 8));
10887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10888                 if (r->count < 0 || r->count > 256) {
10889                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
10890                 }
10891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10892                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10893                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10894                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10895                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10896                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10897                 }
10898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10899                 if (r->array) {
10900                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10901                 }
10902         }
10903         if (ndr_flags & NDR_BUFFERS) {
10904                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10905                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10906                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10907                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10908                 }
10909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10910         }
10911         return NDR_ERR_SUCCESS;
10912 }
10913
10914 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
10915 {
10916         uint32_t cntr_array_0;
10917         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
10918         ndr->depth++;
10919         ndr_print_uint32(ndr, "count", r->count);
10920         ndr_print_uint32(ndr, "reserved", r->reserved);
10921         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10922         ndr->depth++;
10923         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10924                 char *idx_0=NULL;
10925                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10926                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
10927                         free(idx_0);
10928                 }
10929         }
10930         ndr->depth--;
10931         ndr->depth--;
10932 }
10933
10934 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
10935 {
10936         if (ndr_flags & NDR_SCALARS) {
10937                 int level = ndr_push_get_switch_value(ndr, r);
10938                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
10939                 switch (level) {
10940                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
10941                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
10942                         break; }
10943
10944                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
10945                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
10946                         break; }
10947
10948                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
10949                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
10950                         break; }
10951
10952                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
10953                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
10954                         break; }
10955
10956                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
10957                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
10958                         break; }
10959
10960                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
10961                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
10962                         break; }
10963
10964                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
10965                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
10966                         break; }
10967
10968                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
10969                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
10970                         break; }
10971
10972                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
10973                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
10974                         break; }
10975
10976                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
10977                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
10978                         break; }
10979
10980                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
10981                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
10982                         break; }
10983
10984                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
10985                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
10986                         break; }
10987
10988                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
10989                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
10990                         break; }
10991
10992                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
10993                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
10994                         break; }
10995
10996                         case DRSUAPI_DS_REPLICA_INFO_06: {
10997                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
10998                         break; }
10999
11000                         default:
11001                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11002                 }
11003         }
11004         if (ndr_flags & NDR_BUFFERS) {
11005                 int level = ndr_push_get_switch_value(ndr, r);
11006                 switch (level) {
11007                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11008                                 if (r->neighbours) {
11009                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11010                                 }
11011                         break;
11012
11013                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11014                                 if (r->cursors) {
11015                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11016                                 }
11017                         break;
11018
11019                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11020                                 if (r->objmetadata) {
11021                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11022                                 }
11023                         break;
11024
11025                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11026                                 if (r->connectfailures) {
11027                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11028                                 }
11029                         break;
11030
11031                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11032                                 if (r->linkfailures) {
11033                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
11034                                 }
11035                         break;
11036
11037                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11038                                 if (r->pendingops) {
11039                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
11040                                 }
11041                         break;
11042
11043                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11044                                 if (r->attrvalmetadata) {
11045                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
11046                                 }
11047                         break;
11048
11049                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11050                                 if (r->cursors2) {
11051                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
11052                                 }
11053                         break;
11054
11055                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11056                                 if (r->cursors3) {
11057                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
11058                                 }
11059                         break;
11060
11061                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11062                                 if (r->objmetadata2) {
11063                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
11064                                 }
11065                         break;
11066
11067                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
11068                                 if (r->attrvalmetadata2) {
11069                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
11070                                 }
11071                         break;
11072
11073                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
11074                                 if (r->neighbours02) {
11075                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
11076                                 }
11077                         break;
11078
11079                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
11080                                 if (r->connections04) {
11081                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
11082                                 }
11083                         break;
11084
11085                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
11086                                 if (r->cursors05) {
11087                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
11088                                 }
11089                         break;
11090
11091                         case DRSUAPI_DS_REPLICA_INFO_06:
11092                                 if (r->i06) {
11093                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
11094                                 }
11095                         break;
11096
11097                         default:
11098                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11099                 }
11100         }
11101         return NDR_ERR_SUCCESS;
11102 }
11103
11104 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
11105 {
11106         int level;
11107         uint32_t _level;
11108         TALLOC_CTX *_mem_save_neighbours_0;
11109         TALLOC_CTX *_mem_save_cursors_0;
11110         TALLOC_CTX *_mem_save_objmetadata_0;
11111         TALLOC_CTX *_mem_save_connectfailures_0;
11112         TALLOC_CTX *_mem_save_linkfailures_0;
11113         TALLOC_CTX *_mem_save_pendingops_0;
11114         TALLOC_CTX *_mem_save_attrvalmetadata_0;
11115         TALLOC_CTX *_mem_save_cursors2_0;
11116         TALLOC_CTX *_mem_save_cursors3_0;
11117         TALLOC_CTX *_mem_save_objmetadata2_0;
11118         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
11119         TALLOC_CTX *_mem_save_neighbours02_0;
11120         TALLOC_CTX *_mem_save_connections04_0;
11121         TALLOC_CTX *_mem_save_cursors05_0;
11122         TALLOC_CTX *_mem_save_i06_0;
11123         level = ndr_pull_get_switch_value(ndr, r);
11124         if (ndr_flags & NDR_SCALARS) {
11125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11126                 if (_level != level) {
11127                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11128                 }
11129                 switch (level) {
11130                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11131                                 uint32_t _ptr_neighbours;
11132                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
11133                                 if (_ptr_neighbours) {
11134                                         NDR_PULL_ALLOC(ndr, r->neighbours);
11135                                 } else {
11136                                         r->neighbours = NULL;
11137                                 }
11138                         break; }
11139
11140                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11141                                 uint32_t _ptr_cursors;
11142                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
11143                                 if (_ptr_cursors) {
11144                                         NDR_PULL_ALLOC(ndr, r->cursors);
11145                                 } else {
11146                                         r->cursors = NULL;
11147                                 }
11148                         break; }
11149
11150                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11151                                 uint32_t _ptr_objmetadata;
11152                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
11153                                 if (_ptr_objmetadata) {
11154                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
11155                                 } else {
11156                                         r->objmetadata = NULL;
11157                                 }
11158                         break; }
11159
11160                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11161                                 uint32_t _ptr_connectfailures;
11162                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
11163                                 if (_ptr_connectfailures) {
11164                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
11165                                 } else {
11166                                         r->connectfailures = NULL;
11167                                 }
11168                         break; }
11169
11170                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11171                                 uint32_t _ptr_linkfailures;
11172                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
11173                                 if (_ptr_linkfailures) {
11174                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
11175                                 } else {
11176                                         r->linkfailures = NULL;
11177                                 }
11178                         break; }
11179
11180                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11181                                 uint32_t _ptr_pendingops;
11182                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
11183                                 if (_ptr_pendingops) {
11184                                         NDR_PULL_ALLOC(ndr, r->pendingops);
11185                                 } else {
11186                                         r->pendingops = NULL;
11187                                 }
11188                         break; }
11189
11190                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11191                                 uint32_t _ptr_attrvalmetadata;
11192                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
11193                                 if (_ptr_attrvalmetadata) {
11194                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
11195                                 } else {
11196                                         r->attrvalmetadata = NULL;
11197                                 }
11198                         break; }
11199
11200                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11201                                 uint32_t _ptr_cursors2;
11202                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
11203                                 if (_ptr_cursors2) {
11204                                         NDR_PULL_ALLOC(ndr, r->cursors2);
11205                                 } else {
11206                                         r->cursors2 = NULL;
11207                                 }
11208                         break; }
11209
11210                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11211                                 uint32_t _ptr_cursors3;
11212                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
11213                                 if (_ptr_cursors3) {
11214                                         NDR_PULL_ALLOC(ndr, r->cursors3);
11215                                 } else {
11216                                         r->cursors3 = NULL;
11217                                 }
11218                         break; }
11219
11220                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11221                                 uint32_t _ptr_objmetadata2;
11222                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
11223                                 if (_ptr_objmetadata2) {
11224                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
11225                                 } else {
11226                                         r->objmetadata2 = NULL;
11227                                 }
11228                         break; }
11229
11230                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11231                                 uint32_t _ptr_attrvalmetadata2;
11232                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
11233                                 if (_ptr_attrvalmetadata2) {
11234                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
11235                                 } else {
11236                                         r->attrvalmetadata2 = NULL;
11237                                 }
11238                         break; }
11239
11240                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11241                                 uint32_t _ptr_neighbours02;
11242                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
11243                                 if (_ptr_neighbours02) {
11244                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
11245                                 } else {
11246                                         r->neighbours02 = NULL;
11247                                 }
11248                         break; }
11249
11250                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
11251                                 uint32_t _ptr_connections04;
11252                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
11253                                 if (_ptr_connections04) {
11254                                         NDR_PULL_ALLOC(ndr, r->connections04);
11255                                 } else {
11256                                         r->connections04 = NULL;
11257                                 }
11258                         break; }
11259
11260                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
11261                                 uint32_t _ptr_cursors05;
11262                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
11263                                 if (_ptr_cursors05) {
11264                                         NDR_PULL_ALLOC(ndr, r->cursors05);
11265                                 } else {
11266                                         r->cursors05 = NULL;
11267                                 }
11268                         break; }
11269
11270                         case DRSUAPI_DS_REPLICA_INFO_06: {
11271                                 uint32_t _ptr_i06;
11272                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
11273                                 if (_ptr_i06) {
11274                                         NDR_PULL_ALLOC(ndr, r->i06);
11275                                 } else {
11276                                         r->i06 = NULL;
11277                                 }
11278                         break; }
11279
11280                         default:
11281                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11282                 }
11283         }
11284         if (ndr_flags & NDR_BUFFERS) {
11285                 switch (level) {
11286                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11287                                 if (r->neighbours) {
11288                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
11289                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
11290                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11291                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
11292                                 }
11293                         break;
11294
11295                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11296                                 if (r->cursors) {
11297                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
11298                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
11299                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11300                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
11301                                 }
11302                         break;
11303
11304                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11305                                 if (r->objmetadata) {
11306                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
11307                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
11308                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11309                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
11310                                 }
11311                         break;
11312
11313                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11314                                 if (r->connectfailures) {
11315                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
11316                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
11317                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11318                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
11319                                 }
11320                         break;
11321
11322                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11323                                 if (r->linkfailures) {
11324                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
11325                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
11326                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
11327                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
11328                                 }
11329                         break;
11330
11331                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11332                                 if (r->pendingops) {
11333                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
11334                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
11335                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
11336                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
11337                                 }
11338                         break;
11339
11340                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11341                                 if (r->attrvalmetadata) {
11342                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
11343                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
11344                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
11345                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
11346                                 }
11347                         break;
11348
11349                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11350                                 if (r->cursors2) {
11351                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
11352                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
11353                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
11354                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
11355                                 }
11356                         break;
11357
11358                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11359                                 if (r->cursors3) {
11360                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
11361                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
11362                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
11363                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
11364                                 }
11365                         break;
11366
11367                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11368                                 if (r->objmetadata2) {
11369                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
11370                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
11371                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
11372                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
11373                                 }
11374                         break;
11375
11376                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
11377                                 if (r->attrvalmetadata2) {
11378                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
11379                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
11380                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
11381                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
11382                                 }
11383                         break;
11384
11385                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
11386                                 if (r->neighbours02) {
11387                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
11388                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
11389                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
11390                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
11391                                 }
11392                         break;
11393
11394                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
11395                                 if (r->connections04) {
11396                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
11397                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
11398                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
11399                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
11400                                 }
11401                         break;
11402
11403                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
11404                                 if (r->cursors05) {
11405                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
11406                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
11407                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
11408                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
11409                                 }
11410                         break;
11411
11412                         case DRSUAPI_DS_REPLICA_INFO_06:
11413                                 if (r->i06) {
11414                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
11415                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
11416                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
11417                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
11418                                 }
11419                         break;
11420
11421                         default:
11422                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11423                 }
11424         }
11425         return NDR_ERR_SUCCESS;
11426 }
11427
11428 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
11429 {
11430         int level;
11431         level = ndr_print_get_switch_value(ndr, r);
11432         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
11433         switch (level) {
11434                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11435                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
11436                         ndr->depth++;
11437                         if (r->neighbours) {
11438                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
11439                         }
11440                         ndr->depth--;
11441                 break;
11442
11443                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11444                         ndr_print_ptr(ndr, "cursors", r->cursors);
11445                         ndr->depth++;
11446                         if (r->cursors) {
11447                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
11448                         }
11449                         ndr->depth--;
11450                 break;
11451
11452                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11453                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
11454                         ndr->depth++;
11455                         if (r->objmetadata) {
11456                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
11457                         }
11458                         ndr->depth--;
11459                 break;
11460
11461                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11462                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
11463                         ndr->depth++;
11464                         if (r->connectfailures) {
11465                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
11466                         }
11467                         ndr->depth--;
11468                 break;
11469
11470                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11471                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
11472                         ndr->depth++;
11473                         if (r->linkfailures) {
11474                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
11475                         }
11476                         ndr->depth--;
11477                 break;
11478
11479                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11480                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
11481                         ndr->depth++;
11482                         if (r->pendingops) {
11483                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
11484                         }
11485                         ndr->depth--;
11486                 break;
11487
11488                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11489                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
11490                         ndr->depth++;
11491                         if (r->attrvalmetadata) {
11492                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
11493                         }
11494                         ndr->depth--;
11495                 break;
11496
11497                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11498                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
11499                         ndr->depth++;
11500                         if (r->cursors2) {
11501                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
11502                         }
11503                         ndr->depth--;
11504                 break;
11505
11506                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11507                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
11508                         ndr->depth++;
11509                         if (r->cursors3) {
11510                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
11511                         }
11512                         ndr->depth--;
11513                 break;
11514
11515                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11516                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
11517                         ndr->depth++;
11518                         if (r->objmetadata2) {
11519                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
11520                         }
11521                         ndr->depth--;
11522                 break;
11523
11524                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
11525                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
11526                         ndr->depth++;
11527                         if (r->attrvalmetadata2) {
11528                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
11529                         }
11530                         ndr->depth--;
11531                 break;
11532
11533                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
11534                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
11535                         ndr->depth++;
11536                         if (r->neighbours02) {
11537                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
11538                         }
11539                         ndr->depth--;
11540                 break;
11541
11542                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
11543                         ndr_print_ptr(ndr, "connections04", r->connections04);
11544                         ndr->depth++;
11545                         if (r->connections04) {
11546                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
11547                         }
11548                         ndr->depth--;
11549                 break;
11550
11551                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
11552                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
11553                         ndr->depth++;
11554                         if (r->cursors05) {
11555                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
11556                         }
11557                         ndr->depth--;
11558                 break;
11559
11560                 case DRSUAPI_DS_REPLICA_INFO_06:
11561                         ndr_print_ptr(ndr, "i06", r->i06);
11562                         ndr->depth++;
11563                         if (r->i06) {
11564                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
11565                         }
11566                         ndr->depth--;
11567                 break;
11568
11569                 default:
11570                         ndr_print_bad_level(ndr, name, level);
11571         }
11572 }
11573
11574 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
11575 {
11576         if (ndr_flags & NDR_SCALARS) {
11577                 int level = ndr_push_get_switch_value(ndr, r);
11578                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
11579                 switch (level) {
11580                         case 1: {
11581                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
11582                         break; }
11583
11584                         default:
11585                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11586                 }
11587         }
11588         if (ndr_flags & NDR_BUFFERS) {
11589                 int level = ndr_push_get_switch_value(ndr, r);
11590                 switch (level) {
11591                         case 1:
11592                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
11593                         break;
11594
11595                         default:
11596                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11597                 }
11598         }
11599         return NDR_ERR_SUCCESS;
11600 }
11601
11602 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
11603 {
11604         int level;
11605         int32_t _level;
11606         level = ndr_pull_get_switch_value(ndr, r);
11607         if (ndr_flags & NDR_SCALARS) {
11608                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
11609                 if (_level != level) {
11610                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11611                 }
11612                 switch (level) {
11613                         case 1: {
11614                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
11615                         break; }
11616
11617                         default:
11618                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11619                 }
11620         }
11621         if (ndr_flags & NDR_BUFFERS) {
11622                 switch (level) {
11623                         case 1:
11624                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
11625                         break;
11626
11627                         default:
11628                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11629                 }
11630         }
11631         return NDR_ERR_SUCCESS;
11632 }
11633
11634 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
11635 {
11636         int level;
11637         level = ndr_print_get_switch_value(ndr, r);
11638         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
11639         switch (level) {
11640                 case 1:
11641                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
11642                 break;
11643
11644                 default:
11645                         ndr_print_bad_level(ndr, name, level);
11646         }
11647 }
11648
11649 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
11650 {
11651         uint32_t cntr_req_array_1;
11652         if (ndr_flags & NDR_SCALARS) {
11653                 NDR_CHECK(ndr_push_align(ndr, 4));
11654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
11655                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
11656         }
11657         if (ndr_flags & NDR_BUFFERS) {
11658                 if (r->req_array) {
11659                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
11660                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
11661                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
11662                         }
11663                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
11664                                 if (r->req_array[cntr_req_array_1]) {
11665                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
11666                                 }
11667                         }
11668                 }
11669         }
11670         return NDR_ERR_SUCCESS;
11671 }
11672
11673 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
11674 {
11675         uint32_t _ptr_req_array;
11676         uint32_t cntr_req_array_1;
11677         TALLOC_CTX *_mem_save_req_array_0;
11678         TALLOC_CTX *_mem_save_req_array_1;
11679         TALLOC_CTX *_mem_save_req_array_2;
11680         if (ndr_flags & NDR_SCALARS) {
11681                 NDR_CHECK(ndr_pull_align(ndr, 4));
11682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
11683                 if (r->num_req < 1 || r->num_req > 10000) {
11684                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11685                 }
11686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
11687                 if (_ptr_req_array) {
11688                         NDR_PULL_ALLOC(ndr, r->req_array);
11689                 } else {
11690                         r->req_array = NULL;
11691                 }
11692         }
11693         if (ndr_flags & NDR_BUFFERS) {
11694                 if (r->req_array) {
11695                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11696                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
11697                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
11698                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
11699                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
11700                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
11701                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
11702                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
11703                                 if (_ptr_req_array) {
11704                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
11705                                 } else {
11706                                         r->req_array[cntr_req_array_1] = NULL;
11707                                 }
11708                         }
11709                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
11710                                 if (r->req_array[cntr_req_array_1]) {
11711                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
11712                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
11713                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
11714                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
11715                                 }
11716                         }
11717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
11718                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
11719                 }
11720                 if (r->req_array) {
11721                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
11722                 }
11723         }
11724         return NDR_ERR_SUCCESS;
11725 }
11726
11727 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
11728 {
11729         uint32_t cntr_req_array_1;
11730         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
11731         ndr->depth++;
11732         ndr_print_uint32(ndr, "num_req", r->num_req);
11733         ndr_print_ptr(ndr, "req_array", r->req_array);
11734         ndr->depth++;
11735         if (r->req_array) {
11736                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
11737                 ndr->depth++;
11738                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
11739                         char *idx_1=NULL;
11740                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
11741                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
11742                                 ndr->depth++;
11743                                 if (r->req_array[cntr_req_array_1]) {
11744                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
11745                                 }
11746                                 ndr->depth--;
11747                                 free(idx_1);
11748                         }
11749                 }
11750                 ndr->depth--;
11751         }
11752         ndr->depth--;
11753         ndr->depth--;
11754 }
11755
11756 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
11757 {
11758         if (ndr_flags & NDR_SCALARS) {
11759                 int level = ndr_push_get_switch_value(ndr, r);
11760                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
11761                 switch (level) {
11762                         case 1: {
11763                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
11764                         break; }
11765
11766                         default:
11767                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11768                 }
11769         }
11770         if (ndr_flags & NDR_BUFFERS) {
11771                 int level = ndr_push_get_switch_value(ndr, r);
11772                 switch (level) {
11773                         case 1:
11774                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
11775                         break;
11776
11777                         default:
11778                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11779                 }
11780         }
11781         return NDR_ERR_SUCCESS;
11782 }
11783
11784 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
11785 {
11786         int level;
11787         int32_t _level;
11788         level = ndr_pull_get_switch_value(ndr, r);
11789         if (ndr_flags & NDR_SCALARS) {
11790                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
11791                 if (_level != level) {
11792                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11793                 }
11794                 switch (level) {
11795                         case 1: {
11796                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
11797                         break; }
11798
11799                         default:
11800                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11801                 }
11802         }
11803         if (ndr_flags & NDR_BUFFERS) {
11804                 switch (level) {
11805                         case 1:
11806                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
11807                         break;
11808
11809                         default:
11810                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11811                 }
11812         }
11813         return NDR_ERR_SUCCESS;
11814 }
11815
11816 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
11817 {
11818         int level;
11819         level = ndr_print_get_switch_value(ndr, r);
11820         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
11821         switch (level) {
11822                 case 1:
11823                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
11824                 break;
11825
11826                 default:
11827                         ndr_print_bad_level(ndr, name, level);
11828         }
11829 }
11830
11831 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
11832 {
11833         if (ndr_flags & NDR_SCALARS) {
11834                 NDR_CHECK(ndr_push_align(ndr, 4));
11835                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
11836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
11837         }
11838         if (ndr_flags & NDR_BUFFERS) {
11839         }
11840         return NDR_ERR_SUCCESS;
11841 }
11842
11843 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
11844 {
11845         if (ndr_flags & NDR_SCALARS) {
11846                 NDR_CHECK(ndr_pull_align(ndr, 4));
11847                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
11848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
11849         }
11850         if (ndr_flags & NDR_BUFFERS) {
11851         }
11852         return NDR_ERR_SUCCESS;
11853 }
11854
11855 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
11856 {
11857         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
11858         ndr->depth++;
11859         ndr_print_WERROR(ndr, "error_code", r->error_code);
11860         ndr_print_uint32(ndr, "site_cost", r->site_cost);
11861         ndr->depth--;
11862 }
11863
11864 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
11865 {
11866         uint32_t cntr_info_1;
11867         if (ndr_flags & NDR_SCALARS) {
11868                 NDR_CHECK(ndr_push_align(ndr, 4));
11869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
11870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
11871                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
11872         }
11873         if (ndr_flags & NDR_BUFFERS) {
11874                 if (r->info) {
11875                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
11876                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
11877                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
11878                         }
11879                 }
11880         }
11881         return NDR_ERR_SUCCESS;
11882 }
11883
11884 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
11885 {
11886         uint32_t _ptr_info;
11887         uint32_t cntr_info_1;
11888         TALLOC_CTX *_mem_save_info_0;
11889         TALLOC_CTX *_mem_save_info_1;
11890         if (ndr_flags & NDR_SCALARS) {
11891                 NDR_CHECK(ndr_pull_align(ndr, 4));
11892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
11893                 if (r->num_info < 0 || r->num_info > 10000) {
11894                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11895                 }
11896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
11897                 if (_ptr_info) {
11898                         NDR_PULL_ALLOC(ndr, r->info);
11899                 } else {
11900                         r->info = NULL;
11901                 }
11902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
11903         }
11904         if (ndr_flags & NDR_BUFFERS) {
11905                 if (r->info) {
11906                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11907                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
11908                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
11909                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
11910                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
11911                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
11912                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
11913                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
11914                         }
11915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
11916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
11917                 }
11918                 if (r->info) {
11919                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
11920                 }
11921         }
11922         return NDR_ERR_SUCCESS;
11923 }
11924
11925 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
11926 {
11927         uint32_t cntr_info_1;
11928         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
11929         ndr->depth++;
11930         ndr_print_uint32(ndr, "num_info", r->num_info);
11931         ndr_print_ptr(ndr, "info", r->info);
11932         ndr->depth++;
11933         if (r->info) {
11934                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
11935                 ndr->depth++;
11936                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
11937                         char *idx_1=NULL;
11938                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
11939                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
11940                                 free(idx_1);
11941                         }
11942                 }
11943                 ndr->depth--;
11944         }
11945         ndr->depth--;
11946         ndr_print_uint32(ndr, "unknown", r->unknown);
11947         ndr->depth--;
11948 }
11949
11950 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
11951 {
11952         if (ndr_flags & NDR_SCALARS) {
11953                 int level = ndr_push_get_switch_value(ndr, r);
11954                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
11955                 switch (level) {
11956                         case 1: {
11957                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
11958                         break; }
11959
11960                         default:
11961                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11962                 }
11963         }
11964         if (ndr_flags & NDR_BUFFERS) {
11965                 int level = ndr_push_get_switch_value(ndr, r);
11966                 switch (level) {
11967                         case 1:
11968                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
11969                         break;
11970
11971                         default:
11972                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11973                 }
11974         }
11975         return NDR_ERR_SUCCESS;
11976 }
11977
11978 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
11979 {
11980         int level;
11981         int32_t _level;
11982         level = ndr_pull_get_switch_value(ndr, r);
11983         if (ndr_flags & NDR_SCALARS) {
11984                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
11985                 if (_level != level) {
11986                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11987                 }
11988                 switch (level) {
11989                         case 1: {
11990                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
11991                         break; }
11992
11993                         default:
11994                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11995                 }
11996         }
11997         if (ndr_flags & NDR_BUFFERS) {
11998                 switch (level) {
11999                         case 1:
12000                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12001                         break;
12002
12003                         default:
12004                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12005                 }
12006         }
12007         return NDR_ERR_SUCCESS;
12008 }
12009
12010 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
12011 {
12012         int level;
12013         level = ndr_print_get_switch_value(ndr, r);
12014         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
12015         switch (level) {
12016                 case 1:
12017                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
12018                 break;
12019
12020                 default:
12021                         ndr_print_bad_level(ndr, name, level);
12022         }
12023 }
12024
12025 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
12026 {
12027         uint32_t cntr_site_to_1;
12028         if (ndr_flags & NDR_SCALARS) {
12029                 NDR_CHECK(ndr_push_align(ndr, 4));
12030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
12031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
12033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
12034         }
12035         if (ndr_flags & NDR_BUFFERS) {
12036                 if (r->site_from) {
12037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12038                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12039                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12040                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12041                 }
12042                 if (r->site_to) {
12043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12044                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12045                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
12046                         }
12047                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12048                                 if (r->site_to[cntr_site_to_1]) {
12049                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12050                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12051                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12052                                         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));
12053                                 }
12054                         }
12055                 }
12056         }
12057         return NDR_ERR_SUCCESS;
12058 }
12059
12060 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
12061 {
12062         uint32_t _ptr_site_from;
12063         TALLOC_CTX *_mem_save_site_from_0;
12064         uint32_t _ptr_site_to;
12065         uint32_t cntr_site_to_1;
12066         TALLOC_CTX *_mem_save_site_to_0;
12067         TALLOC_CTX *_mem_save_site_to_1;
12068         TALLOC_CTX *_mem_save_site_to_2;
12069         if (ndr_flags & NDR_SCALARS) {
12070                 NDR_CHECK(ndr_pull_align(ndr, 4));
12071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
12072                 if (_ptr_site_from) {
12073                         NDR_PULL_ALLOC(ndr, r->site_from);
12074                 } else {
12075                         r->site_from = NULL;
12076                 }
12077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12078                 if (r->num_req < 1 || r->num_req > 10000) {
12079                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12080                 }
12081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
12082                 if (_ptr_site_to) {
12083                         NDR_PULL_ALLOC(ndr, r->site_to);
12084                 } else {
12085                         r->site_to = NULL;
12086                 }
12087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
12088         }
12089         if (ndr_flags & NDR_BUFFERS) {
12090                 if (r->site_from) {
12091                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
12092                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
12093                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
12094                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
12095                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
12096                                 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));
12097                         }
12098                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
12099                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
12100                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
12101                 }
12102                 if (r->site_to) {
12103                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
12104                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
12105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
12106                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
12107                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
12108                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
12109                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12110                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
12111                                 if (_ptr_site_to) {
12112                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
12113                                 } else {
12114                                         r->site_to[cntr_site_to_1] = NULL;
12115                                 }
12116                         }
12117                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12118                                 if (r->site_to[cntr_site_to_1]) {
12119                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
12120                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
12121                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
12122                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
12123                                         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])) {
12124                                                 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]));
12125                                         }
12126                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
12127                                         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));
12128                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
12129                                 }
12130                         }
12131                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
12132                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
12133                 }
12134                 if (r->site_to) {
12135                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
12136                 }
12137         }
12138         return NDR_ERR_SUCCESS;
12139 }
12140
12141 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
12142 {
12143         uint32_t cntr_site_to_1;
12144         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
12145         ndr->depth++;
12146         ndr_print_ptr(ndr, "site_from", r->site_from);
12147         ndr->depth++;
12148         if (r->site_from) {
12149                 ndr_print_string(ndr, "site_from", r->site_from);
12150         }
12151         ndr->depth--;
12152         ndr_print_uint32(ndr, "num_req", r->num_req);
12153         ndr_print_ptr(ndr, "site_to", r->site_to);
12154         ndr->depth++;
12155         if (r->site_to) {
12156                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
12157                 ndr->depth++;
12158                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
12159                         char *idx_1=NULL;
12160                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
12161                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
12162                                 ndr->depth++;
12163                                 if (r->site_to[cntr_site_to_1]) {
12164                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
12165                                 }
12166                                 ndr->depth--;
12167                                 free(idx_1);
12168                         }
12169                 }
12170                 ndr->depth--;
12171         }
12172         ndr->depth--;
12173         ndr_print_uint32(ndr, "flags", r->flags);
12174         ndr->depth--;
12175 }
12176
12177 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
12178 {
12179         if (ndr_flags & NDR_SCALARS) {
12180                 int level = ndr_push_get_switch_value(ndr, r);
12181                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12182                 switch (level) {
12183                         case 1: {
12184                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
12185                         break; }
12186
12187                         default:
12188                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12189                 }
12190         }
12191         if (ndr_flags & NDR_BUFFERS) {
12192                 int level = ndr_push_get_switch_value(ndr, r);
12193                 switch (level) {
12194                         case 1:
12195                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
12196                         break;
12197
12198                         default:
12199                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12200                 }
12201         }
12202         return NDR_ERR_SUCCESS;
12203 }
12204
12205 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
12206 {
12207         int level;
12208         int32_t _level;
12209         level = ndr_pull_get_switch_value(ndr, r);
12210         if (ndr_flags & NDR_SCALARS) {
12211                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12212                 if (_level != level) {
12213                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12214                 }
12215                 switch (level) {
12216                         case 1: {
12217                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
12218                         break; }
12219
12220                         default:
12221                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12222                 }
12223         }
12224         if (ndr_flags & NDR_BUFFERS) {
12225                 switch (level) {
12226                         case 1:
12227                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
12228                         break;
12229
12230                         default:
12231                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12232                 }
12233         }
12234         return NDR_ERR_SUCCESS;
12235 }
12236
12237 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
12238 {
12239         int level;
12240         level = ndr_print_get_switch_value(ndr, r);
12241         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
12242         switch (level) {
12243                 case 1:
12244                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
12245                 break;
12246
12247                 default:
12248                         ndr_print_bad_level(ndr, name, level);
12249         }
12250 }
12251
12252 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
12253 {
12254         if (flags & NDR_IN) {
12255                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
12256                 if (r->in.bind_guid) {
12257                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
12258                 }
12259                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
12260                 if (r->in.bind_info) {
12261                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
12262                 }
12263         }
12264         if (flags & NDR_OUT) {
12265                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
12266                 if (r->out.bind_info) {
12267                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
12268                 }
12269                 if (r->out.bind_handle == NULL) {
12270                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12271                 }
12272                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12273                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12274         }
12275         return NDR_ERR_SUCCESS;
12276 }
12277
12278 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
12279 {
12280         uint32_t _ptr_bind_guid;
12281         uint32_t _ptr_bind_info;
12282         TALLOC_CTX *_mem_save_bind_guid_0;
12283         TALLOC_CTX *_mem_save_bind_info_0;
12284         TALLOC_CTX *_mem_save_bind_handle_0;
12285         if (flags & NDR_IN) {
12286                 ZERO_STRUCT(r->out);
12287
12288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
12289                 if (_ptr_bind_guid) {
12290                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
12291                 } else {
12292                         r->in.bind_guid = NULL;
12293                 }
12294                 if (r->in.bind_guid) {
12295                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
12296                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
12297                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
12298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
12299                 }
12300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
12301                 if (_ptr_bind_info) {
12302                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
12303                 } else {
12304                         r->in.bind_info = NULL;
12305                 }
12306                 if (r->in.bind_info) {
12307                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12308                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
12309                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
12310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
12311                 }
12312                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12313                 ZERO_STRUCTP(r->out.bind_handle);
12314         }
12315         if (flags & NDR_OUT) {
12316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
12317                 if (_ptr_bind_info) {
12318                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
12319                 } else {
12320                         r->out.bind_info = NULL;
12321                 }
12322                 if (r->out.bind_info) {
12323                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12324                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
12325                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
12326                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
12327                 }
12328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12329                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12330                 }
12331                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12332                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12333                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12335                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12336         }
12337         return NDR_ERR_SUCCESS;
12338 }
12339
12340 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
12341 {
12342         ndr_print_struct(ndr, name, "drsuapi_DsBind");
12343         ndr->depth++;
12344         if (flags & NDR_SET_VALUES) {
12345                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12346         }
12347         if (flags & NDR_IN) {
12348                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
12349                 ndr->depth++;
12350                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
12351                 ndr->depth++;
12352                 if (r->in.bind_guid) {
12353                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
12354                 }
12355                 ndr->depth--;
12356                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
12357                 ndr->depth++;
12358                 if (r->in.bind_info) {
12359                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
12360                 }
12361                 ndr->depth--;
12362                 ndr->depth--;
12363         }
12364         if (flags & NDR_OUT) {
12365                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
12366                 ndr->depth++;
12367                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
12368                 ndr->depth++;
12369                 if (r->out.bind_info) {
12370                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
12371                 }
12372                 ndr->depth--;
12373                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
12374                 ndr->depth++;
12375                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
12376                 ndr->depth--;
12377                 ndr_print_WERROR(ndr, "result", r->out.result);
12378                 ndr->depth--;
12379         }
12380         ndr->depth--;
12381 }
12382
12383 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
12384 {
12385         if (flags & NDR_IN) {
12386                 if (r->in.bind_handle == NULL) {
12387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12388                 }
12389                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12390         }
12391         if (flags & NDR_OUT) {
12392                 if (r->out.bind_handle == NULL) {
12393                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12394                 }
12395                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12397         }
12398         return NDR_ERR_SUCCESS;
12399 }
12400
12401 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
12402 {
12403         TALLOC_CTX *_mem_save_bind_handle_0;
12404         if (flags & NDR_IN) {
12405                 ZERO_STRUCT(r->out);
12406
12407                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12408                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
12409                 }
12410                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12411                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12412                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12414                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12415                 *r->out.bind_handle = *r->in.bind_handle;
12416         }
12417         if (flags & NDR_OUT) {
12418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12419                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12420                 }
12421                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12422                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12423                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12425                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12426         }
12427         return NDR_ERR_SUCCESS;
12428 }
12429
12430 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
12431 {
12432         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
12433         ndr->depth++;
12434         if (flags & NDR_SET_VALUES) {
12435                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12436         }
12437         if (flags & NDR_IN) {
12438                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
12439                 ndr->depth++;
12440                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
12441                 ndr->depth++;
12442                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
12443                 ndr->depth--;
12444                 ndr->depth--;
12445         }
12446         if (flags & NDR_OUT) {
12447                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
12448                 ndr->depth++;
12449                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
12450                 ndr->depth++;
12451                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
12452                 ndr->depth--;
12453                 ndr_print_WERROR(ndr, "result", r->out.result);
12454                 ndr->depth--;
12455         }
12456         ndr->depth--;
12457 }
12458
12459 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
12460 {
12461         if (flags & NDR_IN) {
12462                 if (r->in.bind_handle == NULL) {
12463                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12464                 }
12465                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12466                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
12467                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
12468                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
12469         }
12470         if (flags & NDR_OUT) {
12471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12472         }
12473         return NDR_ERR_SUCCESS;
12474 }
12475
12476 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
12477 {
12478         TALLOC_CTX *_mem_save_bind_handle_0;
12479         if (flags & NDR_IN) {
12480                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12481                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
12482                 }
12483                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12484                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12485                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12487                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
12488                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
12489                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
12490         }
12491         if (flags & NDR_OUT) {
12492                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12493         }
12494         return NDR_ERR_SUCCESS;
12495 }
12496
12497 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
12498 {
12499         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
12500         ndr->depth++;
12501         if (flags & NDR_SET_VALUES) {
12502                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12503         }
12504         if (flags & NDR_IN) {
12505                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
12506                 ndr->depth++;
12507                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
12508                 ndr->depth++;
12509                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
12510                 ndr->depth--;
12511                 ndr_print_int32(ndr, "level", r->in.level);
12512                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
12513                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
12514                 ndr->depth--;
12515         }
12516         if (flags & NDR_OUT) {
12517                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
12518                 ndr->depth++;
12519                 ndr_print_WERROR(ndr, "result", r->out.result);
12520                 ndr->depth--;
12521         }
12522         ndr->depth--;
12523 }
12524
12525 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
12526 {
12527         if (flags & NDR_IN) {
12528                 if (r->in.bind_handle == NULL) {
12529                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12530                 }
12531                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12532                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
12533                 if (r->in.req == NULL) {
12534                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12535                 }
12536                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
12537                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12538         }
12539         if (flags & NDR_OUT) {
12540                 if (r->out.level_out == NULL) {
12541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12542                 }
12543                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
12544                 if (r->out.ctr == NULL) {
12545                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12546                 }
12547                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
12548                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
12549                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12550         }
12551         return NDR_ERR_SUCCESS;
12552 }
12553
12554 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
12555 {
12556         TALLOC_CTX *_mem_save_bind_handle_0;
12557         TALLOC_CTX *_mem_save_req_0;
12558         TALLOC_CTX *_mem_save_level_out_0;
12559         TALLOC_CTX *_mem_save_ctr_0;
12560         if (flags & NDR_IN) {
12561                 ZERO_STRUCT(r->out);
12562
12563                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12564                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
12565                 }
12566                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12567                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12568                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12569                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12570                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
12571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12572                         NDR_PULL_ALLOC(ndr, r->in.req);
12573                 }
12574                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
12575                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
12576                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
12577                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
12579                 NDR_PULL_ALLOC(ndr, r->out.level_out);
12580                 ZERO_STRUCTP(r->out.level_out);
12581                 NDR_PULL_ALLOC(ndr, r->out.ctr);
12582                 ZERO_STRUCTP(r->out.ctr);
12583         }
12584         if (flags & NDR_OUT) {
12585                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12586                         NDR_PULL_ALLOC(ndr, r->out.level_out);
12587                 }
12588                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
12589                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
12590                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
12591                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
12592                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12593                         NDR_PULL_ALLOC(ndr, r->out.ctr);
12594                 }
12595                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12596                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
12597                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
12598                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
12599                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
12600                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12601         }
12602         return NDR_ERR_SUCCESS;
12603 }
12604
12605 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
12606 {
12607         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
12608         ndr->depth++;
12609         if (flags & NDR_SET_VALUES) {
12610                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12611         }
12612         if (flags & NDR_IN) {
12613                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
12614                 ndr->depth++;
12615                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
12616                 ndr->depth++;
12617                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
12618                 ndr->depth--;
12619                 ndr_print_int32(ndr, "level", r->in.level);
12620                 ndr_print_ptr(ndr, "req", r->in.req);
12621                 ndr->depth++;
12622                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
12623                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
12624                 ndr->depth--;
12625                 ndr->depth--;
12626         }
12627         if (flags & NDR_OUT) {
12628                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
12629                 ndr->depth++;
12630                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
12631                 ndr->depth++;
12632                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
12633                 ndr->depth--;
12634                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
12635                 ndr->depth++;
12636                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
12637                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
12638                 ndr->depth--;
12639                 ndr_print_WERROR(ndr, "result", r->out.result);
12640                 ndr->depth--;
12641         }
12642         ndr->depth--;
12643 }
12644
12645 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
12646 {
12647         if (flags & NDR_IN) {
12648                 if (r->in.bind_handle == NULL) {
12649                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12650                 }
12651                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12652                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
12653                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
12654                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
12655         }
12656         if (flags & NDR_OUT) {
12657                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12658         }
12659         return NDR_ERR_SUCCESS;
12660 }
12661
12662 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
12663 {
12664         TALLOC_CTX *_mem_save_bind_handle_0;
12665         if (flags & NDR_IN) {
12666                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12667                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
12668                 }
12669                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12670                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12671                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12672                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12673                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
12674                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
12675                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
12676         }
12677         if (flags & NDR_OUT) {
12678                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12679         }
12680         return NDR_ERR_SUCCESS;
12681 }
12682
12683 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
12684 {
12685         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
12686         ndr->depth++;
12687         if (flags & NDR_SET_VALUES) {
12688                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12689         }
12690         if (flags & NDR_IN) {
12691                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
12692                 ndr->depth++;
12693                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
12694                 ndr->depth++;
12695                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
12696                 ndr->depth--;
12697                 ndr_print_int32(ndr, "level", r->in.level);
12698                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
12699                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
12700                 ndr->depth--;
12701         }
12702         if (flags & NDR_OUT) {
12703                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
12704                 ndr->depth++;
12705                 ndr_print_WERROR(ndr, "result", r->out.result);
12706                 ndr->depth--;
12707         }
12708         ndr->depth--;
12709 }
12710
12711 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_ADD(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_ADD *r)
12712 {
12713         if (flags & NDR_IN) {
12714         }
12715         if (flags & NDR_OUT) {
12716                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12717         }
12718         return NDR_ERR_SUCCESS;
12719 }
12720
12721 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_ADD(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_ADD *r)
12722 {
12723         if (flags & NDR_IN) {
12724         }
12725         if (flags & NDR_OUT) {
12726                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12727         }
12728         return NDR_ERR_SUCCESS;
12729 }
12730
12731 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_ADD(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_ADD *r)
12732 {
12733         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_ADD");
12734         ndr->depth++;
12735         if (flags & NDR_SET_VALUES) {
12736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12737         }
12738         if (flags & NDR_IN) {
12739                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_ADD");
12740                 ndr->depth++;
12741                 ndr->depth--;
12742         }
12743         if (flags & NDR_OUT) {
12744                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_ADD");
12745                 ndr->depth++;
12746                 ndr_print_WERROR(ndr, "result", r->out.result);
12747                 ndr->depth--;
12748         }
12749         ndr->depth--;
12750 }
12751
12752 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_DEL(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_DEL *r)
12753 {
12754         if (flags & NDR_IN) {
12755         }
12756         if (flags & NDR_OUT) {
12757                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12758         }
12759         return NDR_ERR_SUCCESS;
12760 }
12761
12762 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_DEL(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_DEL *r)
12763 {
12764         if (flags & NDR_IN) {
12765         }
12766         if (flags & NDR_OUT) {
12767                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12768         }
12769         return NDR_ERR_SUCCESS;
12770 }
12771
12772 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_DEL(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_DEL *r)
12773 {
12774         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_DEL");
12775         ndr->depth++;
12776         if (flags & NDR_SET_VALUES) {
12777                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12778         }
12779         if (flags & NDR_IN) {
12780                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_DEL");
12781                 ndr->depth++;
12782                 ndr->depth--;
12783         }
12784         if (flags & NDR_OUT) {
12785                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_DEL");
12786                 ndr->depth++;
12787                 ndr_print_WERROR(ndr, "result", r->out.result);
12788                 ndr->depth--;
12789         }
12790         ndr->depth--;
12791 }
12792
12793 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_MODIFY(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_MODIFY *r)
12794 {
12795         if (flags & NDR_IN) {
12796         }
12797         if (flags & NDR_OUT) {
12798                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12799         }
12800         return NDR_ERR_SUCCESS;
12801 }
12802
12803 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_MODIFY(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_MODIFY *r)
12804 {
12805         if (flags & NDR_IN) {
12806         }
12807         if (flags & NDR_OUT) {
12808                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12809         }
12810         return NDR_ERR_SUCCESS;
12811 }
12812
12813 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_MODIFY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_MODIFY *r)
12814 {
12815         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_MODIFY");
12816         ndr->depth++;
12817         if (flags & NDR_SET_VALUES) {
12818                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12819         }
12820         if (flags & NDR_IN) {
12821                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_MODIFY");
12822                 ndr->depth++;
12823                 ndr->depth--;
12824         }
12825         if (flags & NDR_OUT) {
12826                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_MODIFY");
12827                 ndr->depth++;
12828                 ndr_print_WERROR(ndr, "result", r->out.result);
12829                 ndr->depth--;
12830         }
12831         ndr->depth--;
12832 }
12833
12834 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
12835 {
12836         if (flags & NDR_IN) {
12837         }
12838         if (flags & NDR_OUT) {
12839                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12840         }
12841         return NDR_ERR_SUCCESS;
12842 }
12843
12844 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
12845 {
12846         if (flags & NDR_IN) {
12847         }
12848         if (flags & NDR_OUT) {
12849                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12850         }
12851         return NDR_ERR_SUCCESS;
12852 }
12853
12854 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
12855 {
12856         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
12857         ndr->depth++;
12858         if (flags & NDR_SET_VALUES) {
12859                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12860         }
12861         if (flags & NDR_IN) {
12862                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
12863                 ndr->depth++;
12864                 ndr->depth--;
12865         }
12866         if (flags & NDR_OUT) {
12867                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
12868                 ndr->depth++;
12869                 ndr_print_WERROR(ndr, "result", r->out.result);
12870                 ndr->depth--;
12871         }
12872         ndr->depth--;
12873 }
12874
12875 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
12876 {
12877         if (flags & NDR_IN) {
12878                 if (r->in.bind_handle == NULL) {
12879                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12880                 }
12881                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12882                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
12883                 if (r->in.req == NULL) {
12884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12885                 }
12886                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
12887                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12888         }
12889         if (flags & NDR_OUT) {
12890                 if (r->out.level_out == NULL) {
12891                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12892                 }
12893                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
12894                 if (r->out.ctr == NULL) {
12895                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12896                 }
12897                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
12898                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
12899                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12900         }
12901         return NDR_ERR_SUCCESS;
12902 }
12903
12904 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
12905 {
12906         TALLOC_CTX *_mem_save_bind_handle_0;
12907         TALLOC_CTX *_mem_save_req_0;
12908         TALLOC_CTX *_mem_save_level_out_0;
12909         TALLOC_CTX *_mem_save_ctr_0;
12910         if (flags & NDR_IN) {
12911                 ZERO_STRUCT(r->out);
12912
12913                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12914                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
12915                 }
12916                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12917                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12918                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12919                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12920                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
12921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12922                         NDR_PULL_ALLOC(ndr, r->in.req);
12923                 }
12924                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
12925                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
12926                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
12927                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12928                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
12929                 NDR_PULL_ALLOC(ndr, r->out.level_out);
12930                 ZERO_STRUCTP(r->out.level_out);
12931                 NDR_PULL_ALLOC(ndr, r->out.ctr);
12932                 ZERO_STRUCTP(r->out.ctr);
12933         }
12934         if (flags & NDR_OUT) {
12935                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12936                         NDR_PULL_ALLOC(ndr, r->out.level_out);
12937                 }
12938                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
12939                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
12940                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
12941                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
12942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12943                         NDR_PULL_ALLOC(ndr, r->out.ctr);
12944                 }
12945                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12946                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
12947                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
12948                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
12949                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
12950                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12951         }
12952         return NDR_ERR_SUCCESS;
12953 }
12954
12955 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
12956 {
12957         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
12958         ndr->depth++;
12959         if (flags & NDR_SET_VALUES) {
12960                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12961         }
12962         if (flags & NDR_IN) {
12963                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
12964                 ndr->depth++;
12965                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
12966                 ndr->depth++;
12967                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
12968                 ndr->depth--;
12969                 ndr_print_int32(ndr, "level", r->in.level);
12970                 ndr_print_ptr(ndr, "req", r->in.req);
12971                 ndr->depth++;
12972                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
12973                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
12974                 ndr->depth--;
12975                 ndr->depth--;
12976         }
12977         if (flags & NDR_OUT) {
12978                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
12979                 ndr->depth++;
12980                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
12981                 ndr->depth++;
12982                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
12983                 ndr->depth--;
12984                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
12985                 ndr->depth++;
12986                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
12987                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
12988                 ndr->depth--;
12989                 ndr_print_WERROR(ndr, "result", r->out.result);
12990                 ndr->depth--;
12991         }
12992         ndr->depth--;
12993 }
12994
12995 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
12996 {
12997         if (flags & NDR_IN) {
12998         }
12999         if (flags & NDR_OUT) {
13000                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13001         }
13002         return NDR_ERR_SUCCESS;
13003 }
13004
13005 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13006 {
13007         if (flags & NDR_IN) {
13008         }
13009         if (flags & NDR_OUT) {
13010                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13011         }
13012         return NDR_ERR_SUCCESS;
13013 }
13014
13015 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13016 {
13017         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
13018         ndr->depth++;
13019         if (flags & NDR_SET_VALUES) {
13020                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13021         }
13022         if (flags & NDR_IN) {
13023                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
13024                 ndr->depth++;
13025                 ndr->depth--;
13026         }
13027         if (flags & NDR_OUT) {
13028                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
13029                 ndr->depth++;
13030                 ndr_print_WERROR(ndr, "result", r->out.result);
13031                 ndr->depth--;
13032         }
13033         ndr->depth--;
13034 }
13035
13036 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
13037 {
13038         if (flags & NDR_IN) {
13039                 if (r->in.bind_handle == NULL) {
13040                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13041                 }
13042                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13044                 if (r->in.req == NULL) {
13045                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13046                 }
13047                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13048                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13049         }
13050         if (flags & NDR_OUT) {
13051                 if (r->out.level_out == NULL) {
13052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13053                 }
13054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
13055                 if (r->out.info == NULL) {
13056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13057                 }
13058                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
13059                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13060                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13061         }
13062         return NDR_ERR_SUCCESS;
13063 }
13064
13065 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
13066 {
13067         TALLOC_CTX *_mem_save_bind_handle_0;
13068         TALLOC_CTX *_mem_save_req_0;
13069         TALLOC_CTX *_mem_save_level_out_0;
13070         TALLOC_CTX *_mem_save_info_0;
13071         if (flags & NDR_IN) {
13072                 ZERO_STRUCT(r->out);
13073
13074                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13075                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13076                 }
13077                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13078                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13079                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13080                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13082                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13083                         NDR_PULL_ALLOC(ndr, r->in.req);
13084                 }
13085                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13086                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13087                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13088                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13090                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13091                 ZERO_STRUCTP(r->out.level_out);
13092                 NDR_PULL_ALLOC(ndr, r->out.info);
13093                 ZERO_STRUCTP(r->out.info);
13094         }
13095         if (flags & NDR_OUT) {
13096                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13097                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13098                 }
13099                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13100                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
13102                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13103                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13104                         NDR_PULL_ALLOC(ndr, r->out.info);
13105                 }
13106                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13107                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
13108                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
13109                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
13111                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13112         }
13113         return NDR_ERR_SUCCESS;
13114 }
13115
13116 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
13117 {
13118         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
13119         ndr->depth++;
13120         if (flags & NDR_SET_VALUES) {
13121                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13122         }
13123         if (flags & NDR_IN) {
13124                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
13125                 ndr->depth++;
13126                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13127                 ndr->depth++;
13128                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13129                 ndr->depth--;
13130                 ndr_print_uint32(ndr, "level", r->in.level);
13131                 ndr_print_ptr(ndr, "req", r->in.req);
13132                 ndr->depth++;
13133                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13134                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
13135                 ndr->depth--;
13136                 ndr->depth--;
13137         }
13138         if (flags & NDR_OUT) {
13139                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
13140                 ndr->depth++;
13141                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13142                 ndr->depth++;
13143                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
13144                 ndr->depth--;
13145                 ndr_print_ptr(ndr, "info", r->out.info);
13146                 ndr->depth++;
13147                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
13148                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
13149                 ndr->depth--;
13150                 ndr_print_WERROR(ndr, "result", r->out.result);
13151                 ndr->depth--;
13152         }
13153         ndr->depth--;
13154 }
13155
13156 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
13157 {
13158         if (flags & NDR_IN) {
13159                 if (r->in.bind_handle == NULL) {
13160                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13161                 }
13162                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13163                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13164                 if (r->in.req == NULL) {
13165                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13166                 }
13167                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13168                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13169         }
13170         if (flags & NDR_OUT) {
13171                 if (r->out.level_out == NULL) {
13172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13173                 }
13174                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13175                 if (r->out.ctr == NULL) {
13176                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13177                 }
13178                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13179                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13180                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13181         }
13182         return NDR_ERR_SUCCESS;
13183 }
13184
13185 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
13186 {
13187         TALLOC_CTX *_mem_save_bind_handle_0;
13188         TALLOC_CTX *_mem_save_req_0;
13189         TALLOC_CTX *_mem_save_level_out_0;
13190         TALLOC_CTX *_mem_save_ctr_0;
13191         if (flags & NDR_IN) {
13192                 ZERO_STRUCT(r->out);
13193
13194                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13195                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13196                 }
13197                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13198                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13199                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13200                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13201                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13203                         NDR_PULL_ALLOC(ndr, r->in.req);
13204                 }
13205                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13207                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13208                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13210                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13211                 ZERO_STRUCTP(r->out.level_out);
13212                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13213                 ZERO_STRUCTP(r->out.ctr);
13214         }
13215         if (flags & NDR_OUT) {
13216                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13217                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13218                 }
13219                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13220                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13221                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13222                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13223                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13224                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13225                 }
13226                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13227                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13228                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13229                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13230                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13231                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13232         }
13233         return NDR_ERR_SUCCESS;
13234 }
13235
13236 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
13237 {
13238         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
13239         ndr->depth++;
13240         if (flags & NDR_SET_VALUES) {
13241                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13242         }
13243         if (flags & NDR_IN) {
13244                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
13245                 ndr->depth++;
13246                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13247                 ndr->depth++;
13248                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13249                 ndr->depth--;
13250                 ndr_print_int32(ndr, "level", r->in.level);
13251                 ndr_print_ptr(ndr, "req", r->in.req);
13252                 ndr->depth++;
13253                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13254                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
13255                 ndr->depth--;
13256                 ndr->depth--;
13257         }
13258         if (flags & NDR_OUT) {
13259                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
13260                 ndr->depth++;
13261                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13262                 ndr->depth++;
13263                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13264                 ndr->depth--;
13265                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13266                 ndr->depth++;
13267                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13268                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
13269                 ndr->depth--;
13270                 ndr_print_WERROR(ndr, "result", r->out.result);
13271                 ndr->depth--;
13272         }
13273         ndr->depth--;
13274 }
13275
13276 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
13277 {
13278         if (flags & NDR_IN) {
13279                 if (r->in.bind_handle == NULL) {
13280                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13281                 }
13282                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13283                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13284                 if (r->in.req == NULL) {
13285                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13286                 }
13287                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13288                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13289         }
13290         if (flags & NDR_OUT) {
13291                 if (r->out.level_out == NULL) {
13292                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13293                 }
13294                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13295                 if (r->out.res == NULL) {
13296                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13297                 }
13298                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
13299                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
13300                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13301         }
13302         return NDR_ERR_SUCCESS;
13303 }
13304
13305 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
13306 {
13307         TALLOC_CTX *_mem_save_bind_handle_0;
13308         TALLOC_CTX *_mem_save_req_0;
13309         TALLOC_CTX *_mem_save_level_out_0;
13310         TALLOC_CTX *_mem_save_res_0;
13311         if (flags & NDR_IN) {
13312                 ZERO_STRUCT(r->out);
13313
13314                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13315                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13316                 }
13317                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13318                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13319                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13320                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13321                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13322                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13323                         NDR_PULL_ALLOC(ndr, r->in.req);
13324                 }
13325                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13326                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13327                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13328                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13329                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13330                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13331                 ZERO_STRUCTP(r->out.level_out);
13332                 NDR_PULL_ALLOC(ndr, r->out.res);
13333                 ZERO_STRUCTP(r->out.res);
13334         }
13335         if (flags & NDR_OUT) {
13336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13337                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13338                 }
13339                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13340                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13341                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13343                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13344                         NDR_PULL_ALLOC(ndr, r->out.res);
13345                 }
13346                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
13347                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
13348                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
13349                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
13350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
13351                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13352         }
13353         return NDR_ERR_SUCCESS;
13354 }
13355
13356 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
13357 {
13358         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
13359         ndr->depth++;
13360         if (flags & NDR_SET_VALUES) {
13361                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13362         }
13363         if (flags & NDR_IN) {
13364                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
13365                 ndr->depth++;
13366                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13367                 ndr->depth++;
13368                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13369                 ndr->depth--;
13370                 ndr_print_int32(ndr, "level", r->in.level);
13371                 ndr_print_ptr(ndr, "req", r->in.req);
13372                 ndr->depth++;
13373                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13374                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
13375                 ndr->depth--;
13376                 ndr->depth--;
13377         }
13378         if (flags & NDR_OUT) {
13379                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
13380                 ndr->depth++;
13381                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13382                 ndr->depth++;
13383                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13384                 ndr->depth--;
13385                 ndr_print_ptr(ndr, "res", r->out.res);
13386                 ndr->depth++;
13387                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
13388                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
13389                 ndr->depth--;
13390                 ndr_print_WERROR(ndr, "result", r->out.result);
13391                 ndr->depth--;
13392         }
13393         ndr->depth--;
13394 }
13395
13396 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
13397 {
13398         if (flags & NDR_IN) {
13399                 if (r->in.bind_handle == NULL) {
13400                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13401                 }
13402                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13403                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13404                 if (r->in.req == NULL) {
13405                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13406                 }
13407                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13408                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13409         }
13410         if (flags & NDR_OUT) {
13411                 if (r->out.level_out == NULL) {
13412                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13413                 }
13414                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13415                 if (r->out.res == NULL) {
13416                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13417                 }
13418                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
13419                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
13420                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13421         }
13422         return NDR_ERR_SUCCESS;
13423 }
13424
13425 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
13426 {
13427         TALLOC_CTX *_mem_save_bind_handle_0;
13428         TALLOC_CTX *_mem_save_req_0;
13429         TALLOC_CTX *_mem_save_level_out_0;
13430         TALLOC_CTX *_mem_save_res_0;
13431         if (flags & NDR_IN) {
13432                 ZERO_STRUCT(r->out);
13433
13434                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13435                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13436                 }
13437                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13438                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13439                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13440                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13441                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13442                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13443                         NDR_PULL_ALLOC(ndr, r->in.req);
13444                 }
13445                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13446                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13447                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13448                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13450                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13451                 ZERO_STRUCTP(r->out.level_out);
13452                 NDR_PULL_ALLOC(ndr, r->out.res);
13453                 ZERO_STRUCTP(r->out.res);
13454         }
13455         if (flags & NDR_OUT) {
13456                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13457                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13458                 }
13459                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13460                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13461                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13463                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13464                         NDR_PULL_ALLOC(ndr, r->out.res);
13465                 }
13466                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
13467                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
13468                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
13469                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
13470                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
13471                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13472         }
13473         return NDR_ERR_SUCCESS;
13474 }
13475
13476 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
13477 {
13478         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
13479         ndr->depth++;
13480         if (flags & NDR_SET_VALUES) {
13481                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13482         }
13483         if (flags & NDR_IN) {
13484                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
13485                 ndr->depth++;
13486                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13487                 ndr->depth++;
13488                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13489                 ndr->depth--;
13490                 ndr_print_int32(ndr, "level", r->in.level);
13491                 ndr_print_ptr(ndr, "req", r->in.req);
13492                 ndr->depth++;
13493                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13494                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
13495                 ndr->depth--;
13496                 ndr->depth--;
13497         }
13498         if (flags & NDR_OUT) {
13499                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
13500                 ndr->depth++;
13501                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13502                 ndr->depth++;
13503                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13504                 ndr->depth--;
13505                 ndr_print_ptr(ndr, "res", r->out.res);
13506                 ndr->depth++;
13507                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
13508                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
13509                 ndr->depth--;
13510                 ndr_print_WERROR(ndr, "result", r->out.result);
13511                 ndr->depth--;
13512         }
13513         ndr->depth--;
13514 }
13515
13516 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
13517 {
13518         if (flags & NDR_IN) {
13519         }
13520         if (flags & NDR_OUT) {
13521                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13522         }
13523         return NDR_ERR_SUCCESS;
13524 }
13525
13526 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
13527 {
13528         if (flags & NDR_IN) {
13529         }
13530         if (flags & NDR_OUT) {
13531                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13532         }
13533         return NDR_ERR_SUCCESS;
13534 }
13535
13536 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
13537 {
13538         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
13539         ndr->depth++;
13540         if (flags & NDR_SET_VALUES) {
13541                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13542         }
13543         if (flags & NDR_IN) {
13544                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
13545                 ndr->depth++;
13546                 ndr->depth--;
13547         }
13548         if (flags & NDR_OUT) {
13549                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
13550                 ndr->depth++;
13551                 ndr_print_WERROR(ndr, "result", r->out.result);
13552                 ndr->depth--;
13553         }
13554         ndr->depth--;
13555 }
13556
13557 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
13558 {
13559         if (flags & NDR_IN) {
13560                 if (r->in.bind_handle == NULL) {
13561                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13562                 }
13563                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13564                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13565                 if (r->in.req == NULL) {
13566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13567                 }
13568                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13569                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13570         }
13571         if (flags & NDR_OUT) {
13572                 if (r->out.level_out == NULL) {
13573                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13574                 }
13575                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13576                 if (r->out.ctr == NULL) {
13577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13578                 }
13579                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13580                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13581                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13582         }
13583         return NDR_ERR_SUCCESS;
13584 }
13585
13586 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
13587 {
13588         TALLOC_CTX *_mem_save_bind_handle_0;
13589         TALLOC_CTX *_mem_save_req_0;
13590         TALLOC_CTX *_mem_save_level_out_0;
13591         TALLOC_CTX *_mem_save_ctr_0;
13592         if (flags & NDR_IN) {
13593                 ZERO_STRUCT(r->out);
13594
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                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13604                         NDR_PULL_ALLOC(ndr, r->in.req);
13605                 }
13606                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13607                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13608                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13609                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13610                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13611                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13612                 ZERO_STRUCTP(r->out.level_out);
13613                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13614                 ZERO_STRUCTP(r->out.ctr);
13615         }
13616         if (flags & NDR_OUT) {
13617                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13618                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13619                 }
13620                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13621                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13622                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13623                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13624                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13625                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13626                 }
13627                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13628                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13629                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13630                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13631                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13632                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13633         }
13634         return NDR_ERR_SUCCESS;
13635 }
13636
13637 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
13638 {
13639         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
13640         ndr->depth++;
13641         if (flags & NDR_SET_VALUES) {
13642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13643         }
13644         if (flags & NDR_IN) {
13645                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
13646                 ndr->depth++;
13647                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13648                 ndr->depth++;
13649                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13650                 ndr->depth--;
13651                 ndr_print_int32(ndr, "level", r->in.level);
13652                 ndr_print_ptr(ndr, "req", r->in.req);
13653                 ndr->depth++;
13654                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13655                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
13656                 ndr->depth--;
13657                 ndr->depth--;
13658         }
13659         if (flags & NDR_OUT) {
13660                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
13661                 ndr->depth++;
13662                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13663                 ndr->depth++;
13664                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13665                 ndr->depth--;
13666                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13667                 ndr->depth++;
13668                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13669                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
13670                 ndr->depth--;
13671                 ndr_print_WERROR(ndr, "result", r->out.result);
13672                 ndr->depth--;
13673         }
13674         ndr->depth--;
13675 }
13676
13677 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
13678 {
13679         if (flags & NDR_IN) {
13680                 if (r->in.bind_handle == NULL) {
13681                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13682                 }
13683                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13684                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13685                 if (r->in.req == NULL) {
13686                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13687                 }
13688                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13689                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13690         }
13691         if (flags & NDR_OUT) {
13692                 if (r->out.level_out == NULL) {
13693                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13694                 }
13695                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13696                 if (r->out.ctr == NULL) {
13697                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13698                 }
13699                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13700                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13701                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13702         }
13703         return NDR_ERR_SUCCESS;
13704 }
13705
13706 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
13707 {
13708         TALLOC_CTX *_mem_save_bind_handle_0;
13709         TALLOC_CTX *_mem_save_req_0;
13710         TALLOC_CTX *_mem_save_level_out_0;
13711         TALLOC_CTX *_mem_save_ctr_0;
13712         if (flags & NDR_IN) {
13713                 ZERO_STRUCT(r->out);
13714
13715                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13716                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13717                 }
13718                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13719                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13720                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13721                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13722                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13723                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13724                         NDR_PULL_ALLOC(ndr, r->in.req);
13725                 }
13726                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13727                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13728                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13729                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13730                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13731                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13732                 ZERO_STRUCTP(r->out.level_out);
13733                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13734                 ZERO_STRUCTP(r->out.ctr);
13735         }
13736         if (flags & NDR_OUT) {
13737                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13738                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13739                 }
13740                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13741                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13742                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13744                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13745                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13746                 }
13747                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13748                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13749                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13750                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13751                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13752                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13753         }
13754         return NDR_ERR_SUCCESS;
13755 }
13756
13757 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
13758 {
13759         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
13760         ndr->depth++;
13761         if (flags & NDR_SET_VALUES) {
13762                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13763         }
13764         if (flags & NDR_IN) {
13765                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
13766                 ndr->depth++;
13767                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13768                 ndr->depth++;
13769                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13770                 ndr->depth--;
13771                 ndr_print_int32(ndr, "level", r->in.level);
13772                 ndr_print_ptr(ndr, "req", r->in.req);
13773                 ndr->depth++;
13774                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13775                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
13776                 ndr->depth--;
13777                 ndr->depth--;
13778         }
13779         if (flags & NDR_OUT) {
13780                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
13781                 ndr->depth++;
13782                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13783                 ndr->depth++;
13784                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13785                 ndr->depth--;
13786                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13787                 ndr->depth++;
13788                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13789                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
13790                 ndr->depth--;
13791                 ndr_print_WERROR(ndr, "result", r->out.result);
13792                 ndr->depth--;
13793         }
13794         ndr->depth--;
13795 }
13796
13797 static enum ndr_err_code ndr_push_DRSUAPI_EXECUTE_KCC(struct ndr_push *ndr, int flags, const struct DRSUAPI_EXECUTE_KCC *r)
13798 {
13799         if (flags & NDR_IN) {
13800         }
13801         if (flags & NDR_OUT) {
13802                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13803         }
13804         return NDR_ERR_SUCCESS;
13805 }
13806
13807 static enum ndr_err_code ndr_pull_DRSUAPI_EXECUTE_KCC(struct ndr_pull *ndr, int flags, struct DRSUAPI_EXECUTE_KCC *r)
13808 {
13809         if (flags & NDR_IN) {
13810         }
13811         if (flags & NDR_OUT) {
13812                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13813         }
13814         return NDR_ERR_SUCCESS;
13815 }
13816
13817 _PUBLIC_ void ndr_print_DRSUAPI_EXECUTE_KCC(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_EXECUTE_KCC *r)
13818 {
13819         ndr_print_struct(ndr, name, "DRSUAPI_EXECUTE_KCC");
13820         ndr->depth++;
13821         if (flags & NDR_SET_VALUES) {
13822                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13823         }
13824         if (flags & NDR_IN) {
13825                 ndr_print_struct(ndr, "in", "DRSUAPI_EXECUTE_KCC");
13826                 ndr->depth++;
13827                 ndr->depth--;
13828         }
13829         if (flags & NDR_OUT) {
13830                 ndr_print_struct(ndr, "out", "DRSUAPI_EXECUTE_KCC");
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_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
13839 {
13840         if (flags & NDR_IN) {
13841                 if (r->in.bind_handle == NULL) {
13842                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13843                 }
13844                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13845                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
13846                 if (r->in.req == NULL) {
13847                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13848                 }
13849                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13850                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13851         }
13852         if (flags & NDR_OUT) {
13853                 if (r->out.info_type == NULL) {
13854                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13855                 }
13856                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
13857                 if (r->out.info == NULL) {
13858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13859                 }
13860                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
13861                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13862                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13863         }
13864         return NDR_ERR_SUCCESS;
13865 }
13866
13867 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
13868 {
13869         TALLOC_CTX *_mem_save_bind_handle_0;
13870         TALLOC_CTX *_mem_save_req_0;
13871         TALLOC_CTX *_mem_save_info_type_0;
13872         TALLOC_CTX *_mem_save_info_0;
13873         if (flags & NDR_IN) {
13874                 ZERO_STRUCT(r->out);
13875
13876                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13877                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13878                 }
13879                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13880                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13881                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13882                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13883                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
13884                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13885                         NDR_PULL_ALLOC(ndr, r->in.req);
13886                 }
13887                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13888                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13889                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13890                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13891                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13892                 NDR_PULL_ALLOC(ndr, r->out.info_type);
13893                 ZERO_STRUCTP(r->out.info_type);
13894                 NDR_PULL_ALLOC(ndr, r->out.info);
13895                 ZERO_STRUCTP(r->out.info);
13896         }
13897         if (flags & NDR_OUT) {
13898                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13899                         NDR_PULL_ALLOC(ndr, r->out.info_type);
13900                 }
13901                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
13902                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
13903                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
13904                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
13905                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13906                         NDR_PULL_ALLOC(ndr, r->out.info);
13907                 }
13908                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13909                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
13910                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
13911                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
13913                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13914         }
13915         return NDR_ERR_SUCCESS;
13916 }
13917
13918 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
13919 {
13920         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
13921         ndr->depth++;
13922         if (flags & NDR_SET_VALUES) {
13923                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13924         }
13925         if (flags & NDR_IN) {
13926                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
13927                 ndr->depth++;
13928                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13929                 ndr->depth++;
13930                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13931                 ndr->depth--;
13932                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
13933                 ndr_print_ptr(ndr, "req", r->in.req);
13934                 ndr->depth++;
13935                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13936                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
13937                 ndr->depth--;
13938                 ndr->depth--;
13939         }
13940         if (flags & NDR_OUT) {
13941                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
13942                 ndr->depth++;
13943                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
13944                 ndr->depth++;
13945                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
13946                 ndr->depth--;
13947                 ndr_print_ptr(ndr, "info", r->out.info);
13948                 ndr->depth++;
13949                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
13950                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
13951                 ndr->depth--;
13952                 ndr_print_WERROR(ndr, "result", r->out.result);
13953                 ndr->depth--;
13954         }
13955         ndr->depth--;
13956 }
13957
13958 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
13959 {
13960         if (flags & NDR_IN) {
13961         }
13962         if (flags & NDR_OUT) {
13963                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13964         }
13965         return NDR_ERR_SUCCESS;
13966 }
13967
13968 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
13969 {
13970         if (flags & NDR_IN) {
13971         }
13972         if (flags & NDR_OUT) {
13973                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13974         }
13975         return NDR_ERR_SUCCESS;
13976 }
13977
13978 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
13979 {
13980         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
13981         ndr->depth++;
13982         if (flags & NDR_SET_VALUES) {
13983                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13984         }
13985         if (flags & NDR_IN) {
13986                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
13987                 ndr->depth++;
13988                 ndr->depth--;
13989         }
13990         if (flags & NDR_OUT) {
13991                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
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_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
14000 {
14001         if (flags & NDR_IN) {
14002                 if (r->in.bind_handle == NULL) {
14003                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14004                 }
14005                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14006                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14007                 if (r->in.req == NULL) {
14008                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14009                 }
14010                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14011                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14012         }
14013         if (flags & NDR_OUT) {
14014                 if (r->out.level_out == NULL) {
14015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14016                 }
14017                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14018                 if (r->out.ctr == NULL) {
14019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14020                 }
14021                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14022                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14023                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14024         }
14025         return NDR_ERR_SUCCESS;
14026 }
14027
14028 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
14029 {
14030         TALLOC_CTX *_mem_save_bind_handle_0;
14031         TALLOC_CTX *_mem_save_req_0;
14032         TALLOC_CTX *_mem_save_level_out_0;
14033         TALLOC_CTX *_mem_save_ctr_0;
14034         if (flags & NDR_IN) {
14035                 ZERO_STRUCT(r->out);
14036
14037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14038                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14039                 }
14040                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14041                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14042                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14044                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14045                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14046                         NDR_PULL_ALLOC(ndr, r->in.req);
14047                 }
14048                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14049                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14050                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14051                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14053                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14054                 ZERO_STRUCTP(r->out.level_out);
14055                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14056                 ZERO_STRUCTP(r->out.ctr);
14057         }
14058         if (flags & NDR_OUT) {
14059                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14060                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14061                 }
14062                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14063                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14064                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14065                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14066                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14067                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14068                 }
14069                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14070                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14071                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14072                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14073                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14074                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14075         }
14076         return NDR_ERR_SUCCESS;
14077 }
14078
14079 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
14080 {
14081         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
14082         ndr->depth++;
14083         if (flags & NDR_SET_VALUES) {
14084                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14085         }
14086         if (flags & NDR_IN) {
14087                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
14088                 ndr->depth++;
14089                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14090                 ndr->depth++;
14091                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14092                 ndr->depth--;
14093                 ndr_print_int32(ndr, "level", r->in.level);
14094                 ndr_print_ptr(ndr, "req", r->in.req);
14095                 ndr->depth++;
14096                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14097                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
14098                 ndr->depth--;
14099                 ndr->depth--;
14100         }
14101         if (flags & NDR_OUT) {
14102                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
14103                 ndr->depth++;
14104                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14105                 ndr->depth++;
14106                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14107                 ndr->depth--;
14108                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14109                 ndr->depth++;
14110                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14111                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
14112                 ndr->depth--;
14113                 ndr_print_WERROR(ndr, "result", r->out.result);
14114                 ndr->depth--;
14115         }
14116         ndr->depth--;
14117 }
14118
14119 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14120 {
14121         if (flags & NDR_IN) {
14122         }
14123         if (flags & NDR_OUT) {
14124                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14125         }
14126         return NDR_ERR_SUCCESS;
14127 }
14128
14129 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14130 {
14131         if (flags & NDR_IN) {
14132         }
14133         if (flags & NDR_OUT) {
14134                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14135         }
14136         return NDR_ERR_SUCCESS;
14137 }
14138
14139 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14140 {
14141         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
14142         ndr->depth++;
14143         if (flags & NDR_SET_VALUES) {
14144                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14145         }
14146         if (flags & NDR_IN) {
14147                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
14148                 ndr->depth++;
14149                 ndr->depth--;
14150         }
14151         if (flags & NDR_OUT) {
14152                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
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_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
14161 {
14162         if (flags & NDR_IN) {
14163         }
14164         if (flags & NDR_OUT) {
14165                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14166         }
14167         return NDR_ERR_SUCCESS;
14168 }
14169
14170 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
14171 {
14172         if (flags & NDR_IN) {
14173         }
14174         if (flags & NDR_OUT) {
14175                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14176         }
14177         return NDR_ERR_SUCCESS;
14178 }
14179
14180 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
14181 {
14182         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
14183         ndr->depth++;
14184         if (flags & NDR_SET_VALUES) {
14185                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14186         }
14187         if (flags & NDR_IN) {
14188                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
14189                 ndr->depth++;
14190                 ndr->depth--;
14191         }
14192         if (flags & NDR_OUT) {
14193                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
14194                 ndr->depth++;
14195                 ndr_print_WERROR(ndr, "result", r->out.result);
14196                 ndr->depth--;
14197         }
14198         ndr->depth--;
14199 }
14200
14201 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
14202 {
14203         if (flags & NDR_IN) {
14204                 if (r->in.bind_handle == NULL) {
14205                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14206                 }
14207                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14208                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14209                 if (r->in.req == NULL) {
14210                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14211                 }
14212                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14213                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14214         }
14215         if (flags & NDR_OUT) {
14216                 if (r->out.level_out == NULL) {
14217                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14218                 }
14219                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14220                 if (r->out.ctr == NULL) {
14221                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14222                 }
14223                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14224                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14225                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14226         }
14227         return NDR_ERR_SUCCESS;
14228 }
14229
14230 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
14231 {
14232         TALLOC_CTX *_mem_save_bind_handle_0;
14233         TALLOC_CTX *_mem_save_req_0;
14234         TALLOC_CTX *_mem_save_level_out_0;
14235         TALLOC_CTX *_mem_save_ctr_0;
14236         if (flags & NDR_IN) {
14237                 ZERO_STRUCT(r->out);
14238
14239                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14240                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14241                 }
14242                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14243                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14244                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14245                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14246                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14247                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14248                         NDR_PULL_ALLOC(ndr, r->in.req);
14249                 }
14250                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14251                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14252                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14253                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14254                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14255                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14256                 ZERO_STRUCTP(r->out.level_out);
14257                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14258                 ZERO_STRUCTP(r->out.ctr);
14259         }
14260         if (flags & NDR_OUT) {
14261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14262                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14263                 }
14264                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14265                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14266                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14268                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14269                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14270                 }
14271                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14272                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14273                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14274                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14275                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14276                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14277         }
14278         return NDR_ERR_SUCCESS;
14279 }
14280
14281 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
14282 {
14283         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
14284         ndr->depth++;
14285         if (flags & NDR_SET_VALUES) {
14286                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14287         }
14288         if (flags & NDR_IN) {
14289                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
14290                 ndr->depth++;
14291                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14292                 ndr->depth++;
14293                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14294                 ndr->depth--;
14295                 ndr_print_int32(ndr, "level", r->in.level);
14296                 ndr_print_ptr(ndr, "req", r->in.req);
14297                 ndr->depth++;
14298                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14299                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
14300                 ndr->depth--;
14301                 ndr->depth--;
14302         }
14303         if (flags & NDR_OUT) {
14304                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
14305                 ndr->depth++;
14306                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14307                 ndr->depth++;
14308                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14309                 ndr->depth--;
14310                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14311                 ndr->depth++;
14312                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14313                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
14314                 ndr->depth--;
14315                 ndr_print_WERROR(ndr, "result", r->out.result);
14316                 ndr->depth--;
14317         }
14318         ndr->depth--;
14319 }
14320
14321 static const struct ndr_interface_call drsuapi_calls[] = {
14322         {
14323                 "drsuapi_DsBind",
14324                 sizeof(struct drsuapi_DsBind),
14325                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
14326                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
14327                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
14328                 false,
14329         },
14330         {
14331                 "drsuapi_DsUnbind",
14332                 sizeof(struct drsuapi_DsUnbind),
14333                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
14334                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
14335                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
14336                 false,
14337         },
14338         {
14339                 "drsuapi_DsReplicaSync",
14340                 sizeof(struct drsuapi_DsReplicaSync),
14341                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
14342                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
14343                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
14344                 false,
14345         },
14346         {
14347                 "drsuapi_DsGetNCChanges",
14348                 sizeof(struct drsuapi_DsGetNCChanges),
14349                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
14350                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
14351                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
14352                 false,
14353         },
14354         {
14355                 "drsuapi_DsReplicaUpdateRefs",
14356                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
14357                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
14358                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
14359                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
14360                 false,
14361         },
14362         {
14363                 "DRSUAPI_REPLICA_ADD",
14364                 sizeof(struct DRSUAPI_REPLICA_ADD),
14365                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_ADD,
14366                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_ADD,
14367                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_ADD,
14368                 false,
14369         },
14370         {
14371                 "DRSUAPI_REPLICA_DEL",
14372                 sizeof(struct DRSUAPI_REPLICA_DEL),
14373                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_DEL,
14374                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_DEL,
14375                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_DEL,
14376                 false,
14377         },
14378         {
14379                 "DRSUAPI_REPLICA_MODIFY",
14380                 sizeof(struct DRSUAPI_REPLICA_MODIFY),
14381                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_MODIFY,
14382                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_MODIFY,
14383                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_MODIFY,
14384                 false,
14385         },
14386         {
14387                 "DRSUAPI_VERIFY_NAMES",
14388                 sizeof(struct DRSUAPI_VERIFY_NAMES),
14389                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
14390                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
14391                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
14392                 false,
14393         },
14394         {
14395                 "drsuapi_DsGetMemberships",
14396                 sizeof(struct drsuapi_DsGetMemberships),
14397                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
14398                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
14399                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
14400                 false,
14401         },
14402         {
14403                 "DRSUAPI_INTER_DOMAIN_MOVE",
14404                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
14405                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
14406                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
14407                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
14408                 false,
14409         },
14410         {
14411                 "drsuapi_DsGetNT4ChangeLog",
14412                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
14413                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
14414                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
14415                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
14416                 false,
14417         },
14418         {
14419                 "drsuapi_DsCrackNames",
14420                 sizeof(struct drsuapi_DsCrackNames),
14421                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
14422                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
14423                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
14424                 false,
14425         },
14426         {
14427                 "drsuapi_DsWriteAccountSpn",
14428                 sizeof(struct drsuapi_DsWriteAccountSpn),
14429                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
14430                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
14431                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
14432                 false,
14433         },
14434         {
14435                 "drsuapi_DsRemoveDSServer",
14436                 sizeof(struct drsuapi_DsRemoveDSServer),
14437                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
14438                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
14439                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
14440                 false,
14441         },
14442         {
14443                 "DRSUAPI_REMOVE_DS_DOMAIN",
14444                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
14445                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
14446                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
14447                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
14448                 false,
14449         },
14450         {
14451                 "drsuapi_DsGetDomainControllerInfo",
14452                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
14453                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
14454                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
14455                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
14456                 false,
14457         },
14458         {
14459                 "drsuapi_DsAddEntry",
14460                 sizeof(struct drsuapi_DsAddEntry),
14461                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
14462                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
14463                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
14464                 false,
14465         },
14466         {
14467                 "DRSUAPI_EXECUTE_KCC",
14468                 sizeof(struct DRSUAPI_EXECUTE_KCC),
14469                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_EXECUTE_KCC,
14470                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_EXECUTE_KCC,
14471                 (ndr_print_function_t) ndr_print_DRSUAPI_EXECUTE_KCC,
14472                 false,
14473         },
14474         {
14475                 "drsuapi_DsReplicaGetInfo",
14476                 sizeof(struct drsuapi_DsReplicaGetInfo),
14477                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
14478                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
14479                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
14480                 false,
14481         },
14482         {
14483                 "DRSUAPI_ADD_SID_HISTORY",
14484                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
14485                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
14486                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
14487                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
14488                 false,
14489         },
14490         {
14491                 "drsuapi_DsGetMemberships2",
14492                 sizeof(struct drsuapi_DsGetMemberships2),
14493                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
14494                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
14495                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
14496                 false,
14497         },
14498         {
14499                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
14500                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
14501                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
14502                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
14503                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
14504                 false,
14505         },
14506         {
14507                 "DRSUAPI_GET_OBJECT_EXISTENCE",
14508                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
14509                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
14510                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
14511                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
14512                 false,
14513         },
14514         {
14515                 "drsuapi_QuerySitesByCost",
14516                 sizeof(struct drsuapi_QuerySitesByCost),
14517                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
14518                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
14519                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
14520                 false,
14521         },
14522         { NULL, 0, NULL, NULL, NULL, false }
14523 };
14524
14525 static const char * const drsuapi_endpoint_strings[] = {
14526         "ncacn_np:[\\pipe\\lsass]",
14527         "ncacn_np:[\\pipe\\protected_storage]",
14528         "ncacn_ip_tcp:",
14529         "ncalrpc:",
14530 };
14531
14532 static const struct ndr_interface_string_array drsuapi_endpoints = {
14533         .count  = 4,
14534         .names  = drsuapi_endpoint_strings
14535 };
14536
14537 static const char * const drsuapi_authservice_strings[] = {
14538         "ldap",
14539 };
14540
14541 static const struct ndr_interface_string_array drsuapi_authservices = {
14542         .count  = 1,
14543         .names  = drsuapi_authservice_strings
14544 };
14545
14546
14547 const struct ndr_interface_table ndr_table_drsuapi = {
14548         .name           = "drsuapi",
14549         .syntax_id      = {
14550                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
14551                 NDR_DRSUAPI_VERSION
14552         },
14553         .helpstring     = NDR_DRSUAPI_HELPSTRING,
14554         .num_calls      = 25,
14555         .calls          = drsuapi_calls,
14556         .endpoints      = &drsuapi_endpoints,
14557         .authservices   = &drsuapi_authservices
14558 };
14559