librpc/gen_ndr/ndr_drsuapi.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_drsuapi.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 #include "librpc/gen_ndr/ndr_misc.h"
   8 #include "librpc/gen_ndr/ndr_samr.h"
   9 #include "librpc/ndr/ndr_compression.h"
  10 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  11 {
  12         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  13         return NDR_ERR_SUCCESS;
  14 }
  15
  16 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  17 {
  18         uint32_t v;
  19         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  20         *r = v;
  21         return NDR_ERR_SUCCESS;
  22 }
  23
  24 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensions(struct ndr_print *ndr, const char *name, uint32_t r)
  25 {
  26         ndr_print_uint32(ndr, name, r);
  27         ndr->depth++;
  28         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_BASE", DRSUAPI_SUPPORTED_EXTENSION_BASE, r);
  29         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION, r);
  30         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI", DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI, r);
  31         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2", DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2, r);
  32         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS, r);
  33         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1, r);
  34         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION", DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION, r);
  35         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00000080", DRSUAPI_SUPPORTED_EXTENSION_00000080, r);
  36         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE", DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE, r);
  37         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2, r);
  38         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION, r);
  39         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2, r);
  40         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD", DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD, r);
  41         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND", DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND, r);
  42         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO", DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO, r);
  43         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION", DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION, r);
  44         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01, r);
  45         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP", DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP, r);
  46         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY", DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY, r);
  47         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3", DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3, r);
  48         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00100000", DRSUAPI_SUPPORTED_EXTENSION_00100000, r);
  49         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2", DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2, r);
  50         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6, r);
  51         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS", DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS, r);
  52         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8, r);
  53         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5, r);
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT", DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT, r);
  58         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS, r);
  59         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_20000000", DRSUAPI_SUPPORTED_EXTENSION_20000000, r);
  60         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_40000000", DRSUAPI_SUPPORTED_EXTENSION_40000000, r);
  61         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_80000000", DRSUAPI_SUPPORTED_EXTENSION_80000000, r);
  62         ndr->depth--;
  63 }
  64
  65 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensionsExt(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  66 {
  67         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  68         return NDR_ERR_SUCCESS;
  69 }
  70
  71 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensionsExt(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  72 {
  73         uint32_t v;
  74         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  75         *r = v;
  76         return NDR_ERR_SUCCESS;
  77 }
  78
  79 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensionsExt(struct ndr_print *ndr, const char *name, uint32_t r)
  80 {
  81         ndr_print_uint32(ndr, name, r);
  82         ndr->depth++;
  83         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADAM", DRSUAPI_SUPPORTED_EXTENSION_ADAM, r);
  84         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2", DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2, r);
  85         ndr->depth--;
  86 }
  87
  88 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo24 *r)
  89 {
  90         if (ndr_flags & NDR_SCALARS) {
  91                 NDR_CHECK(ndr_push_align(ndr, 4));
  92                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
  93                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
  94                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
  95         }
  96         if (ndr_flags & NDR_BUFFERS) {
  97         }
  98         return NDR_ERR_SUCCESS;
  99 }
 100
 101 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo24 *r)
 102 {
 103         if (ndr_flags & NDR_SCALARS) {
 104                 NDR_CHECK(ndr_pull_align(ndr, 4));
 105                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 106                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 108         }
 109         if (ndr_flags & NDR_BUFFERS) {
 110         }
 111         return NDR_ERR_SUCCESS;
 112 }
 113
 114 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r)
 115 {
 116         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo24");
 117         ndr->depth++;
 118         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 119         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 120         ndr_print_uint32(ndr, "pid", r->pid);
 121         ndr->depth--;
 122 }
 123
 124 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo28 *r)
 125 {
 126         if (ndr_flags & NDR_SCALARS) {
 127                 NDR_CHECK(ndr_push_align(ndr, 4));
 128                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 129                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 132         }
 133         if (ndr_flags & NDR_BUFFERS) {
 134         }
 135         return NDR_ERR_SUCCESS;
 136 }
 137
 138 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo28 *r)
 139 {
 140         if (ndr_flags & NDR_SCALARS) {
 141                 NDR_CHECK(ndr_pull_align(ndr, 4));
 142                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 143                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 146         }
 147         if (ndr_flags & NDR_BUFFERS) {
 148         }
 149         return NDR_ERR_SUCCESS;
 150 }
 151
 152 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo28(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo28 *r)
 153 {
 154         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo28");
 155         ndr->depth++;
 156         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 157         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 158         ndr_print_uint32(ndr, "pid", r->pid);
 159         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 160         ndr->depth--;
 161 }
 162
 163 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo48 *r)
 164 {
 165         if (ndr_flags & NDR_SCALARS) {
 166                 NDR_CHECK(ndr_push_align(ndr, 4));
 167                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 168                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 171                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
 172                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 173         }
 174         if (ndr_flags & NDR_BUFFERS) {
 175         }
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo48 *r)
 180 {
 181         if (ndr_flags & NDR_SCALARS) {
 182                 NDR_CHECK(ndr_pull_align(ndr, 4));
 183                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 184                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 187                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
 188                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 189         }
 190         if (ndr_flags & NDR_BUFFERS) {
 191         }
 192         return NDR_ERR_SUCCESS;
 193 }
 194
 195 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo48(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo48 *r)
 196 {
 197         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo48");
 198         ndr->depth++;
 199         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 200         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 201         ndr_print_uint32(ndr, "pid", r->pid);
 202         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 203         ndr_print_drsuapi_SupportedExtensionsExt(ndr, "supported_extensions_ext", r->supported_extensions_ext);
 204         ndr_print_GUID(ndr, "config_dn_guid", &r->config_dn_guid);
 205         ndr->depth--;
 206 }
 207
 208 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoFallBack *r)
 209 {
 210         if (ndr_flags & NDR_SCALARS) {
 211                 NDR_CHECK(ndr_push_align(ndr, 4));
 212                 {
 213                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 215                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
 216                         ndr->flags = _flags_save_DATA_BLOB;
 217                 }
 218         }
 219         if (ndr_flags & NDR_BUFFERS) {
 220         }
 221         return NDR_ERR_SUCCESS;
 222 }
 223
 224 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoFallBack *r)
 225 {
 226         if (ndr_flags & NDR_SCALARS) {
 227                 NDR_CHECK(ndr_pull_align(ndr, 4));
 228                 {
 229                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 231                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
 232                         ndr->flags = _flags_save_DATA_BLOB;
 233                 }
 234         }
 235         if (ndr_flags & NDR_BUFFERS) {
 236         }
 237         return NDR_ERR_SUCCESS;
 238 }
 239
 240 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoFallBack(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoFallBack *r)
 241 {
 242         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoFallBack");
 243         ndr->depth++;
 244         ndr_print_DATA_BLOB(ndr, "info", r->info);
 245         ndr->depth--;
 246 }
 247
 248 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
 249 {
 250         if (ndr_flags & NDR_SCALARS) {
 251                 int level = ndr_push_get_switch_value(ndr, r);
 252                 switch (level) {
 253                         case 24: {
 254                                 {
 255                                         struct ndr_push *_ndr_info24;
 256                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 4, -1));
 257                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 258                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 4, -1));
 259                                 }
 260                         break; }
 261
 262                         case 28: {
 263                                 {
 264                                         struct ndr_push *_ndr_info28;
 265                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 4, -1));
 266                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 267                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 4, -1));
 268                                 }
 269                         break; }
 270
 271                         case 48: {
 272                                 {
 273                                         struct ndr_push *_ndr_info48;
 274                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 4, -1));
 275                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 276                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 4, -1));
 277                                 }
 278                         break; }
 279
 280                         default: {
 281                                 {
 282                                         struct ndr_push *_ndr_FallBack;
 283                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 284                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 285                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 286                                 }
 287                         break; }
 288
 289                 }
 290         }
 291         if (ndr_flags & NDR_BUFFERS) {
 292                 int level = ndr_push_get_switch_value(ndr, r);
 293                 switch (level) {
 294                         case 24:
 295                         break;
 296
 297                         case 28:
 298                         break;
 299
 300                         case 48:
 301                         break;
 302
 303                         default:
 304                         break;
 305
 306                 }
 307         }
 308         return NDR_ERR_SUCCESS;
 309 }
 310
 311 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
 312 {
 313         int level;
 314         level = ndr_pull_get_switch_value(ndr, r);
 315         if (ndr_flags & NDR_SCALARS) {
 316                 switch (level) {
 317                         case 24: {
 318                                 {
 319                                         struct ndr_pull *_ndr_info24;
 320                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 4, -1));
 321                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 322                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 4, -1));
 323                                 }
 324                         break; }
 325
 326                         case 28: {
 327                                 {
 328                                         struct ndr_pull *_ndr_info28;
 329                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 4, -1));
 330                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 331                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 4, -1));
 332                                 }
 333                         break; }
 334
 335                         case 48: {
 336                                 {
 337                                         struct ndr_pull *_ndr_info48;
 338                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 4, -1));
 339                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 340                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 4, -1));
 341                                 }
 342                         break; }
 343
 344                         default: {
 345                                 {
 346                                         struct ndr_pull *_ndr_FallBack;
 347                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 348                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 349                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 350                                 }
 351                         break; }
 352
 353                 }
 354         }
 355         if (ndr_flags & NDR_BUFFERS) {
 356                 switch (level) {
 357                         case 24:
 358                         break;
 359
 360                         case 28:
 361                         break;
 362
 363                         case 48:
 364                         break;
 365
 366                         default:
 367                         break;
 368
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
 375 {
 376         int level;
 377         level = ndr_print_get_switch_value(ndr, r);
 378         ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
 379         switch (level) {
 380                 case 24:
 381                         ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
 382                 break;
 383
 384                 case 28:
 385                         ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
 386                 break;
 387
 388                 case 48:
 389                         ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
 390                 break;
 391
 392                 default:
 393                         ndr_print_drsuapi_DsBindInfoFallBack(ndr, "FallBack", &r->FallBack);
 394                 break;
 395
 396         }
 397 }
 398
 399 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoCtr *r)
 400 {
 401         if (ndr_flags & NDR_SCALARS) {
 402                 NDR_CHECK(ndr_push_align(ndr, 4));
 403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 404                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
 405                 NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 406         }
 407         if (ndr_flags & NDR_BUFFERS) {
 408         }
 409         return NDR_ERR_SUCCESS;
 410 }
 411
 412 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoCtr *r)
 413 {
 414         if (ndr_flags & NDR_SCALARS) {
 415                 NDR_CHECK(ndr_pull_align(ndr, 4));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 417                 if (r->length < 1 || r->length > 10000) {
 418                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 419                 }
 420                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
 421                 NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 422         }
 423         if (ndr_flags & NDR_BUFFERS) {
 424         }
 425         return NDR_ERR_SUCCESS;
 426 }
 427
 428 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoCtr *r)
 429 {
 430         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoCtr");
 431         ndr->depth++;
 432         ndr_print_uint32(ndr, "length", r->length);
 433         ndr_print_set_switch_value(ndr, &r->info, r->length);
 434         ndr_print_drsuapi_DsBindInfo(ndr, "info", &r->info);
 435         ndr->depth--;
 436 }
 437
 438 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 439 {
 440         if (ndr_flags & NDR_SCALARS) {
 441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
 442                 NDR_CHECK(ndr_push_align(ndr, 4));
 443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4));
 444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
 445                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 446                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
 448                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
 449         }
 450         if (ndr_flags & NDR_BUFFERS) {
 451                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 452         }
 453         return NDR_ERR_SUCCESS;
 454 }
 455
 456 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier *r)
 457 {
 458         uint32_t size_dn_0 = 0;
 459         if (ndr_flags & NDR_SCALARS) {
 460                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dn));
 461                 NDR_CHECK(ndr_pull_align(ndr, 4));
 462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
 463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
 464                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 465                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
 467                 size_dn_0 = ndr_get_array_size(ndr, &r->dn);
 468                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, size_dn_0, sizeof(uint16_t), CH_UTF16));
 469                 if (r->dn) {
 470                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
 471                 }
 472         }
 473         if (ndr_flags & NDR_BUFFERS) {
 474                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 475         }
 476         return NDR_ERR_SUCCESS;
 477 }
 478
 479 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier *r)
 480 {
 481         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier");
 482         ndr->depth++;
 483         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4:r->__ndr_size);
 484         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);
 485         ndr_print_GUID(ndr, "guid", &r->guid);
 486         ndr_print_dom_sid28(ndr, "sid", &r->sid);
 487         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
 488         ndr_print_string(ndr, "dn", r->dn);
 489         ndr->depth--;
 490 }
 491
 492 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, struct smb_iconv_convenience *ic, int flags)
 493 {
 494         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier, ic);
 495 }
 496
 497 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 498 {
 499         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 500         return NDR_ERR_SUCCESS;
 501 }
 502
 503 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 504 {
 505         uint32_t v;
 506         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 507         *r = v;
 508         return NDR_ERR_SUCCESS;
 509 }
 510
 511 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, const char *name, uint32_t r)
 512 {
 513         ndr_print_uint32(ndr, name, r);
 514         ndr->depth++;
 515         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION, r);
 516         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_WRITEABLE", DRSUAPI_DS_REPLICA_SYNC_WRITEABLE, r);
 517         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PERIODIC", DRSUAPI_DS_REPLICA_SYNC_PERIODIC, r);
 518         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING", DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING, r);
 519         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES", DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES, r);
 520         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL", DRSUAPI_DS_REPLICA_SYNC_FULL, r);
 521         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_URGENT", DRSUAPI_DS_REPLICA_SYNC_URGENT, r);
 522         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD", DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD, r);
 523         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FORCE", DRSUAPI_DS_REPLICA_SYNC_FORCE, r);
 524         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE", DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE, r);
 525         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED", DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED, r);
 526         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_TWO_WAY", DRSUAPI_DS_REPLICA_SYNC_TWO_WAY, r);
 527         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY", DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY, r);
 528         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL", DRSUAPI_DS_REPLICA_SYNC_INITIAL, r);
 529         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION", DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION, r);
 530         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ABANDONED", DRSUAPI_DS_REPLICA_SYNC_ABANDONED, r);
 531         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS, r);
 532         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET, r);
 533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_REQUEUE", DRSUAPI_DS_REPLICA_SYNC_REQUEUE, r);
 534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION", DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION, r);
 535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA, r);
 536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_CRITICAL", DRSUAPI_DS_REPLICA_SYNC_CRITICAL, r);
 537         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS, r);
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PREEMPTED", DRSUAPI_DS_REPLICA_SYNC_PREEMPTED, r);
 539         ndr->depth--;
 540 }
 541
 542 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 543 {
 544         if (ndr_flags & NDR_SCALARS) {
 545                 NDR_CHECK(ndr_push_align(ndr, 4));
 546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
 547                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 548                 {
 549                         uint32_t _flags_save_string = ndr->flags;
 550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 551                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
 552                         ndr->flags = _flags_save_string;
 553                 }
 554                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->options));
 555         }
 556         if (ndr_flags & NDR_BUFFERS) {
 557                 if (r->naming_context) {
 558                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 559                 }
 560                 {
 561                         uint32_t _flags_save_string = ndr->flags;
 562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 563                         if (r->other_info) {
 564                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->other_info));
 565                         }
 566                         ndr->flags = _flags_save_string;
 567                 }
 568         }
 569         return NDR_ERR_SUCCESS;
 570 }
 571
 572 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 573 {
 574         uint32_t _ptr_naming_context;
 575         TALLOC_CTX *_mem_save_naming_context_0;
 576         uint32_t _ptr_other_info;
 577         TALLOC_CTX *_mem_save_other_info_0;
 578         if (ndr_flags & NDR_SCALARS) {
 579                 NDR_CHECK(ndr_pull_align(ndr, 4));
 580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
 581                 if (_ptr_naming_context) {
 582                         NDR_PULL_ALLOC(ndr, r->naming_context);
 583                 } else {
 584                         r->naming_context = NULL;
 585                 }
 586                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 587                 {
 588                         uint32_t _flags_save_string = ndr->flags;
 589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 590                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 591                         if (_ptr_other_info) {
 592                                 NDR_PULL_ALLOC(ndr, r->other_info);
 593                         } else {
 594                                 r->other_info = NULL;
 595                         }
 596                         ndr->flags = _flags_save_string;
 597                 }
 598                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->options));
 599         }
 600         if (ndr_flags & NDR_BUFFERS) {
 601                 if (r->naming_context) {
 602                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 603                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 604                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 606                 }
 607                 {
 608                         uint32_t _flags_save_string = ndr->flags;
 609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 610                         if (r->other_info) {
 611                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 612                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 613                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->other_info));
 614                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 615                         }
 616                         ndr->flags = _flags_save_string;
 617                 }
 618         }
 619         return NDR_ERR_SUCCESS;
 620 }
 621
 622 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 623 {
 624         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 625         ndr->depth++;
 626         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 627         ndr->depth++;
 628         if (r->naming_context) {
 629                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 630         }
 631         ndr->depth--;
 632         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 633         ndr_print_ptr(ndr, "other_info", r->other_info);
 634         ndr->depth++;
 635         if (r->other_info) {
 636                 ndr_print_string(ndr, "other_info", r->other_info);
 637         }
 638         ndr->depth--;
 639         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "options", r->options);
 640         ndr->depth--;
 641 }
 642
 643 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 644 {
 645         if (ndr_flags & NDR_SCALARS) {
 646                 int level = ndr_push_get_switch_value(ndr, r);
 647                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
 648                 switch (level) {
 649                         case 1: {
 650                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 651                         break; }
 652
 653                         default:
 654                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 655                 }
 656         }
 657         if (ndr_flags & NDR_BUFFERS) {
 658                 int level = ndr_push_get_switch_value(ndr, r);
 659                 switch (level) {
 660                         case 1:
 661                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 662                         break;
 663
 664                         default:
 665                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 666                 }
 667         }
 668         return NDR_ERR_SUCCESS;
 669 }
 670
 671 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaSyncRequest *r)
 672 {
 673         int level;
 674         int32_t _level;
 675         level = ndr_pull_get_switch_value(ndr, r);
 676         if (ndr_flags & NDR_SCALARS) {
 677                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
 678                 if (_level != level) {
 679                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 680                 }
 681                 switch (level) {
 682                         case 1: {
 683                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 684                         break; }
 685
 686                         default:
 687                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 688                 }
 689         }
 690         if (ndr_flags & NDR_BUFFERS) {
 691                 switch (level) {
 692                         case 1:
 693                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 694                         break;
 695
 696                         default:
 697                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 698                 }
 699         }
 700         return NDR_ERR_SUCCESS;
 701 }
 702
 703 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 704 {
 705         int level;
 706         level = ndr_print_get_switch_value(ndr, r);
 707         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 708         switch (level) {
 709                 case 1:
 710                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 711                 break;
 712
 713                 default:
 714                         ndr_print_bad_level(ndr, name, level);
 715         }
 716 }
 717
 718 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 719 {
 720         if (ndr_flags & NDR_SCALARS) {
 721                 NDR_CHECK(ndr_push_align(ndr, 8));
 722                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 723                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 724                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 725         }
 726         if (ndr_flags & NDR_BUFFERS) {
 727         }
 728         return NDR_ERR_SUCCESS;
 729 }
 730
 731 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 732 {
 733         if (ndr_flags & NDR_SCALARS) {
 734                 NDR_CHECK(ndr_pull_align(ndr, 8));
 735                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 736                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 737                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 738         }
 739         if (ndr_flags & NDR_BUFFERS) {
 740         }
 741         return NDR_ERR_SUCCESS;
 742 }
 743
 744 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 745 {
 746         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 747         ndr->depth++;
 748         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 749         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 750         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 751         ndr->depth--;
 752 }
 753
 754 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 755 {
 756         if (ndr_flags & NDR_SCALARS) {
 757                 NDR_CHECK(ndr_push_align(ndr, 8));
 758                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 759                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 760         }
 761         if (ndr_flags & NDR_BUFFERS) {
 762         }
 763         return NDR_ERR_SUCCESS;
 764 }
 765
 766 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 NDR_CHECK(ndr_pull_align(ndr, 8));
 770                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 771                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 772         }
 773         if (ndr_flags & NDR_BUFFERS) {
 774         }
 775         return NDR_ERR_SUCCESS;
 776 }
 777
 778 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 779 {
 780         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 781         ndr->depth++;
 782         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 783         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 784         ndr->depth--;
 785 }
 786
 787 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 788 {
 789         uint32_t cntr_cursors_0;
 790         if (ndr_flags & NDR_SCALARS) {
 791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 792                 NDR_CHECK(ndr_push_align(ndr, 8));
 793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 797                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 798                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 799                 }
 800         }
 801         if (ndr_flags & NDR_BUFFERS) {
 802         }
 803         return NDR_ERR_SUCCESS;
 804 }
 805
 806 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 807 {
 808         uint32_t size_cursors_0 = 0;
 809         uint32_t cntr_cursors_0;
 810         TALLOC_CTX *_mem_save_cursors_0;
 811         if (ndr_flags & NDR_SCALARS) {
 812                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 813                 NDR_CHECK(ndr_pull_align(ndr, 8));
 814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 817                 if (r->count > 0x100000) {
 818                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 819                 }
 820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 821                 size_cursors_0 = ndr_get_array_size(ndr, &r->cursors);
 822                 NDR_PULL_ALLOC_N(ndr, r->cursors, size_cursors_0);
 823                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 824                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 825                 for (cntr_cursors_0 = 0; cntr_cursors_0 < size_cursors_0; cntr_cursors_0++) {
 826                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 827                 }
 828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 829                 if (r->cursors) {
 830                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 831                 }
 832         }
 833         if (ndr_flags & NDR_BUFFERS) {
 834         }
 835         return NDR_ERR_SUCCESS;
 836 }
 837
 838 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 839 {
 840         uint32_t cntr_cursors_0;
 841         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 842         ndr->depth++;
 843         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 844         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 845         ndr_print_uint32(ndr, "count", r->count);
 846         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 847         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 848         ndr->depth++;
 849         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 850                 char *idx_0=NULL;
 851                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 852                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 853                         free(idx_0);
 854                 }
 855         }
 856         ndr->depth--;
 857         ndr->depth--;
 858 }
 859
 860 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 861 {
 862         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 863         return NDR_ERR_SUCCESS;
 864 }
 865
 866 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 867 {
 868         uint32_t v;
 869         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 870         *r = v;
 871         return NDR_ERR_SUCCESS;
 872 }
 873
 874 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 875 {
 876         ndr_print_uint32(ndr, name, r);
 877         ndr->depth++;
 878         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE", DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE, r);
 879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP", DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP, r);
 880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS", DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS, r);
 881         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);
 882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC, r);
 883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS", DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS, r);
 884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS, r);
 885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_NEXT_PACKET", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_NEXT_PACKET, r);
 886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED", DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED, r);
 887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED", DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED, r);
 888         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS, r);
 889         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC, r);
 890         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES", DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES, r);
 891         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS, r);
 892         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET, r);
 893         ndr->depth--;
 894 }
 895
 896 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 897 {
 898         {
 899                 uint32_t _flags_save_ENUM = ndr->flags;
 900                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 902                 ndr->flags = _flags_save_ENUM;
 903         }
 904         return NDR_ERR_SUCCESS;
 905 }
 906
 907 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 908 {
 909         uint32_t v;
 910         {
 911                 uint32_t _flags_save_ENUM = ndr->flags;
 912                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 914                 *r = v;
 915                 ndr->flags = _flags_save_ENUM;
 916         }
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 921 {
 922         const char *val = NULL;
 923
 924         {
 925                 uint32_t _flags_save_ENUM = ndr->flags;
 926                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 927                 switch (r) {
 928                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
 929                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
 930                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
 931                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
 932                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
 933                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
 934                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
 935                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
 936                 }
 937                 ndr_print_enum(ndr, name, "ENUM", val, r);
 938                 ndr->flags = _flags_save_ENUM;
 939         }
 940 }
 941
 942 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
 943 {
 944         {
 945                 uint32_t _flags_save_ENUM = ndr->flags;
 946                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 948                 ndr->flags = _flags_save_ENUM;
 949         }
 950         return NDR_ERR_SUCCESS;
 951 }
 952
 953 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
 954 {
 955         uint32_t v;
 956         {
 957                 uint32_t _flags_save_ENUM = ndr->flags;
 958                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 960                 *r = v;
 961                 ndr->flags = _flags_save_ENUM;
 962         }
 963         return NDR_ERR_SUCCESS;
 964 }
 965
 966 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
 967 {
 968         const char *val = NULL;
 969
 970         {
 971                 uint32_t _flags_save_ENUM = ndr->flags;
 972                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 973                 switch (r) {
 974                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
 975                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
 976                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
 977                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
 978                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
 979                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
 980                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
 981                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
 982                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
 983                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
 984                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
 985                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
 986                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
 987                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
 988                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
 989                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
 990                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
 991                 }
 992                 ndr_print_enum(ndr, name, "ENUM", val, r);
 993                 ndr->flags = _flags_save_ENUM;
 994         }
 995 }
 996
 997 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
 998 {
 999         if (ndr_flags & NDR_SCALARS) {
1000                 NDR_CHECK(ndr_push_align(ndr, 8));
1001                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1002                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1003                 if (r->naming_context == NULL) {
1004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1005                 }
1006                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1007                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1009                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1012                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1013                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1014         }
1015         if (ndr_flags & NDR_BUFFERS) {
1016                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1017                 if (r->uptodateness_vector) {
1018                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1019                 }
1020         }
1021         return NDR_ERR_SUCCESS;
1022 }
1023
1024 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1025 {
1026         uint32_t _ptr_naming_context;
1027         TALLOC_CTX *_mem_save_naming_context_0;
1028         uint32_t _ptr_uptodateness_vector;
1029         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1030         if (ndr_flags & NDR_SCALARS) {
1031                 NDR_CHECK(ndr_pull_align(ndr, 8));
1032                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1033                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1034                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1035                 if (_ptr_naming_context) {
1036                         NDR_PULL_ALLOC(ndr, r->naming_context);
1037                 } else {
1038                         r->naming_context = NULL;
1039                 }
1040                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1042                 if (_ptr_uptodateness_vector) {
1043                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1044                 } else {
1045                         r->uptodateness_vector = NULL;
1046                 }
1047                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1050                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1051                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1052         }
1053         if (ndr_flags & NDR_BUFFERS) {
1054                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1055                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1056                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1057                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1058                 if (r->uptodateness_vector) {
1059                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1060                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1061                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1063                 }
1064         }
1065         return NDR_ERR_SUCCESS;
1066 }
1067
1068 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1069 {
1070         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1071         ndr->depth++;
1072         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1073         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1074         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1075         ndr->depth++;
1076         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1077         ndr->depth--;
1078         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1079         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1080         ndr->depth++;
1081         if (r->uptodateness_vector) {
1082                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1083         }
1084         ndr->depth--;
1085         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1086         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1087         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1088         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1089         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1090         ndr->depth--;
1091 }
1092
1093 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
1094 {
1095         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
1096         ndr->depth++;
1097         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaOID_oid(r->oid, 0):r->__ndr_size);
1098         ndr_print_ptr(ndr, "oid", r->oid);
1099         ndr->depth++;
1100         if (r->oid) {
1101                 ndr_print_string(ndr, "oid", r->oid);
1102         }
1103         ndr->depth--;
1104         ndr->depth--;
1105 }
1106
1107 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1108 {
1109         if (ndr_flags & NDR_SCALARS) {
1110                 NDR_CHECK(ndr_push_align(ndr, 4));
1111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1112                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1113         }
1114         if (ndr_flags & NDR_BUFFERS) {
1115                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1116         }
1117         return NDR_ERR_SUCCESS;
1118 }
1119
1120 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1121 {
1122         if (ndr_flags & NDR_SCALARS) {
1123                 NDR_CHECK(ndr_pull_align(ndr, 4));
1124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1125                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1126         }
1127         if (ndr_flags & NDR_BUFFERS) {
1128                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1129         }
1130         return NDR_ERR_SUCCESS;
1131 }
1132
1133 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1134 {
1135         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1136         ndr->depth++;
1137         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1138         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1139         ndr->depth--;
1140 }
1141
1142 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1143 {
1144         uint32_t cntr_mappings_1;
1145         if (ndr_flags & NDR_SCALARS) {
1146                 NDR_CHECK(ndr_push_align(ndr, 4));
1147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1149         }
1150         if (ndr_flags & NDR_BUFFERS) {
1151                 if (r->mappings) {
1152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1153                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1154                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1155                         }
1156                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1157                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1158                         }
1159                 }
1160         }
1161         return NDR_ERR_SUCCESS;
1162 }
1163
1164 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1165 {
1166         uint32_t _ptr_mappings;
1167         uint32_t size_mappings_1 = 0;
1168         uint32_t cntr_mappings_1;
1169         TALLOC_CTX *_mem_save_mappings_0;
1170         TALLOC_CTX *_mem_save_mappings_1;
1171         if (ndr_flags & NDR_SCALARS) {
1172                 NDR_CHECK(ndr_pull_align(ndr, 4));
1173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1174                 if (r->num_mappings > 0x100000) {
1175                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1176                 }
1177                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1178                 if (_ptr_mappings) {
1179                         NDR_PULL_ALLOC(ndr, r->mappings);
1180                 } else {
1181                         r->mappings = NULL;
1182                 }
1183         }
1184         if (ndr_flags & NDR_BUFFERS) {
1185                 if (r->mappings) {
1186                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1187                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1188                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1189                         size_mappings_1 = ndr_get_array_size(ndr, &r->mappings);
1190                         NDR_PULL_ALLOC_N(ndr, r->mappings, size_mappings_1);
1191                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1192                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1193                         for (cntr_mappings_1 = 0; cntr_mappings_1 < size_mappings_1; cntr_mappings_1++) {
1194                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1195                         }
1196                         for (cntr_mappings_1 = 0; cntr_mappings_1 < size_mappings_1; cntr_mappings_1++) {
1197                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1198                         }
1199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1201                 }
1202                 if (r->mappings) {
1203                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1204                 }
1205         }
1206         return NDR_ERR_SUCCESS;
1207 }
1208
1209 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1210 {
1211         uint32_t cntr_mappings_1;
1212         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1213         ndr->depth++;
1214         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1215         ndr_print_ptr(ndr, "mappings", r->mappings);
1216         ndr->depth++;
1217         if (r->mappings) {
1218                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1219                 ndr->depth++;
1220                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1221                         char *idx_1=NULL;
1222                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1223                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1224                                 free(idx_1);
1225                         }
1226                 }
1227                 ndr->depth--;
1228         }
1229         ndr->depth--;
1230         ndr->depth--;
1231 }
1232
1233 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1234 {
1235         {
1236                 uint32_t _flags_save_ENUM = ndr->flags;
1237                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1239                 ndr->flags = _flags_save_ENUM;
1240         }
1241         return NDR_ERR_SUCCESS;
1242 }
1243
1244 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1245 {
1246         uint32_t v;
1247         {
1248                 uint32_t _flags_save_ENUM = ndr->flags;
1249                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1251                 *r = v;
1252                 ndr->flags = _flags_save_ENUM;
1253         }
1254         return NDR_ERR_SUCCESS;
1255 }
1256
1257 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1258 {
1259         const char *val = NULL;
1260
1261         {
1262                 uint32_t _flags_save_ENUM = ndr->flags;
1263                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1264                 switch (r) {
1265                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1266                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1267                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1268                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1269                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1270                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1271                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1272                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1273                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1274                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1275                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1276                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1277                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1278                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1279                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1280                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1281                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1282                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1283                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1284                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1285                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1286                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1287                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1288                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1289                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1290                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1291                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1292                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1293                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1294                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1295                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1296                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1297                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1298                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1299                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1300                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1301                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1302                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1303                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1304                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1305                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1306                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1307                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1308                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1309                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1310                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1311                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1312                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1313                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1314                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1315                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1316                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1317                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1318                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1319                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1320                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1321                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1322                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1323                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1324                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1325                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1326                 }
1327                 ndr_print_enum(ndr, name, "ENUM", val, r);
1328                 ndr->flags = _flags_save_ENUM;
1329         }
1330 }
1331
1332 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1333 {
1334         uint32_t cntr_attids_0;
1335         if (ndr_flags & NDR_SCALARS) {
1336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1337                 NDR_CHECK(ndr_push_align(ndr, 4));
1338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1341                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1342                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1343                 }
1344         }
1345         if (ndr_flags & NDR_BUFFERS) {
1346         }
1347         return NDR_ERR_SUCCESS;
1348 }
1349
1350 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1351 {
1352         uint32_t size_attids_0 = 0;
1353         uint32_t cntr_attids_0;
1354         TALLOC_CTX *_mem_save_attids_0;
1355         if (ndr_flags & NDR_SCALARS) {
1356                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1357                 NDR_CHECK(ndr_pull_align(ndr, 4));
1358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1361                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1362                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1363                 }
1364                 size_attids_0 = ndr_get_array_size(ndr, &r->attids);
1365                 NDR_PULL_ALLOC_N(ndr, r->attids, size_attids_0);
1366                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1367                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1368                 for (cntr_attids_0 = 0; cntr_attids_0 < size_attids_0; cntr_attids_0++) {
1369                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1370                 }
1371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1372                 if (r->attids) {
1373                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1374                 }
1375         }
1376         if (ndr_flags & NDR_BUFFERS) {
1377         }
1378         return NDR_ERR_SUCCESS;
1379 }
1380
1381 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1382 {
1383         uint32_t cntr_attids_0;
1384         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1385         ndr->depth++;
1386         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1387         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1388         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1389         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1390         ndr->depth++;
1391         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1392                 char *idx_0=NULL;
1393                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1394                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1395                         free(idx_0);
1396                 }
1397         }
1398         ndr->depth--;
1399         ndr->depth--;
1400 }
1401
1402 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1403 {
1404         if (ndr_flags & NDR_SCALARS) {
1405                 NDR_CHECK(ndr_push_align(ndr, 8));
1406                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1407                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1408                 if (r->naming_context == NULL) {
1409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1410                 }
1411                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1412                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1414                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1417                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1418                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1421                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1422         }
1423         if (ndr_flags & NDR_BUFFERS) {
1424                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1425                 if (r->uptodateness_vector) {
1426                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1427                 }
1428                 if (r->partial_attribute_set) {
1429                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1430                 }
1431                 if (r->partial_attribute_set_ex) {
1432                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1433                 }
1434                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1435         }
1436         return NDR_ERR_SUCCESS;
1437 }
1438
1439 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1440 {
1441         uint32_t _ptr_naming_context;
1442         TALLOC_CTX *_mem_save_naming_context_0;
1443         uint32_t _ptr_uptodateness_vector;
1444         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1445         uint32_t _ptr_partial_attribute_set;
1446         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1447         uint32_t _ptr_partial_attribute_set_ex;
1448         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1449         if (ndr_flags & NDR_SCALARS) {
1450                 NDR_CHECK(ndr_pull_align(ndr, 8));
1451                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1452                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1453                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1454                 if (_ptr_naming_context) {
1455                         NDR_PULL_ALLOC(ndr, r->naming_context);
1456                 } else {
1457                         r->naming_context = NULL;
1458                 }
1459                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1461                 if (_ptr_uptodateness_vector) {
1462                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1463                 } else {
1464                         r->uptodateness_vector = NULL;
1465                 }
1466                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1469                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1470                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1471                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1472                 if (_ptr_partial_attribute_set) {
1473                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1474                 } else {
1475                         r->partial_attribute_set = NULL;
1476                 }
1477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1478                 if (_ptr_partial_attribute_set_ex) {
1479                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1480                 } else {
1481                         r->partial_attribute_set_ex = NULL;
1482                 }
1483                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1484         }
1485         if (ndr_flags & NDR_BUFFERS) {
1486                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1487                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1488                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1490                 if (r->uptodateness_vector) {
1491                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1492                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1493                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1494                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1495                 }
1496                 if (r->partial_attribute_set) {
1497                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1498                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1499                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1501                 }
1502                 if (r->partial_attribute_set_ex) {
1503                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1504                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1505                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1507                 }
1508                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1509         }
1510         return NDR_ERR_SUCCESS;
1511 }
1512
1513 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1514 {
1515         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1516         ndr->depth++;
1517         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1518         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1519         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1520         ndr->depth++;
1521         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1522         ndr->depth--;
1523         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1524         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1525         ndr->depth++;
1526         if (r->uptodateness_vector) {
1527                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1528         }
1529         ndr->depth--;
1530         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1531         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1532         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1533         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1534         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1535         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1536         ndr->depth++;
1537         if (r->partial_attribute_set) {
1538                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1539         }
1540         ndr->depth--;
1541         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1542         ndr->depth++;
1543         if (r->partial_attribute_set_ex) {
1544                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1545         }
1546         ndr->depth--;
1547         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1548         ndr->depth--;
1549 }
1550
1551 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1552 {
1553         if (ndr_flags & NDR_SCALARS) {
1554                 int level = ndr_push_get_switch_value(ndr, r);
1555                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1556                 switch (level) {
1557                         case 5: {
1558                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1559                         break; }
1560
1561                         case 8: {
1562                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1563                         break; }
1564
1565                         default:
1566                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1567                 }
1568         }
1569         if (ndr_flags & NDR_BUFFERS) {
1570                 int level = ndr_push_get_switch_value(ndr, r);
1571                 switch (level) {
1572                         case 5:
1573                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1574                         break;
1575
1576                         case 8:
1577                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1578                         break;
1579
1580                         default:
1581                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1582                 }
1583         }
1584         return NDR_ERR_SUCCESS;
1585 }
1586
1587 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1588 {
1589         int level;
1590         int32_t _level;
1591         level = ndr_pull_get_switch_value(ndr, r);
1592         if (ndr_flags & NDR_SCALARS) {
1593                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1594                 if (_level != level) {
1595                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1596                 }
1597                 switch (level) {
1598                         case 5: {
1599                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1600                         break; }
1601
1602                         case 8: {
1603                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1604                         break; }
1605
1606                         default:
1607                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1608                 }
1609         }
1610         if (ndr_flags & NDR_BUFFERS) {
1611                 switch (level) {
1612                         case 5:
1613                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1614                         break;
1615
1616                         case 8:
1617                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1618                         break;
1619
1620                         default:
1621                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1622                 }
1623         }
1624         return NDR_ERR_SUCCESS;
1625 }
1626
1627 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1628 {
1629         int level;
1630         level = ndr_print_get_switch_value(ndr, r);
1631         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1632         switch (level) {
1633                 case 5:
1634                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1635                 break;
1636
1637                 case 8:
1638                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1639                 break;
1640
1641                 default:
1642                         ndr_print_bad_level(ndr, name, level);
1643         }
1644 }
1645
1646 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1647 {
1648         if (ndr_flags & NDR_SCALARS) {
1649                 NDR_CHECK(ndr_push_align(ndr, 8));
1650                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1651                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1652                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1653         }
1654         if (ndr_flags & NDR_BUFFERS) {
1655         }
1656         return NDR_ERR_SUCCESS;
1657 }
1658
1659 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1660 {
1661         if (ndr_flags & NDR_SCALARS) {
1662                 NDR_CHECK(ndr_pull_align(ndr, 8));
1663                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1664                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1665                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1666         }
1667         if (ndr_flags & NDR_BUFFERS) {
1668         }
1669         return NDR_ERR_SUCCESS;
1670 }
1671
1672 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1673 {
1674         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1675         ndr->depth++;
1676         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1677         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1678         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1679         ndr->depth--;
1680 }
1681
1682 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1683 {
1684         uint32_t cntr_cursors_0;
1685         if (ndr_flags & NDR_SCALARS) {
1686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1687                 NDR_CHECK(ndr_push_align(ndr, 8));
1688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1692                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1693                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1694                 }
1695         }
1696         if (ndr_flags & NDR_BUFFERS) {
1697         }
1698         return NDR_ERR_SUCCESS;
1699 }
1700
1701 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1702 {
1703         uint32_t size_cursors_0 = 0;
1704         uint32_t cntr_cursors_0;
1705         TALLOC_CTX *_mem_save_cursors_0;
1706         if (ndr_flags & NDR_SCALARS) {
1707                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1708                 NDR_CHECK(ndr_pull_align(ndr, 8));
1709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1712                 if (r->count > 0x100000) {
1713                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1714                 }
1715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1716                 size_cursors_0 = ndr_get_array_size(ndr, &r->cursors);
1717                 NDR_PULL_ALLOC_N(ndr, r->cursors, size_cursors_0);
1718                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1719                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1720                 for (cntr_cursors_0 = 0; cntr_cursors_0 < size_cursors_0; cntr_cursors_0++) {
1721                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1722                 }
1723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
1724                 if (r->cursors) {
1725                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
1726                 }
1727         }
1728         if (ndr_flags & NDR_BUFFERS) {
1729         }
1730         return NDR_ERR_SUCCESS;
1731 }
1732
1733 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1734 {
1735         uint32_t cntr_cursors_0;
1736         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
1737         ndr->depth++;
1738         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
1739         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1740         ndr_print_uint32(ndr, "count", r->count);
1741         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
1742         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
1743         ndr->depth++;
1744         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
1745                 char *idx_0=NULL;
1746                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
1747                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
1748                         free(idx_0);
1749                 }
1750         }
1751         ndr->depth--;
1752         ndr->depth--;
1753 }
1754
1755 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
1756 {
1757         if (ndr_flags & NDR_SCALARS) {
1758                 NDR_CHECK(ndr_push_align(ndr, 4));
1759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
1760                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
1761         }
1762         if (ndr_flags & NDR_BUFFERS) {
1763                 if (r->blob) {
1764                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
1765                 }
1766         }
1767         return NDR_ERR_SUCCESS;
1768 }
1769
1770 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
1771 {
1772         uint32_t _ptr_blob;
1773         TALLOC_CTX *_mem_save_blob_0;
1774         if (ndr_flags & NDR_SCALARS) {
1775                 NDR_CHECK(ndr_pull_align(ndr, 4));
1776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1777                 if (r->__ndr_size > 10485760) {
1778                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1779                 }
1780                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
1781                 if (_ptr_blob) {
1782                         NDR_PULL_ALLOC(ndr, r->blob);
1783                 } else {
1784                         r->blob = NULL;
1785                 }
1786         }
1787         if (ndr_flags & NDR_BUFFERS) {
1788                 if (r->blob) {
1789                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
1790                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
1791                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
1792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
1793                 }
1794         }
1795         return NDR_ERR_SUCCESS;
1796 }
1797
1798 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
1799 {
1800         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
1801         ndr->depth++;
1802         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
1803         ndr_print_ptr(ndr, "blob", r->blob);
1804         ndr->depth++;
1805         if (r->blob) {
1806                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
1807         }
1808         ndr->depth--;
1809         ndr->depth--;
1810 }
1811
1812 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
1813 {
1814         uint32_t cntr_values_1;
1815         if (ndr_flags & NDR_SCALARS) {
1816                 NDR_CHECK(ndr_push_align(ndr, 4));
1817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
1818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
1819         }
1820         if (ndr_flags & NDR_BUFFERS) {
1821                 if (r->values) {
1822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
1823                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1824                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
1825                         }
1826                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
1827                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
1828                         }
1829                 }
1830         }
1831         return NDR_ERR_SUCCESS;
1832 }
1833
1834 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
1835 {
1836         uint32_t _ptr_values;
1837         uint32_t size_values_1 = 0;
1838         uint32_t cntr_values_1;
1839         TALLOC_CTX *_mem_save_values_0;
1840         TALLOC_CTX *_mem_save_values_1;
1841         if (ndr_flags & NDR_SCALARS) {
1842                 NDR_CHECK(ndr_pull_align(ndr, 4));
1843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
1844                 if (r->num_values > 10485760) {
1845                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1846                 }
1847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
1848                 if (_ptr_values) {
1849                         NDR_PULL_ALLOC(ndr, r->values);
1850                 } else {
1851                         r->values = NULL;
1852                 }
1853         }
1854         if (ndr_flags & NDR_BUFFERS) {
1855                 if (r->values) {
1856                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
1857                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
1858                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
1859                         size_values_1 = ndr_get_array_size(ndr, &r->values);
1860                         NDR_PULL_ALLOC_N(ndr, r->values, size_values_1);
1861                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
1862                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
1863                         for (cntr_values_1 = 0; cntr_values_1 < size_values_1; cntr_values_1++) {
1864                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
1865                         }
1866                         for (cntr_values_1 = 0; cntr_values_1 < size_values_1; cntr_values_1++) {
1867                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
1868                         }
1869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
1870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
1871                 }
1872                 if (r->values) {
1873                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
1874                 }
1875         }
1876         return NDR_ERR_SUCCESS;
1877 }
1878
1879 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
1880 {
1881         uint32_t cntr_values_1;
1882         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
1883         ndr->depth++;
1884         ndr_print_uint32(ndr, "num_values", r->num_values);
1885         ndr_print_ptr(ndr, "values", r->values);
1886         ndr->depth++;
1887         if (r->values) {
1888                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
1889                 ndr->depth++;
1890                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
1891                         char *idx_1=NULL;
1892                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
1893                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
1894                                 free(idx_1);
1895                         }
1896                 }
1897                 ndr->depth--;
1898         }
1899         ndr->depth--;
1900         ndr->depth--;
1901 }
1902
1903 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
1904 {
1905         if (ndr_flags & NDR_SCALARS) {
1906                 NDR_CHECK(ndr_push_align(ndr, 4));
1907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
1908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
1909                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
1910                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
1912                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
1913         }
1914         if (ndr_flags & NDR_BUFFERS) {
1915                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1916         }
1917         return NDR_ERR_SUCCESS;
1918 }
1919
1920 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
1921 {
1922         uint32_t size_dn_0 = 0;
1923         if (ndr_flags & NDR_SCALARS) {
1924                 NDR_CHECK(ndr_pull_align(ndr, 4));
1925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
1927                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
1928                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
1930                 size_dn_0 = r->__ndr_size_dn + 1;
1931                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, size_dn_0, sizeof(uint16_t), CH_UTF16));
1932         }
1933         if (ndr_flags & NDR_BUFFERS) {
1934                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1935         }
1936         return NDR_ERR_SUCCESS;
1937 }
1938
1939 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
1940 {
1941         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
1942         ndr->depth++;
1943         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
1944         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);
1945         ndr_print_GUID(ndr, "guid", &r->guid);
1946         ndr_print_dom_sid28(ndr, "sid", &r->sid);
1947         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
1948         ndr_print_string(ndr, "dn", r->dn);
1949         ndr->depth--;
1950 }
1951
1952 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
1953 {
1954         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
1955 }
1956
1957 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
1958 {
1959         if (ndr_flags & NDR_SCALARS) {
1960                 NDR_CHECK(ndr_push_align(ndr, 4));
1961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(r, ndr->iconv_convenience, ndr->flags)));
1962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
1963                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
1964                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
1966                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
1967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
1968                 {
1969                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1971                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
1972                         ndr->flags = _flags_save_DATA_BLOB;
1973                 }
1974         }
1975         if (ndr_flags & NDR_BUFFERS) {
1976                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
1977         }
1978         return NDR_ERR_SUCCESS;
1979 }
1980
1981 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
1982 {
1983         uint32_t size_dn_0 = 0;
1984         if (ndr_flags & NDR_SCALARS) {
1985                 NDR_CHECK(ndr_pull_align(ndr, 4));
1986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
1988                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
1989                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
1990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
1991                 size_dn_0 = r->__ndr_size_dn + 1;
1992                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, size_dn_0, sizeof(uint16_t), CH_UTF16));
1993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
1994                 {
1995                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1997                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
1998                         ndr->flags = _flags_save_DATA_BLOB;
1999                 }
2000         }
2001         if (ndr_flags & NDR_BUFFERS) {
2002                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2003         }
2004         return NDR_ERR_SUCCESS;
2005 }
2006
2007 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2008 {
2009         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2010         ndr->depth++;
2011         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
2012         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);
2013         ndr_print_GUID(ndr, "guid", &r->guid);
2014         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2015         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2016         ndr_print_string(ndr, "dn", r->dn);
2017         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2018         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2019         ndr->depth--;
2020 }
2021
2022 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, struct smb_iconv_convenience *ic, int flags)
2023 {
2024         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary, ic);
2025 }
2026
2027 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2028 {
2029         if (ndr_flags & NDR_SCALARS) {
2030                 NDR_CHECK(ndr_push_align(ndr, 4));
2031                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2032                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2033         }
2034         if (ndr_flags & NDR_BUFFERS) {
2035                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2036         }
2037         return NDR_ERR_SUCCESS;
2038 }
2039
2040 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2041 {
2042         if (ndr_flags & NDR_SCALARS) {
2043                 NDR_CHECK(ndr_pull_align(ndr, 4));
2044                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2045                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2046         }
2047         if (ndr_flags & NDR_BUFFERS) {
2048                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2049         }
2050         return NDR_ERR_SUCCESS;
2051 }
2052
2053 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2054 {
2055         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2056         ndr->depth++;
2057         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2058         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2059         ndr->depth--;
2060 }
2061
2062 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2063 {
2064         uint32_t cntr_attributes_1;
2065         if (ndr_flags & NDR_SCALARS) {
2066                 NDR_CHECK(ndr_push_align(ndr, 4));
2067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2069         }
2070         if (ndr_flags & NDR_BUFFERS) {
2071                 if (r->attributes) {
2072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2073                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2074                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2075                         }
2076                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2077                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2078                         }
2079                 }
2080         }
2081         return NDR_ERR_SUCCESS;
2082 }
2083
2084 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2085 {
2086         uint32_t _ptr_attributes;
2087         uint32_t size_attributes_1 = 0;
2088         uint32_t cntr_attributes_1;
2089         TALLOC_CTX *_mem_save_attributes_0;
2090         TALLOC_CTX *_mem_save_attributes_1;
2091         if (ndr_flags & NDR_SCALARS) {
2092                 NDR_CHECK(ndr_pull_align(ndr, 4));
2093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2094                 if (r->num_attributes > 1048576) {
2095                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2096                 }
2097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2098                 if (_ptr_attributes) {
2099                         NDR_PULL_ALLOC(ndr, r->attributes);
2100                 } else {
2101                         r->attributes = NULL;
2102                 }
2103         }
2104         if (ndr_flags & NDR_BUFFERS) {
2105                 if (r->attributes) {
2106                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2107                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2108                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2109                         size_attributes_1 = ndr_get_array_size(ndr, &r->attributes);
2110                         NDR_PULL_ALLOC_N(ndr, r->attributes, size_attributes_1);
2111                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2112                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2113                         for (cntr_attributes_1 = 0; cntr_attributes_1 < size_attributes_1; cntr_attributes_1++) {
2114                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2115                         }
2116                         for (cntr_attributes_1 = 0; cntr_attributes_1 < size_attributes_1; cntr_attributes_1++) {
2117                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2118                         }
2119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2120                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2121                 }
2122                 if (r->attributes) {
2123                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2124                 }
2125         }
2126         return NDR_ERR_SUCCESS;
2127 }
2128
2129 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2130 {
2131         uint32_t cntr_attributes_1;
2132         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2133         ndr->depth++;
2134         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2135         ndr_print_ptr(ndr, "attributes", r->attributes);
2136         ndr->depth++;
2137         if (r->attributes) {
2138                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2139                 ndr->depth++;
2140                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2141                         char *idx_1=NULL;
2142                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2143                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2144                                 free(idx_1);
2145                         }
2146                 }
2147                 ndr->depth--;
2148         }
2149         ndr->depth--;
2150         ndr->depth--;
2151 }
2152
2153 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2154 {
2155         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2156         return NDR_ERR_SUCCESS;
2157 }
2158
2159 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2160 {
2161         uint32_t v;
2162         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2163         *r = v;
2164         return NDR_ERR_SUCCESS;
2165 }
2166
2167 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2168 {
2169         ndr_print_uint32(ndr, name, r);
2170         ndr->depth++;
2171         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2172         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2173         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2174         ndr->depth--;
2175 }
2176
2177 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2178 {
2179         if (ndr_flags & NDR_SCALARS) {
2180                 NDR_CHECK(ndr_push_align(ndr, 4));
2181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2182                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2183                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2184         }
2185         if (ndr_flags & NDR_BUFFERS) {
2186                 if (r->identifier) {
2187                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2188                 }
2189                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2190         }
2191         return NDR_ERR_SUCCESS;
2192 }
2193
2194 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2195 {
2196         uint32_t _ptr_identifier;
2197         TALLOC_CTX *_mem_save_identifier_0;
2198         if (ndr_flags & NDR_SCALARS) {
2199                 NDR_CHECK(ndr_pull_align(ndr, 4));
2200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2201                 if (_ptr_identifier) {
2202                         NDR_PULL_ALLOC(ndr, r->identifier);
2203                 } else {
2204                         r->identifier = NULL;
2205                 }
2206                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2207                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2208         }
2209         if (ndr_flags & NDR_BUFFERS) {
2210                 if (r->identifier) {
2211                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2212                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2213                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2215                 }
2216                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2217         }
2218         return NDR_ERR_SUCCESS;
2219 }
2220
2221 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2222 {
2223         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2224         ndr->depth++;
2225         ndr_print_ptr(ndr, "identifier", r->identifier);
2226         ndr->depth++;
2227         if (r->identifier) {
2228                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2229         }
2230         ndr->depth--;
2231         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2232         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2233         ndr->depth--;
2234 }
2235
2236 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2237 {
2238         if (ndr_flags & NDR_SCALARS) {
2239                 NDR_CHECK(ndr_push_align(ndr, 8));
2240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2241                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2242                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2243                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2244         }
2245         if (ndr_flags & NDR_BUFFERS) {
2246         }
2247         return NDR_ERR_SUCCESS;
2248 }
2249
2250 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2251 {
2252         if (ndr_flags & NDR_SCALARS) {
2253                 NDR_CHECK(ndr_pull_align(ndr, 8));
2254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2255                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2256                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2257                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2258         }
2259         if (ndr_flags & NDR_BUFFERS) {
2260         }
2261         return NDR_ERR_SUCCESS;
2262 }
2263
2264 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2265 {
2266         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2267         ndr->depth++;
2268         ndr_print_uint32(ndr, "version", r->version);
2269         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2270         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2271         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2272         ndr->depth--;
2273 }
2274
2275 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2276 {
2277         uint32_t cntr_meta_data_0;
2278         if (ndr_flags & NDR_SCALARS) {
2279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2280                 NDR_CHECK(ndr_push_align(ndr, 8));
2281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2282                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2283                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2284                 }
2285         }
2286         if (ndr_flags & NDR_BUFFERS) {
2287         }
2288         return NDR_ERR_SUCCESS;
2289 }
2290
2291 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2292 {
2293         uint32_t size_meta_data_0 = 0;
2294         uint32_t cntr_meta_data_0;
2295         TALLOC_CTX *_mem_save_meta_data_0;
2296         if (ndr_flags & NDR_SCALARS) {
2297                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2298                 NDR_CHECK(ndr_pull_align(ndr, 8));
2299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2300                 if (r->count > 1048576) {
2301                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2302                 }
2303                 size_meta_data_0 = ndr_get_array_size(ndr, &r->meta_data);
2304                 NDR_PULL_ALLOC_N(ndr, r->meta_data, size_meta_data_0);
2305                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2306                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2307                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < size_meta_data_0; cntr_meta_data_0++) {
2308                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2309                 }
2310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2311                 if (r->meta_data) {
2312                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2313                 }
2314         }
2315         if (ndr_flags & NDR_BUFFERS) {
2316         }
2317         return NDR_ERR_SUCCESS;
2318 }
2319
2320 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2321 {
2322         uint32_t cntr_meta_data_0;
2323         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2324         ndr->depth++;
2325         ndr_print_uint32(ndr, "count", r->count);
2326         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2327         ndr->depth++;
2328         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2329                 char *idx_0=NULL;
2330                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2331                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2332                         free(idx_0);
2333                 }
2334         }
2335         ndr->depth--;
2336         ndr->depth--;
2337 }
2338
2339 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2340 {
2341         if (ndr_flags & NDR_SCALARS) {
2342                 NDR_CHECK(ndr_push_align(ndr, 4));
2343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2344                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2346                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2348         }
2349         if (ndr_flags & NDR_BUFFERS) {
2350                 if (r->next_object) {
2351                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2352                 }
2353                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2354                 if (r->parent_object_guid) {
2355                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2356                 }
2357                 if (r->meta_data_ctr) {
2358                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2359                 }
2360         }
2361         return NDR_ERR_SUCCESS;
2362 }
2363
2364 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2365 {
2366         uint32_t _ptr_next_object;
2367         TALLOC_CTX *_mem_save_next_object_0;
2368         uint32_t _ptr_parent_object_guid;
2369         TALLOC_CTX *_mem_save_parent_object_guid_0;
2370         uint32_t _ptr_meta_data_ctr;
2371         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2372         if (ndr_flags & NDR_SCALARS) {
2373                 NDR_CHECK(ndr_pull_align(ndr, 4));
2374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2375                 if (_ptr_next_object) {
2376                         NDR_PULL_ALLOC(ndr, r->next_object);
2377                 } else {
2378                         r->next_object = NULL;
2379                 }
2380                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2382                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2383                 if (_ptr_parent_object_guid) {
2384                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2385                 } else {
2386                         r->parent_object_guid = NULL;
2387                 }
2388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2389                 if (_ptr_meta_data_ctr) {
2390                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2391                 } else {
2392                         r->meta_data_ctr = NULL;
2393                 }
2394         }
2395         if (ndr_flags & NDR_BUFFERS) {
2396                 if (r->next_object) {
2397                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2398                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2399                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2400                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2401                 }
2402                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2403                 if (r->parent_object_guid) {
2404                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2405                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2406                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2408                 }
2409                 if (r->meta_data_ctr) {
2410                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2411                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2412                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2414                 }
2415         }
2416         return NDR_ERR_SUCCESS;
2417 }
2418
2419 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2420 {
2421         if (ndr_flags & NDR_SCALARS) {
2422                 NDR_CHECK(ndr_push_align(ndr, 8));
2423                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2424                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2426                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2427                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2429                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2430                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2435         }
2436         if (ndr_flags & NDR_BUFFERS) {
2437                 if (r->naming_context) {
2438                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2439                 }
2440                 if (r->uptodateness_vector) {
2441                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2442                 }
2443                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2444                 if (r->first_object) {
2445                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2446                 }
2447         }
2448         return NDR_ERR_SUCCESS;
2449 }
2450
2451 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2452 {
2453         uint32_t _ptr_naming_context;
2454         TALLOC_CTX *_mem_save_naming_context_0;
2455         uint32_t _ptr_uptodateness_vector;
2456         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2457         uint32_t _ptr_first_object;
2458         TALLOC_CTX *_mem_save_first_object_0;
2459         if (ndr_flags & NDR_SCALARS) {
2460                 NDR_CHECK(ndr_pull_align(ndr, 8));
2461                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2462                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2464                 if (_ptr_naming_context) {
2465                         NDR_PULL_ALLOC(ndr, r->naming_context);
2466                 } else {
2467                         r->naming_context = NULL;
2468                 }
2469                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2470                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2471                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2472                 if (_ptr_uptodateness_vector) {
2473                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2474                 } else {
2475                         r->uptodateness_vector = NULL;
2476                 }
2477                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2478                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2481                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2482                 if (_ptr_first_object) {
2483                         NDR_PULL_ALLOC(ndr, r->first_object);
2484                 } else {
2485                         r->first_object = NULL;
2486                 }
2487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2488         }
2489         if (ndr_flags & NDR_BUFFERS) {
2490                 if (r->naming_context) {
2491                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2492                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2493                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2494                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2495                 }
2496                 if (r->uptodateness_vector) {
2497                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2498                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2499                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2501                 }
2502                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2503                 if (r->first_object) {
2504                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2505                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2506                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2507                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2508                 }
2509         }
2510         return NDR_ERR_SUCCESS;
2511 }
2512
2513 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2514 {
2515         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2516         ndr->depth++;
2517         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2518         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2519         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2520         ndr->depth++;
2521         if (r->naming_context) {
2522                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2523         }
2524         ndr->depth--;
2525         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2526         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2527         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2528         ndr->depth++;
2529         if (r->uptodateness_vector) {
2530                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2531         }
2532         ndr->depth--;
2533         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2534         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2535         ndr_print_uint32(ndr, "object_count", r->object_count);
2536         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55:r->__ndr_size);
2537         ndr_print_ptr(ndr, "first_object", r->first_object);
2538         ndr->depth++;
2539         if (r->first_object) {
2540                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2541         }
2542         ndr->depth--;
2543         ndr_print_uint32(ndr, "more_data", r->more_data);
2544         ndr->depth--;
2545 }
2546
2547 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2548 {
2549         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2550 }
2551
2552 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2553 {
2554         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2555         return NDR_ERR_SUCCESS;
2556 }
2557
2558 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2559 {
2560         uint32_t v;
2561         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2562         *r = v;
2563         return NDR_ERR_SUCCESS;
2564 }
2565
2566 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2567 {
2568         ndr_print_uint32(ndr, name, r);
2569         ndr->depth++;
2570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2571         ndr->depth--;
2572 }
2573
2574 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2575 {
2576         if (ndr_flags & NDR_SCALARS) {
2577                 NDR_CHECK(ndr_push_align(ndr, 8));
2578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2579                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2580                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2581                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2582                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2583                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2584         }
2585         if (ndr_flags & NDR_BUFFERS) {
2586                 if (r->identifier) {
2587                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2588                 }
2589                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2590         }
2591         return NDR_ERR_SUCCESS;
2592 }
2593
2594 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2595 {
2596         uint32_t _ptr_identifier;
2597         TALLOC_CTX *_mem_save_identifier_0;
2598         if (ndr_flags & NDR_SCALARS) {
2599                 NDR_CHECK(ndr_pull_align(ndr, 8));
2600                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2601                 if (_ptr_identifier) {
2602                         NDR_PULL_ALLOC(ndr, r->identifier);
2603                 } else {
2604                         r->identifier = NULL;
2605                 }
2606                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2607                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2608                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2609                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2610                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2611         }
2612         if (ndr_flags & NDR_BUFFERS) {
2613                 if (r->identifier) {
2614                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2615                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2616                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2618                 }
2619                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2620         }
2621         return NDR_ERR_SUCCESS;
2622 }
2623
2624 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2625 {
2626         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2627         ndr->depth++;
2628         ndr_print_ptr(ndr, "identifier", r->identifier);
2629         ndr->depth++;
2630         if (r->identifier) {
2631                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2632         }
2633         ndr->depth--;
2634         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2635         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2636         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2637         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2638         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2639         ndr->depth--;
2640 }
2641
2642 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2643 {
2644         uint32_t cntr_linked_attributes_1;
2645         if (ndr_flags & NDR_SCALARS) {
2646                 NDR_CHECK(ndr_push_align(ndr, 8));
2647                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2648                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2650                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2651                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2653                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2654                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2657                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2662                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2663                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2664         }
2665         if (ndr_flags & NDR_BUFFERS) {
2666                 if (r->naming_context) {
2667                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2668                 }
2669                 if (r->uptodateness_vector) {
2670                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2671                 }
2672                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2673                 if (r->first_object) {
2674                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2675                 }
2676                 if (r->linked_attributes) {
2677                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2678                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2679                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2680                         }
2681                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2682                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2683                         }
2684                 }
2685         }
2686         return NDR_ERR_SUCCESS;
2687 }
2688
2689 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2690 {
2691         uint32_t _ptr_naming_context;
2692         TALLOC_CTX *_mem_save_naming_context_0;
2693         uint32_t _ptr_uptodateness_vector;
2694         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2695         uint32_t _ptr_first_object;
2696         TALLOC_CTX *_mem_save_first_object_0;
2697         uint32_t _ptr_linked_attributes;
2698         uint32_t size_linked_attributes_1 = 0;
2699         uint32_t cntr_linked_attributes_1;
2700         TALLOC_CTX *_mem_save_linked_attributes_0;
2701         TALLOC_CTX *_mem_save_linked_attributes_1;
2702         if (ndr_flags & NDR_SCALARS) {
2703                 NDR_CHECK(ndr_pull_align(ndr, 8));
2704                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2705                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2707                 if (_ptr_naming_context) {
2708                         NDR_PULL_ALLOC(ndr, r->naming_context);
2709                 } else {
2710                         r->naming_context = NULL;
2711                 }
2712                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2713                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2715                 if (_ptr_uptodateness_vector) {
2716                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2717                 } else {
2718                         r->uptodateness_vector = NULL;
2719                 }
2720                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2721                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2724                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2725                 if (_ptr_first_object) {
2726                         NDR_PULL_ALLOC(ndr, r->first_object);
2727                 } else {
2728                         r->first_object = NULL;
2729                 }
2730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
2732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
2733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
2734                 if (r->linked_attributes_count > 1048576) {
2735                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2736                 }
2737                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
2738                 if (_ptr_linked_attributes) {
2739                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
2740                 } else {
2741                         r->linked_attributes = NULL;
2742                 }
2743                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
2744         }
2745         if (ndr_flags & NDR_BUFFERS) {
2746                 if (r->naming_context) {
2747                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2748                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2749                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2751                 }
2752                 if (r->uptodateness_vector) {
2753                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2754                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2755                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2757                 }
2758                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2759                 if (r->first_object) {
2760                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2761                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2762                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2764                 }
2765                 if (r->linked_attributes) {
2766                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2767                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2768                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
2769                         size_linked_attributes_1 = ndr_get_array_size(ndr, &r->linked_attributes);
2770                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, size_linked_attributes_1);
2771                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2772                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2773                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < size_linked_attributes_1; cntr_linked_attributes_1++) {
2774                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2775                         }
2776                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < size_linked_attributes_1; cntr_linked_attributes_1++) {
2777                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2778                         }
2779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
2780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
2781                 }
2782                 if (r->linked_attributes) {
2783                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
2784                 }
2785         }
2786         return NDR_ERR_SUCCESS;
2787 }
2788
2789 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
2790 {
2791         uint32_t cntr_linked_attributes_1;
2792         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
2793         ndr->depth++;
2794         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2795         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2796         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2797         ndr->depth++;
2798         if (r->naming_context) {
2799                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2800         }
2801         ndr->depth--;
2802         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2803         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2804         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2805         ndr->depth++;
2806         if (r->uptodateness_vector) {
2807                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2808         }
2809         ndr->depth--;
2810         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2811         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2812         ndr_print_uint32(ndr, "object_count", r->object_count);
2813         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55:r->__ndr_size);
2814         ndr_print_ptr(ndr, "first_object", r->first_object);
2815         ndr->depth++;
2816         if (r->first_object) {
2817                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2818         }
2819         ndr->depth--;
2820         ndr_print_uint32(ndr, "more_data", r->more_data);
2821         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
2822         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
2823         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
2824         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
2825         ndr->depth++;
2826         if (r->linked_attributes) {
2827                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
2828                 ndr->depth++;
2829                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
2830                         char *idx_1=NULL;
2831                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
2832                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
2833                                 free(idx_1);
2834                         }
2835                 }
2836                 ndr->depth--;
2837         }
2838         ndr->depth--;
2839         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
2840         ndr->depth--;
2841 }
2842
2843 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
2844 {
2845         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
2846 }
2847
2848 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
2849 {
2850         if (ndr_flags & NDR_SCALARS) {
2851                 NDR_CHECK(ndr_push_align(ndr, 1));
2852                 {
2853                         struct ndr_push *_ndr_ctr1;
2854                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
2855                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
2856                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
2857                 }
2858         }
2859         if (ndr_flags & NDR_BUFFERS) {
2860         }
2861         return NDR_ERR_SUCCESS;
2862 }
2863
2864 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
2865 {
2866         if (ndr_flags & NDR_SCALARS) {
2867                 NDR_CHECK(ndr_pull_align(ndr, 1));
2868                 {
2869                         struct ndr_pull *_ndr_ctr1;
2870                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
2871                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
2872                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
2873                 }
2874         }
2875         if (ndr_flags & NDR_BUFFERS) {
2876         }
2877         return NDR_ERR_SUCCESS;
2878 }
2879
2880 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
2881 {
2882         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
2883         ndr->depth++;
2884         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
2885         ndr->depth--;
2886 }
2887
2888 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
2889 {
2890         if (ndr_flags & NDR_SCALARS) {
2891                 NDR_CHECK(ndr_push_align(ndr, 1));
2892                 {
2893                         struct ndr_push *_ndr_ctr6;
2894                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
2895                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
2896                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
2897                 }
2898         }
2899         if (ndr_flags & NDR_BUFFERS) {
2900         }
2901         return NDR_ERR_SUCCESS;
2902 }
2903
2904 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
2905 {
2906         if (ndr_flags & NDR_SCALARS) {
2907                 NDR_CHECK(ndr_pull_align(ndr, 1));
2908                 {
2909                         struct ndr_pull *_ndr_ctr6;
2910                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
2911                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
2912                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
2913                 }
2914         }
2915         if (ndr_flags & NDR_BUFFERS) {
2916         }
2917         return NDR_ERR_SUCCESS;
2918 }
2919
2920 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
2921 {
2922         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
2923         ndr->depth++;
2924         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
2925         ndr->depth--;
2926 }
2927
2928 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
2929 {
2930         uint32_t _ptr_ts;
2931         TALLOC_CTX *_mem_save_ts_0;
2932         if (ndr_flags & NDR_SCALARS) {
2933                 NDR_CHECK(ndr_pull_align(ndr, 4));
2934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
2935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
2936                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
2937                 if (_ptr_ts) {
2938                         NDR_PULL_ALLOC(ndr, r->ts);
2939                 } else {
2940                         r->ts = NULL;
2941                 }
2942         }
2943         if (ndr_flags & NDR_BUFFERS) {
2944                 if (r->ts) {
2945                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
2946                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
2947                         {
2948                                 struct ndr_pull *_ndr_ts;
2949                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
2950                                 {
2951                                         struct ndr_pull *_ndr_ts_compressed;
2952                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2953                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
2954                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
2955                                 }
2956                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
2957                         }
2958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
2959                 }
2960         }
2961         return NDR_ERR_SUCCESS;
2962 }
2963
2964 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
2965 {
2966         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
2967         ndr->depth++;
2968         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
2969         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
2970         ndr_print_ptr(ndr, "ts", r->ts);
2971         ndr->depth++;
2972         if (r->ts) {
2973                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
2974         }
2975         ndr->depth--;
2976         ndr->depth--;
2977 }
2978
2979 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
2980 {
2981         uint32_t _ptr_ts;
2982         TALLOC_CTX *_mem_save_ts_0;
2983         if (ndr_flags & NDR_SCALARS) {
2984                 NDR_CHECK(ndr_pull_align(ndr, 4));
2985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
2986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
2987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
2988                 if (_ptr_ts) {
2989                         NDR_PULL_ALLOC(ndr, r->ts);
2990                 } else {
2991                         r->ts = NULL;
2992                 }
2993         }
2994         if (ndr_flags & NDR_BUFFERS) {
2995                 if (r->ts) {
2996                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
2997                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
2998                         {
2999                                 struct ndr_pull *_ndr_ts;
3000                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3001                                 {
3002                                         struct ndr_pull *_ndr_ts_compressed;
3003                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3004                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3005                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3006                                 }
3007                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3008                         }
3009                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3010                 }
3011         }
3012         return NDR_ERR_SUCCESS;
3013 }
3014
3015 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3016 {
3017         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3018         ndr->depth++;
3019         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3020         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3021         ndr_print_ptr(ndr, "ts", r->ts);
3022         ndr->depth++;
3023         if (r->ts) {
3024                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3025         }
3026         ndr->depth--;
3027         ndr->depth--;
3028 }
3029
3030 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3031 {
3032         uint32_t _ptr_ts;
3033         TALLOC_CTX *_mem_save_ts_0;
3034         if (ndr_flags & NDR_SCALARS) {
3035                 NDR_CHECK(ndr_pull_align(ndr, 4));
3036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3038                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3039                 if (_ptr_ts) {
3040                         NDR_PULL_ALLOC(ndr, r->ts);
3041                 } else {
3042                         r->ts = NULL;
3043                 }
3044         }
3045         if (ndr_flags & NDR_BUFFERS) {
3046                 if (r->ts) {
3047                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3048                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3049                         {
3050                                 struct ndr_pull *_ndr_ts;
3051                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3052                                 {
3053                                         struct ndr_pull *_ndr_ts_compressed;
3054                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3055                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3056                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3057                                 }
3058                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3059                         }
3060                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3061                 }
3062         }
3063         return NDR_ERR_SUCCESS;
3064 }
3065
3066 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3067 {
3068         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3069         ndr->depth++;
3070         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3071         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3072         ndr_print_ptr(ndr, "ts", r->ts);
3073         ndr->depth++;
3074         if (r->ts) {
3075                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3076         }
3077         ndr->depth--;
3078         ndr->depth--;
3079 }
3080
3081 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3082 {
3083         uint32_t _ptr_ts;
3084         TALLOC_CTX *_mem_save_ts_0;
3085         if (ndr_flags & NDR_SCALARS) {
3086                 NDR_CHECK(ndr_pull_align(ndr, 4));
3087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3090                 if (_ptr_ts) {
3091                         NDR_PULL_ALLOC(ndr, r->ts);
3092                 } else {
3093                         r->ts = NULL;
3094                 }
3095         }
3096         if (ndr_flags & NDR_BUFFERS) {
3097                 if (r->ts) {
3098                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3099                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3100                         {
3101                                 struct ndr_pull *_ndr_ts;
3102                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3103                                 {
3104                                         struct ndr_pull *_ndr_ts_compressed;
3105                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3106                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3107                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3108                                 }
3109                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3110                         }
3111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3112                 }
3113         }
3114         return NDR_ERR_SUCCESS;
3115 }
3116
3117 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3118 {
3119         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3120         ndr->depth++;
3121         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3122         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3123         ndr_print_ptr(ndr, "ts", r->ts);
3124         ndr->depth++;
3125         if (r->ts) {
3126                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3127         }
3128         ndr->depth--;
3129         ndr->depth--;
3130 }
3131
3132 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3133 {
3134         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
3135         return NDR_ERR_SUCCESS;
3136 }
3137
3138 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3139 {
3140         uint16_t v;
3141         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
3142         *r = v;
3143         return NDR_ERR_SUCCESS;
3144 }
3145
3146 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3147 {
3148         const char *val = NULL;
3149
3150         switch (r) {
3151                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3152                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3153         }
3154         ndr_print_enum(ndr, name, "ENUM", val, r);
3155 }
3156
3157 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3158 {
3159         {
3160                 uint32_t _flags_save_UNION = ndr->flags;
3161                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3162                 if (ndr_flags & NDR_SCALARS) {
3163                         int level = ndr_push_get_switch_value(ndr, r);
3164                         switch (level) {
3165                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3166                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3167                                 break; }
3168
3169                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3170                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3171                                 break; }
3172
3173                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3174                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3175                                 break; }
3176
3177                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3178                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3179                                 break; }
3180
3181                                 default:
3182                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3183                         }
3184                 }
3185                 if (ndr_flags & NDR_BUFFERS) {
3186                         int level = ndr_push_get_switch_value(ndr, r);
3187                         switch (level) {
3188                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3189                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3190                                 break;
3191
3192                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3193                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3194                                 break;
3195
3196                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3197                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3198                                 break;
3199
3200                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3201                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3202                                 break;
3203
3204                                 default:
3205                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3206                         }
3207                 }
3208                 ndr->flags = _flags_save_UNION;
3209         }
3210         return NDR_ERR_SUCCESS;
3211 }
3212
3213 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3214 {
3215         int level;
3216         {
3217                 uint32_t _flags_save_UNION = ndr->flags;
3218                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3219                 level = ndr_pull_get_switch_value(ndr, r);
3220                 if (ndr_flags & NDR_SCALARS) {
3221                         switch (level) {
3222                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3223                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3224                                 break; }
3225
3226                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3227                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3228                                 break; }
3229
3230                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3231                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3232                                 break; }
3233
3234                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3235                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3236                                 break; }
3237
3238                                 default:
3239                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3240                         }
3241                 }
3242                 if (ndr_flags & NDR_BUFFERS) {
3243                         switch (level) {
3244                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3245                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3246                                 break;
3247
3248                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3249                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3250                                 break;
3251
3252                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3253                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3254                                 break;
3255
3256                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3257                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3258                                 break;
3259
3260                                 default:
3261                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3262                         }
3263                 }
3264                 ndr->flags = _flags_save_UNION;
3265         }
3266         return NDR_ERR_SUCCESS;
3267 }
3268
3269 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3270 {
3271         int level;
3272         {
3273                 uint32_t _flags_save_UNION = ndr->flags;
3274                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3275                 level = ndr_print_get_switch_value(ndr, r);
3276                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3277                 switch (level) {
3278                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3279                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3280                         break;
3281
3282                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3283                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3284                         break;
3285
3286                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3287                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3288                         break;
3289
3290                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3291                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3292                         break;
3293
3294                         default:
3295                                 ndr_print_bad_level(ndr, name, level);
3296                 }
3297                 ndr->flags = _flags_save_UNION;
3298         }
3299 }
3300
3301 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3302 {
3303         if (ndr_flags & NDR_SCALARS) {
3304                 NDR_CHECK(ndr_push_align(ndr, 4));
3305                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3306         }
3307         if (ndr_flags & NDR_BUFFERS) {
3308                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3309         }
3310         return NDR_ERR_SUCCESS;
3311 }
3312
3313 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3314 {
3315         if (ndr_flags & NDR_SCALARS) {
3316                 NDR_CHECK(ndr_pull_align(ndr, 4));
3317                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3318         }
3319         if (ndr_flags & NDR_BUFFERS) {
3320                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3321         }
3322         return NDR_ERR_SUCCESS;
3323 }
3324
3325 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3326 {
3327         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3328         ndr->depth++;
3329         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3330         ndr->depth--;
3331 }
3332
3333 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3334 {
3335         if (ndr_flags & NDR_SCALARS) {
3336                 NDR_CHECK(ndr_push_align(ndr, 4));
3337                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3338                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3339                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3340                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3341         }
3342         if (ndr_flags & NDR_BUFFERS) {
3343                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3344         }
3345         return NDR_ERR_SUCCESS;
3346 }
3347
3348 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3349 {
3350         if (ndr_flags & NDR_SCALARS) {
3351                 NDR_CHECK(ndr_pull_align(ndr, 4));
3352                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3353                 if (r->level < 0 || r->level > 6) {
3354                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3355                 }
3356                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3357                 if (r->type < 2 || r->type > 3) {
3358                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3359                 }
3360                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3361                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3362         }
3363         if (ndr_flags & NDR_BUFFERS) {
3364                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3365         }
3366         return NDR_ERR_SUCCESS;
3367 }
3368
3369 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3370 {
3371         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3372         ndr->depth++;
3373         ndr_print_int32(ndr, "level", r->level);
3374         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3375         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3376         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3377         ndr->depth--;
3378 }
3379
3380 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3381 {
3382         if (ndr_flags & NDR_SCALARS) {
3383                 int level = ndr_push_get_switch_value(ndr, r);
3384                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3385                 switch (level) {
3386                         case 1: {
3387                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3388                         break; }
3389
3390                         case 2: {
3391                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3392                         break; }
3393
3394                         case 6: {
3395                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3396                         break; }
3397
3398                         case 7: {
3399                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3400                         break; }
3401
3402                         default:
3403                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3404                 }
3405         }
3406         if (ndr_flags & NDR_BUFFERS) {
3407                 int level = ndr_push_get_switch_value(ndr, r);
3408                 switch (level) {
3409                         case 1:
3410                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3411                         break;
3412
3413                         case 2:
3414                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3415                         break;
3416
3417                         case 6:
3418                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3419                         break;
3420
3421                         case 7:
3422                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3423                         break;
3424
3425                         default:
3426                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3427                 }
3428         }
3429         return NDR_ERR_SUCCESS;
3430 }
3431
3432 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3433 {
3434         int level;
3435         int32_t _level;
3436         level = ndr_pull_get_switch_value(ndr, r);
3437         if (ndr_flags & NDR_SCALARS) {
3438                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3439                 if (_level != level) {
3440                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3441                 }
3442                 switch (level) {
3443                         case 1: {
3444                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3445                         break; }
3446
3447                         case 2: {
3448                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3449                         break; }
3450
3451                         case 6: {
3452                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3453                         break; }
3454
3455                         case 7: {
3456                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3457                         break; }
3458
3459                         default:
3460                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3461                 }
3462         }
3463         if (ndr_flags & NDR_BUFFERS) {
3464                 switch (level) {
3465                         case 1:
3466                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3467                         break;
3468
3469                         case 2:
3470                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3471                         break;
3472
3473                         case 6:
3474                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3475                         break;
3476
3477                         case 7:
3478                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3479                         break;
3480
3481                         default:
3482                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3483                 }
3484         }
3485         return NDR_ERR_SUCCESS;
3486 }
3487
3488 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3489 {
3490         int level;
3491         level = ndr_print_get_switch_value(ndr, r);
3492         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3493         switch (level) {
3494                 case 1:
3495                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3496                 break;
3497
3498                 case 2:
3499                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3500                 break;
3501
3502                 case 6:
3503                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3504                 break;
3505
3506                 case 7:
3507                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3508                 break;
3509
3510                 default:
3511                         ndr_print_bad_level(ndr, name, level);
3512         }
3513 }
3514
3515 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3516 {
3517         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3518         return NDR_ERR_SUCCESS;
3519 }
3520
3521 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3522 {
3523         uint32_t v;
3524         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3525         *r = v;
3526         return NDR_ERR_SUCCESS;
3527 }
3528
3529 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3530 {
3531         ndr_print_uint32(ndr, name, r);
3532         ndr->depth++;
3533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION, r);
3534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE", DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE, r);
3535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE, r);
3536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE, r);
3537         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_0x00000010", DRSUAPI_DS_REPLICA_UPDATE_0x00000010, r);
3538         ndr->depth--;
3539 }
3540
3541 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3542 {
3543         if (ndr_flags & NDR_SCALARS) {
3544                 NDR_CHECK(ndr_push_align(ndr, 4));
3545                 if (r->naming_context == NULL) {
3546                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3547                 }
3548                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3549                 if (r->dest_dsa_dns_name == NULL) {
3550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3551                 }
3552                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3553                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3554                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
3555         }
3556         if (ndr_flags & NDR_BUFFERS) {
3557                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3561                 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));
3562         }
3563         return NDR_ERR_SUCCESS;
3564 }
3565
3566 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3567 {
3568         uint32_t _ptr_naming_context;
3569         TALLOC_CTX *_mem_save_naming_context_0;
3570         uint32_t _ptr_dest_dsa_dns_name;
3571         uint32_t size_dest_dsa_dns_name_1 = 0;
3572         uint32_t length_dest_dsa_dns_name_1 = 0;
3573         if (ndr_flags & NDR_SCALARS) {
3574                 NDR_CHECK(ndr_pull_align(ndr, 4));
3575                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3576                 if (_ptr_naming_context) {
3577                         NDR_PULL_ALLOC(ndr, r->naming_context);
3578                 } else {
3579                         r->naming_context = NULL;
3580                 }
3581                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3582                 if (_ptr_dest_dsa_dns_name) {
3583                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3584                 } else {
3585                         r->dest_dsa_dns_name = NULL;
3586                 }
3587                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3588                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
3589         }
3590         if (ndr_flags & NDR_BUFFERS) {
3591                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3592                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3593                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3594                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3595                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3596                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3597                 size_dest_dsa_dns_name_1 = ndr_get_array_size(ndr, &r->dest_dsa_dns_name);
3598                 length_dest_dsa_dns_name_1 = ndr_get_array_length(ndr, &r->dest_dsa_dns_name);
3599                 if (length_dest_dsa_dns_name_1 > size_dest_dsa_dns_name_1) {
3600                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dest_dsa_dns_name_1, length_dest_dsa_dns_name_1);
3601                 }
3602                 NDR_CHECK(ndr_check_string_terminator(ndr, length_dest_dsa_dns_name_1, sizeof(uint8_t)));
3603                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dest_dsa_dns_name, length_dest_dsa_dns_name_1, sizeof(uint8_t), CH_DOS));
3604         }
3605         return NDR_ERR_SUCCESS;
3606 }
3607
3608 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3609 {
3610         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3611         ndr->depth++;
3612         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3613         ndr->depth++;
3614         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3615         ndr->depth--;
3616         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3617         ndr->depth++;
3618         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3619         ndr->depth--;
3620         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3621         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "options", r->options);
3622         ndr->depth--;
3623 }
3624
3625 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3626 {
3627         if (ndr_flags & NDR_SCALARS) {
3628                 int level = ndr_push_get_switch_value(ndr, r);
3629                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3630                 switch (level) {
3631                         case 1: {
3632                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3633                         break; }
3634
3635                         default:
3636                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3637                 }
3638         }
3639         if (ndr_flags & NDR_BUFFERS) {
3640                 int level = ndr_push_get_switch_value(ndr, r);
3641                 switch (level) {
3642                         case 1:
3643                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3644                         break;
3645
3646                         default:
3647                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3648                 }
3649         }
3650         return NDR_ERR_SUCCESS;
3651 }
3652
3653 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3654 {
3655         int level;
3656         int32_t _level;
3657         level = ndr_pull_get_switch_value(ndr, r);
3658         if (ndr_flags & NDR_SCALARS) {
3659                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3660                 if (_level != level) {
3661                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3662                 }
3663                 switch (level) {
3664                         case 1: {
3665                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3666                         break; }
3667
3668                         default:
3669                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3670                 }
3671         }
3672         if (ndr_flags & NDR_BUFFERS) {
3673                 switch (level) {
3674                         case 1:
3675                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3676                         break;
3677
3678                         default:
3679                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3680                 }
3681         }
3682         return NDR_ERR_SUCCESS;
3683 }
3684
3685 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3686 {
3687         int level;
3688         level = ndr_print_get_switch_value(ndr, r);
3689         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3690         switch (level) {
3691                 case 1:
3692                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3693                 break;
3694
3695                 default:
3696                         ndr_print_bad_level(ndr, name, level);
3697         }
3698 }
3699
3700 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3701 {
3702         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3703         return NDR_ERR_SUCCESS;
3704 }
3705
3706 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3707 {
3708         uint32_t v;
3709         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3710         *r = v;
3711         return NDR_ERR_SUCCESS;
3712 }
3713
3714 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3715 {
3716         ndr_print_uint32(ndr, name, r);
3717         ndr->depth++;
3718         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
3719         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
3720         ndr->depth--;
3721 }
3722
3723 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3724 {
3725         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3726         return NDR_ERR_SUCCESS;
3727 }
3728
3729 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3730 {
3731         uint32_t v;
3732         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3733         *r = v;
3734         return NDR_ERR_SUCCESS;
3735 }
3736
3737 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3738 {
3739         ndr_print_uint32(ndr, name, r);
3740         ndr->depth++;
3741         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION, r);
3742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_DELETE_WRITEABLE", DRSUAPI_DS_REPLICA_DELETE_WRITEABLE, r);
3743         ndr->depth--;
3744 }
3745
3746 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3747 {
3748         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3749         return NDR_ERR_SUCCESS;
3750 }
3751
3752 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModifyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3753 {
3754         uint32_t v;
3755         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3756         *r = v;
3757         return NDR_ERR_SUCCESS;
3758 }
3759
3760 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3761 {
3762         ndr_print_uint32(ndr, name, r);
3763         ndr->depth++;
3764         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION, r);
3765         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE", DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE, r);
3766         ndr->depth--;
3767 }
3768
3769 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
3770 {
3771         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3772         return NDR_ERR_SUCCESS;
3773 }
3774
3775 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
3776 {
3777         uint32_t v;
3778         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3779         *r = v;
3780         return NDR_ERR_SUCCESS;
3781 }
3782
3783 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
3784 {
3785         const char *val = NULL;
3786
3787         switch (r) {
3788                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
3789                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
3790                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
3791                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
3792                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
3793                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
3794                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
3795         }
3796         ndr_print_enum(ndr, name, "ENUM", val, r);
3797 }
3798
3799 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
3800 {
3801         uint32_t cntr_info_array_1;
3802         uint32_t cntr_group_attrs_1;
3803         uint32_t cntr_sids_1;
3804         if (ndr_flags & NDR_SCALARS) {
3805                 NDR_CHECK(ndr_push_align(ndr, 4));
3806                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
3807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
3808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
3809                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
3810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
3811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
3812         }
3813         if (ndr_flags & NDR_BUFFERS) {
3814                 if (r->info_array) {
3815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
3816                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
3817                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
3818                         }
3819                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
3820                                 if (r->info_array[cntr_info_array_1]) {
3821                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
3822                                 }
3823                         }
3824                 }
3825                 if (r->group_attrs) {
3826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
3827                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
3828                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
3829                         }
3830                 }
3831                 if (r->sids) {
3832                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
3833                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
3834                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
3835                         }
3836                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
3837                                 if (r->sids[cntr_sids_1]) {
3838                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
3839                                 }
3840                         }
3841                 }
3842         }
3843         return NDR_ERR_SUCCESS;
3844 }
3845
3846 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
3847 {
3848         uint32_t _ptr_info_array;
3849         uint32_t size_info_array_1 = 0;
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 size_group_attrs_1 = 0;
3856         uint32_t cntr_group_attrs_1;
3857         TALLOC_CTX *_mem_save_group_attrs_0;
3858         TALLOC_CTX *_mem_save_group_attrs_1;
3859         uint32_t _ptr_sids;
3860         uint32_t size_sids_1 = 0;
3861         uint32_t cntr_sids_1;
3862         TALLOC_CTX *_mem_save_sids_0;
3863         TALLOC_CTX *_mem_save_sids_1;
3864         TALLOC_CTX *_mem_save_sids_2;
3865         if (ndr_flags & NDR_SCALARS) {
3866                 NDR_CHECK(ndr_pull_align(ndr, 4));
3867                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
3868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
3869                 if (r->num_memberships > 10000) {
3870                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3871                 }
3872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
3873                 if (r->num_sids > 10000) {
3874                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3875                 }
3876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
3877                 if (_ptr_info_array) {
3878                         NDR_PULL_ALLOC(ndr, r->info_array);
3879                 } else {
3880                         r->info_array = NULL;
3881                 }
3882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
3883                 if (_ptr_group_attrs) {
3884                         NDR_PULL_ALLOC(ndr, r->group_attrs);
3885                 } else {
3886                         r->group_attrs = NULL;
3887                 }
3888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
3889                 if (_ptr_sids) {
3890                         NDR_PULL_ALLOC(ndr, r->sids);
3891                 } else {
3892                         r->sids = NULL;
3893                 }
3894         }
3895         if (ndr_flags & NDR_BUFFERS) {
3896                 if (r->info_array) {
3897                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3898                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
3899                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
3900                         size_info_array_1 = ndr_get_array_size(ndr, &r->info_array);
3901                         NDR_PULL_ALLOC_N(ndr, r->info_array, size_info_array_1);
3902                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3903                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
3904                         for (cntr_info_array_1 = 0; cntr_info_array_1 < size_info_array_1; cntr_info_array_1++) {
3905                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
3906                                 if (_ptr_info_array) {
3907                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
3908                                 } else {
3909                                         r->info_array[cntr_info_array_1] = NULL;
3910                                 }
3911                         }
3912                         for (cntr_info_array_1 = 0; cntr_info_array_1 < size_info_array_1; cntr_info_array_1++) {
3913                                 if (r->info_array[cntr_info_array_1]) {
3914                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
3915                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
3916                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
3917                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
3918                                 }
3919                         }
3920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
3921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
3922                 }
3923                 if (r->group_attrs) {
3924                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
3925                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
3926                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
3927                         size_group_attrs_1 = ndr_get_array_size(ndr, &r->group_attrs);
3928                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, size_group_attrs_1);
3929                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
3930                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
3931                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < size_group_attrs_1; cntr_group_attrs_1++) {
3932                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
3933                         }
3934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
3935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
3936                 }
3937                 if (r->sids) {
3938                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3939                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
3941                         size_sids_1 = ndr_get_array_size(ndr, &r->sids);
3942                         NDR_PULL_ALLOC_N(ndr, r->sids, size_sids_1);
3943                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3944                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3945                         for (cntr_sids_1 = 0; cntr_sids_1 < size_sids_1; cntr_sids_1++) {
3946                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
3947                                 if (_ptr_sids) {
3948                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
3949                                 } else {
3950                                         r->sids[cntr_sids_1] = NULL;
3951                                 }
3952                         }
3953                         for (cntr_sids_1 = 0; cntr_sids_1 < size_sids_1; cntr_sids_1++) {
3954                                 if (r->sids[cntr_sids_1]) {
3955                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
3956                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
3957                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
3958                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
3959                                 }
3960                         }
3961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
3962                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
3963                 }
3964                 if (r->info_array) {
3965                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
3966                 }
3967                 if (r->group_attrs) {
3968                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
3969                 }
3970                 if (r->sids) {
3971                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
3972                 }
3973         }
3974         return NDR_ERR_SUCCESS;
3975 }
3976
3977 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
3978 {
3979         uint32_t cntr_info_array_1;
3980         uint32_t cntr_group_attrs_1;
3981         uint32_t cntr_sids_1;
3982         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
3983         ndr->depth++;
3984         ndr_print_NTSTATUS(ndr, "status", r->status);
3985         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
3986         ndr_print_uint32(ndr, "num_sids", r->num_sids);
3987         ndr_print_ptr(ndr, "info_array", r->info_array);
3988         ndr->depth++;
3989         if (r->info_array) {
3990                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
3991                 ndr->depth++;
3992                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
3993                         char *idx_1=NULL;
3994                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
3995                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
3996                                 ndr->depth++;
3997                                 if (r->info_array[cntr_info_array_1]) {
3998                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
3999                                 }
4000                                 ndr->depth--;
4001                                 free(idx_1);
4002                         }
4003                 }
4004                 ndr->depth--;
4005         }
4006         ndr->depth--;
4007         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4008         ndr->depth++;
4009         if (r->group_attrs) {
4010                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4011                 ndr->depth++;
4012                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4013                         char *idx_1=NULL;
4014                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4015                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4016                                 free(idx_1);
4017                         }
4018                 }
4019                 ndr->depth--;
4020         }
4021         ndr->depth--;
4022         ndr_print_ptr(ndr, "sids", r->sids);
4023         ndr->depth++;
4024         if (r->sids) {
4025                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4026                 ndr->depth++;
4027                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4028                         char *idx_1=NULL;
4029                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4030                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4031                                 ndr->depth++;
4032                                 if (r->sids[cntr_sids_1]) {
4033                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4034                                 }
4035                                 ndr->depth--;
4036                                 free(idx_1);
4037                         }
4038                 }
4039                 ndr->depth--;
4040         }
4041         ndr->depth--;
4042         ndr->depth--;
4043 }
4044
4045 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4046 {
4047         if (ndr_flags & NDR_SCALARS) {
4048                 int level = ndr_push_get_switch_value(ndr, r);
4049                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4050                 switch (level) {
4051                         case 1: {
4052                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4053                         break; }
4054
4055                         default:
4056                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4057                 }
4058         }
4059         if (ndr_flags & NDR_BUFFERS) {
4060                 int level = ndr_push_get_switch_value(ndr, r);
4061                 switch (level) {
4062                         case 1:
4063                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4064                         break;
4065
4066                         default:
4067                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4068                 }
4069         }
4070         return NDR_ERR_SUCCESS;
4071 }
4072
4073 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4074 {
4075         int level;
4076         int32_t _level;
4077         level = ndr_pull_get_switch_value(ndr, r);
4078         if (ndr_flags & NDR_SCALARS) {
4079                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4080                 if (_level != level) {
4081                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4082                 }
4083                 switch (level) {
4084                         case 1: {
4085                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4086                         break; }
4087
4088                         default:
4089                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4090                 }
4091         }
4092         if (ndr_flags & NDR_BUFFERS) {
4093                 switch (level) {
4094                         case 1:
4095                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4096                         break;
4097
4098                         default:
4099                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4100                 }
4101         }
4102         return NDR_ERR_SUCCESS;
4103 }
4104
4105 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
4106 {
4107         int level;
4108         level = ndr_print_get_switch_value(ndr, r);
4109         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
4110         switch (level) {
4111                 case 1:
4112                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
4113                 break;
4114
4115                 default:
4116                         ndr_print_bad_level(ndr, name, level);
4117         }
4118 }
4119
4120 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
4121 {
4122         uint32_t cntr_info_array_1;
4123         if (ndr_flags & NDR_SCALARS) {
4124                 NDR_CHECK(ndr_push_align(ndr, 4));
4125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4126                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4128                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
4129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
4130         }
4131         if (ndr_flags & NDR_BUFFERS) {
4132                 if (r->info_array) {
4133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4134                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4135                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4136                         }
4137                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4138                                 if (r->info_array[cntr_info_array_1]) {
4139                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4140                                 }
4141                         }
4142                 }
4143                 if (r->domain) {
4144                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
4145                 }
4146         }
4147         return NDR_ERR_SUCCESS;
4148 }
4149
4150 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
4151 {
4152         uint32_t _ptr_info_array;
4153         uint32_t size_info_array_1 = 0;
4154         uint32_t cntr_info_array_1;
4155         TALLOC_CTX *_mem_save_info_array_0;
4156         TALLOC_CTX *_mem_save_info_array_1;
4157         TALLOC_CTX *_mem_save_info_array_2;
4158         uint32_t _ptr_domain;
4159         TALLOC_CTX *_mem_save_domain_0;
4160         if (ndr_flags & NDR_SCALARS) {
4161                 NDR_CHECK(ndr_pull_align(ndr, 4));
4162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4163                 if (r->count < 1 || r->count > 10000) {
4164                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4165                 }
4166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4167                 if (_ptr_info_array) {
4168                         NDR_PULL_ALLOC(ndr, r->info_array);
4169                 } else {
4170                         r->info_array = NULL;
4171                 }
4172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4173                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
4174                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
4175                 if (_ptr_domain) {
4176                         NDR_PULL_ALLOC(ndr, r->domain);
4177                 } else {
4178                         r->domain = NULL;
4179                 }
4180         }
4181         if (ndr_flags & NDR_BUFFERS) {
4182                 if (r->info_array) {
4183                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4184                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4186                         size_info_array_1 = ndr_get_array_size(ndr, &r->info_array);
4187                         NDR_PULL_ALLOC_N(ndr, r->info_array, size_info_array_1);
4188                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4189                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4190                         for (cntr_info_array_1 = 0; cntr_info_array_1 < size_info_array_1; cntr_info_array_1++) {
4191                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4192                                 if (_ptr_info_array) {
4193                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4194                                 } else {
4195                                         r->info_array[cntr_info_array_1] = NULL;
4196                                 }
4197                         }
4198                         for (cntr_info_array_1 = 0; cntr_info_array_1 < size_info_array_1; cntr_info_array_1++) {
4199                                 if (r->info_array[cntr_info_array_1]) {
4200                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4201                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4202                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4203                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4204                                 }
4205                         }
4206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4208                 }
4209                 if (r->domain) {
4210                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
4211                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
4212                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
4213                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
4214                 }
4215                 if (r->info_array) {
4216                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
4217                 }
4218         }
4219         return NDR_ERR_SUCCESS;
4220 }
4221
4222 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
4223 {
4224         uint32_t cntr_info_array_1;
4225         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
4226         ndr->depth++;
4227         ndr_print_uint32(ndr, "count", r->count);
4228         ndr_print_ptr(ndr, "info_array", r->info_array);
4229         ndr->depth++;
4230         if (r->info_array) {
4231                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
4232                 ndr->depth++;
4233                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
4234                         char *idx_1=NULL;
4235                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4236                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4237                                 ndr->depth++;
4238                                 if (r->info_array[cntr_info_array_1]) {
4239                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4240                                 }
4241                                 ndr->depth--;
4242                                 free(idx_1);
4243                         }
4244                 }
4245                 ndr->depth--;
4246         }
4247         ndr->depth--;
4248         ndr_print_uint32(ndr, "flags", r->flags);
4249         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
4250         ndr_print_ptr(ndr, "domain", r->domain);
4251         ndr->depth++;
4252         if (r->domain) {
4253                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
4254         }
4255         ndr->depth--;
4256         ndr->depth--;
4257 }
4258
4259 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
4260 {
4261         if (ndr_flags & NDR_SCALARS) {
4262                 int level = ndr_push_get_switch_value(ndr, r);
4263                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4264                 switch (level) {
4265                         case 1: {
4266                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
4267                         break; }
4268
4269                         default:
4270                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4271                 }
4272         }
4273         if (ndr_flags & NDR_BUFFERS) {
4274                 int level = ndr_push_get_switch_value(ndr, r);
4275                 switch (level) {
4276                         case 1:
4277                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
4278                         break;
4279
4280                         default:
4281                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4282                 }
4283         }
4284         return NDR_ERR_SUCCESS;
4285 }
4286
4287 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
4288 {
4289         int level;
4290         int32_t _level;
4291         level = ndr_pull_get_switch_value(ndr, r);
4292         if (ndr_flags & NDR_SCALARS) {
4293                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4294                 if (_level != level) {
4295                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4296                 }
4297                 switch (level) {
4298                         case 1: {
4299                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
4300                         break; }
4301
4302                         default:
4303                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4304                 }
4305         }
4306         if (ndr_flags & NDR_BUFFERS) {
4307                 switch (level) {
4308                         case 1:
4309                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
4310                         break;
4311
4312                         default:
4313                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4314                 }
4315         }
4316         return NDR_ERR_SUCCESS;
4317 }
4318
4319 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
4320 {
4321         int level;
4322         level = ndr_print_get_switch_value(ndr, r);
4323         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
4324         switch (level) {
4325                 case 1:
4326                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
4327                 break;
4328
4329                 default:
4330                         ndr_print_bad_level(ndr, name, level);
4331         }
4332 }
4333
4334 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
4335 {
4336         if (ndr_flags & NDR_SCALARS) {
4337                 NDR_CHECK(ndr_push_align(ndr, 4));
4338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
4339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
4340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4341                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4342         }
4343         if (ndr_flags & NDR_BUFFERS) {
4344                 if (r->data) {
4345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4346                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4347                 }
4348         }
4349         return NDR_ERR_SUCCESS;
4350 }
4351
4352 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
4353 {
4354         uint32_t _ptr_data;
4355         uint32_t size_data_1 = 0;
4356         TALLOC_CTX *_mem_save_data_0;
4357         if (ndr_flags & NDR_SCALARS) {
4358                 NDR_CHECK(ndr_pull_align(ndr, 4));
4359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
4360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
4361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4362                 if (r->length > 0x00A00000) {
4363                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4364                 }
4365                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4366                 if (_ptr_data) {
4367                         NDR_PULL_ALLOC(ndr, r->data);
4368                 } else {
4369                         r->data = NULL;
4370                 }
4371         }
4372         if (ndr_flags & NDR_BUFFERS) {
4373                 if (r->data) {
4374                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4375                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4377                         size_data_1 = ndr_get_array_size(ndr, &r->data);
4378                         NDR_PULL_ALLOC_N(ndr, r->data, size_data_1);
4379                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_1));
4380                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
4381                 }
4382                 if (r->data) {
4383                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
4384                 }
4385         }
4386         return NDR_ERR_SUCCESS;
4387 }
4388
4389 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
4390 {
4391         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
4392         ndr->depth++;
4393         ndr_print_uint32(ndr, "unknown1", r->unknown1);
4394         ndr_print_uint32(ndr, "unknown2", r->unknown2);
4395         ndr_print_uint32(ndr, "length", r->length);
4396         ndr_print_ptr(ndr, "data", r->data);
4397         ndr->depth++;
4398         if (r->data) {
4399                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
4400         }
4401         ndr->depth--;
4402         ndr->depth--;
4403 }
4404
4405 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
4406 {
4407         if (ndr_flags & NDR_SCALARS) {
4408                 int level = ndr_push_get_switch_value(ndr, r);
4409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4410                 switch (level) {
4411                         case 1: {
4412                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
4413                         break; }
4414
4415                         default:
4416                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4417                 }
4418         }
4419         if (ndr_flags & NDR_BUFFERS) {
4420                 int level = ndr_push_get_switch_value(ndr, r);
4421                 switch (level) {
4422                         case 1:
4423                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
4424                         break;
4425
4426                         default:
4427                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4428                 }
4429         }
4430         return NDR_ERR_SUCCESS;
4431 }
4432
4433 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
4434 {
4435         int level;
4436         uint32_t _level;
4437         level = ndr_pull_get_switch_value(ndr, r);
4438         if (ndr_flags & NDR_SCALARS) {
4439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4440                 if (_level != level) {
4441                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4442                 }
4443                 switch (level) {
4444                         case 1: {
4445                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
4446                         break; }
4447
4448                         default:
4449                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4450                 }
4451         }
4452         if (ndr_flags & NDR_BUFFERS) {
4453                 switch (level) {
4454                         case 1:
4455                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
4456                         break;
4457
4458                         default:
4459                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4460                 }
4461         }
4462         return NDR_ERR_SUCCESS;
4463 }
4464
4465 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
4466 {
4467         int level;
4468         level = ndr_print_get_switch_value(ndr, r);
4469         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
4470         switch (level) {
4471                 case 1:
4472                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
4473                 break;
4474
4475                 default:
4476                         ndr_print_bad_level(ndr, name, level);
4477         }
4478 }
4479
4480 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
4481 {
4482         if (ndr_flags & NDR_SCALARS) {
4483                 NDR_CHECK(ndr_push_align(ndr, 8));
4484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
4485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
4486                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
4487                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
4488                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
4489                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
4490                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
4491                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
4492                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
4494                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
4495         }
4496         if (ndr_flags & NDR_BUFFERS) {
4497                 if (r->data1) {
4498                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
4499                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
4500                 }
4501                 if (r->data2) {
4502                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
4503                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
4504                 }
4505         }
4506         return NDR_ERR_SUCCESS;
4507 }
4508
4509 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
4510 {
4511         uint32_t _ptr_data1;
4512         uint32_t size_data1_1 = 0;
4513         TALLOC_CTX *_mem_save_data1_0;
4514         uint32_t _ptr_data2;
4515         uint32_t size_data2_1 = 0;
4516         TALLOC_CTX *_mem_save_data2_0;
4517         if (ndr_flags & NDR_SCALARS) {
4518                 NDR_CHECK(ndr_pull_align(ndr, 8));
4519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
4520                 if (r->length1 > 0x00A00000) {
4521                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4522                 }
4523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
4524                 if (r->length2 > 0x00A00000) {
4525                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4526                 }
4527                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
4528                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
4529                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
4530                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
4531                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
4532                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
4533                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
4535                 if (_ptr_data1) {
4536                         NDR_PULL_ALLOC(ndr, r->data1);
4537                 } else {
4538                         r->data1 = NULL;
4539                 }
4540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
4541                 if (_ptr_data2) {
4542                         NDR_PULL_ALLOC(ndr, r->data2);
4543                 } else {
4544                         r->data2 = NULL;
4545                 }
4546         }
4547         if (ndr_flags & NDR_BUFFERS) {
4548                 if (r->data1) {
4549                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4550                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
4551                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
4552                         size_data1_1 = ndr_get_array_size(ndr, &r->data1);
4553                         NDR_PULL_ALLOC_N(ndr, r->data1, size_data1_1);
4554                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, size_data1_1));
4555                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
4556                 }
4557                 if (r->data2) {
4558                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4559                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
4560                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
4561                         size_data2_1 = ndr_get_array_size(ndr, &r->data2);
4562                         NDR_PULL_ALLOC_N(ndr, r->data2, size_data2_1);
4563                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, size_data2_1));
4564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
4565                 }
4566                 if (r->data1) {
4567                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
4568                 }
4569                 if (r->data2) {
4570                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
4571                 }
4572         }
4573         return NDR_ERR_SUCCESS;
4574 }
4575
4576 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
4577 {
4578         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
4579         ndr->depth++;
4580         ndr_print_uint32(ndr, "length1", r->length1);
4581         ndr_print_uint32(ndr, "length2", r->length2);
4582         ndr_print_hyper(ndr, "unknown1", r->unknown1);
4583         ndr_print_NTTIME(ndr, "time2", r->time2);
4584         ndr_print_hyper(ndr, "unknown3", r->unknown3);
4585         ndr_print_NTTIME(ndr, "time4", r->time4);
4586         ndr_print_hyper(ndr, "unknown5", r->unknown5);
4587         ndr_print_NTTIME(ndr, "time6", r->time6);
4588         ndr_print_NTSTATUS(ndr, "status", r->status);
4589         ndr_print_ptr(ndr, "data1", r->data1);
4590         ndr->depth++;
4591         if (r->data1) {
4592                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
4593         }
4594         ndr->depth--;
4595         ndr_print_ptr(ndr, "data2", r->data2);
4596         ndr->depth++;
4597         if (r->data2) {
4598                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
4599         }
4600         ndr->depth--;
4601         ndr->depth--;
4602 }
4603
4604 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
4605 {
4606         if (ndr_flags & NDR_SCALARS) {
4607                 int level = ndr_push_get_switch_value(ndr, r);
4608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4609                 switch (level) {
4610                         case 1: {
4611                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
4612                         break; }
4613
4614                         default:
4615                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4616                 }
4617         }
4618         if (ndr_flags & NDR_BUFFERS) {
4619                 int level = ndr_push_get_switch_value(ndr, r);
4620                 switch (level) {
4621                         case 1:
4622                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
4623                         break;
4624
4625                         default:
4626                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4627                 }
4628         }
4629         return NDR_ERR_SUCCESS;
4630 }
4631
4632 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
4633 {
4634         int level;
4635         uint32_t _level;
4636         level = ndr_pull_get_switch_value(ndr, r);
4637         if (ndr_flags & NDR_SCALARS) {
4638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4639                 if (_level != level) {
4640                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4641                 }
4642                 switch (level) {
4643                         case 1: {
4644                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
4645                         break; }
4646
4647                         default:
4648                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4649                 }
4650         }
4651         if (ndr_flags & NDR_BUFFERS) {
4652                 switch (level) {
4653                         case 1:
4654                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
4655                         break;
4656
4657                         default:
4658                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4659                 }
4660         }
4661         return NDR_ERR_SUCCESS;
4662 }
4663
4664 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
4665 {
4666         int level;
4667         level = ndr_print_get_switch_value(ndr, r);
4668         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
4669         switch (level) {
4670                 case 1:
4671                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
4672                 break;
4673
4674                 default:
4675                         ndr_print_bad_level(ndr, name, level);
4676         }
4677 }
4678
4679 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
4680 {
4681         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4682         return NDR_ERR_SUCCESS;
4683 }
4684
4685 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
4686 {
4687         uint32_t v;
4688         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4689         *r = v;
4690         return NDR_ERR_SUCCESS;
4691 }
4692
4693 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
4694 {
4695         const char *val = NULL;
4696
4697         switch (r) {
4698                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
4699                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
4700                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
4701                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
4702                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
4703                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
4704                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
4705                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
4706         }
4707         ndr_print_enum(ndr, name, "ENUM", val, r);
4708 }
4709
4710 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
4711 {
4712         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4713         return NDR_ERR_SUCCESS;
4714 }
4715
4716 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
4717 {
4718         uint32_t v;
4719         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4720         *r = v;
4721         return NDR_ERR_SUCCESS;
4722 }
4723
4724 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
4725 {
4726         const char *val = NULL;
4727
4728         switch (r) {
4729                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
4730                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
4731                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
4732                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
4733                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
4734         }
4735         ndr_print_enum(ndr, name, "ENUM", val, r);
4736 }
4737
4738 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
4739 {
4740         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4741         return NDR_ERR_SUCCESS;
4742 }
4743
4744 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
4745 {
4746         uint32_t v;
4747         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4748         *r = v;
4749         return NDR_ERR_SUCCESS;
4750 }
4751
4752 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
4753 {
4754         const char *val = NULL;
4755
4756         switch (r) {
4757                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
4758                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
4759                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
4760                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
4761                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
4762                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
4763                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
4764                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
4765                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
4766                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
4767                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
4768         }
4769         ndr_print_enum(ndr, name, "ENUM", val, r);
4770 }
4771
4772 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
4773 {
4774         if (ndr_flags & NDR_SCALARS) {
4775                 NDR_CHECK(ndr_push_align(ndr, 4));
4776                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
4777         }
4778         if (ndr_flags & NDR_BUFFERS) {
4779                 if (r->str) {
4780                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
4781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4782                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
4783                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4784                 }
4785         }
4786         return NDR_ERR_SUCCESS;
4787 }
4788
4789 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
4790 {
4791         uint32_t _ptr_str;
4792         uint32_t size_str_1 = 0;
4793         uint32_t length_str_1 = 0;
4794         TALLOC_CTX *_mem_save_str_0;
4795         if (ndr_flags & NDR_SCALARS) {
4796                 NDR_CHECK(ndr_pull_align(ndr, 4));
4797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
4798                 if (_ptr_str) {
4799                         NDR_PULL_ALLOC(ndr, r->str);
4800                 } else {
4801                         r->str = NULL;
4802                 }
4803         }
4804         if (ndr_flags & NDR_BUFFERS) {
4805                 if (r->str) {
4806                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
4807                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
4808                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
4809                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
4810                         size_str_1 = ndr_get_array_size(ndr, &r->str);
4811                         length_str_1 = ndr_get_array_length(ndr, &r->str);
4812                         if (length_str_1 > size_str_1) {
4813                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_str_1, length_str_1);
4814                         }
4815                         NDR_CHECK(ndr_check_string_terminator(ndr, length_str_1, sizeof(uint16_t)));
4816                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, length_str_1, sizeof(uint16_t), CH_UTF16));
4817                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
4818                 }
4819         }
4820         return NDR_ERR_SUCCESS;
4821 }
4822
4823 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
4824 {
4825         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
4826         ndr->depth++;
4827         ndr_print_ptr(ndr, "str", r->str);
4828         ndr->depth++;
4829         if (r->str) {
4830                 ndr_print_string(ndr, "str", r->str);
4831         }
4832         ndr->depth--;
4833         ndr->depth--;
4834 }
4835
4836 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
4837 {
4838         uint32_t cntr_names_1;
4839         if (ndr_flags & NDR_SCALARS) {
4840                 NDR_CHECK(ndr_push_align(ndr, 4));
4841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
4842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
4843                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
4844                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
4845                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
4846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
4848         }
4849         if (ndr_flags & NDR_BUFFERS) {
4850                 if (r->names) {
4851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4852                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4853                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
4854                         }
4855                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4856                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
4857                         }
4858                 }
4859         }
4860         return NDR_ERR_SUCCESS;
4861 }
4862
4863 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
4864 {
4865         uint32_t _ptr_names;
4866         uint32_t size_names_1 = 0;
4867         uint32_t cntr_names_1;
4868         TALLOC_CTX *_mem_save_names_0;
4869         TALLOC_CTX *_mem_save_names_1;
4870         if (ndr_flags & NDR_SCALARS) {
4871                 NDR_CHECK(ndr_pull_align(ndr, 4));
4872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
4873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
4874                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
4875                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
4876                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
4877                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4878                 if (r->count < 1 || r->count > 10000) {
4879                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4880                 }
4881                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
4882                 if (_ptr_names) {
4883                         NDR_PULL_ALLOC(ndr, r->names);
4884                 } else {
4885                         r->names = NULL;
4886                 }
4887         }
4888         if (ndr_flags & NDR_BUFFERS) {
4889                 if (r->names) {
4890                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
4891                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
4892                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
4893                         size_names_1 = ndr_get_array_size(ndr, &r->names);
4894                         NDR_PULL_ALLOC_N(ndr, r->names, size_names_1);
4895                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
4896                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
4897                         for (cntr_names_1 = 0; cntr_names_1 < size_names_1; cntr_names_1++) {
4898                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
4899                         }
4900                         for (cntr_names_1 = 0; cntr_names_1 < size_names_1; cntr_names_1++) {
4901                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
4902                         }
4903                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
4904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
4905                 }
4906                 if (r->names) {
4907                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
4908                 }
4909         }
4910         return NDR_ERR_SUCCESS;
4911 }
4912
4913 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
4914 {
4915         uint32_t cntr_names_1;
4916         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
4917         ndr->depth++;
4918         ndr_print_uint32(ndr, "codepage", r->codepage);
4919         ndr_print_uint32(ndr, "language", r->language);
4920         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
4921         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
4922         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
4923         ndr_print_uint32(ndr, "count", r->count);
4924         ndr_print_ptr(ndr, "names", r->names);
4925         ndr->depth++;
4926         if (r->names) {
4927                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
4928                 ndr->depth++;
4929                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
4930                         char *idx_1=NULL;
4931                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
4932                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
4933                                 free(idx_1);
4934                         }
4935                 }
4936                 ndr->depth--;
4937         }
4938         ndr->depth--;
4939         ndr->depth--;
4940 }
4941
4942 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
4943 {
4944         if (ndr_flags & NDR_SCALARS) {
4945                 int level = ndr_push_get_switch_value(ndr, r);
4946                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4947                 switch (level) {
4948                         case 1: {
4949                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
4950                         break; }
4951
4952                         default:
4953                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4954                 }
4955         }
4956         if (ndr_flags & NDR_BUFFERS) {
4957                 int level = ndr_push_get_switch_value(ndr, r);
4958                 switch (level) {
4959                         case 1:
4960                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
4961                         break;
4962
4963                         default:
4964                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4965                 }
4966         }
4967         return NDR_ERR_SUCCESS;
4968 }
4969
4970 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
4971 {
4972         int level;
4973         int32_t _level;
4974         level = ndr_pull_get_switch_value(ndr, r);
4975         if (ndr_flags & NDR_SCALARS) {
4976                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4977                 if (_level != level) {
4978                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4979                 }
4980                 switch (level) {
4981                         case 1: {
4982                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
4983                         break; }
4984
4985                         default:
4986                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4987                 }
4988         }
4989         if (ndr_flags & NDR_BUFFERS) {
4990                 switch (level) {
4991                         case 1:
4992                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
4993                         break;
4994
4995                         default:
4996                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4997                 }
4998         }
4999         return NDR_ERR_SUCCESS;
5000 }
5001
5002 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5003 {
5004         int level;
5005         level = ndr_print_get_switch_value(ndr, r);
5006         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5007         switch (level) {
5008                 case 1:
5009                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5010                 break;
5011
5012                 default:
5013                         ndr_print_bad_level(ndr, name, level);
5014         }
5015 }
5016
5017 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5018 {
5019         if (ndr_flags & NDR_SCALARS) {
5020                 NDR_CHECK(ndr_push_align(ndr, 4));
5021                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5023                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5024         }
5025         if (ndr_flags & NDR_BUFFERS) {
5026                 if (r->dns_domain_name) {
5027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5028                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5029                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5030                         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));
5031                 }
5032                 if (r->result_name) {
5033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5034                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5036                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5037                 }
5038         }
5039         return NDR_ERR_SUCCESS;
5040 }
5041
5042 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5043 {
5044         uint32_t _ptr_dns_domain_name;
5045         uint32_t size_dns_domain_name_1 = 0;
5046         uint32_t length_dns_domain_name_1 = 0;
5047         TALLOC_CTX *_mem_save_dns_domain_name_0;
5048         uint32_t _ptr_result_name;
5049         uint32_t size_result_name_1 = 0;
5050         uint32_t length_result_name_1 = 0;
5051         TALLOC_CTX *_mem_save_result_name_0;
5052         if (ndr_flags & NDR_SCALARS) {
5053                 NDR_CHECK(ndr_pull_align(ndr, 4));
5054                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5056                 if (_ptr_dns_domain_name) {
5057                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5058                 } else {
5059                         r->dns_domain_name = NULL;
5060                 }
5061                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5062                 if (_ptr_result_name) {
5063                         NDR_PULL_ALLOC(ndr, r->result_name);
5064                 } else {
5065                         r->result_name = NULL;
5066                 }
5067         }
5068         if (ndr_flags & NDR_BUFFERS) {
5069                 if (r->dns_domain_name) {
5070                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5071                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5074                         size_dns_domain_name_1 = ndr_get_array_size(ndr, &r->dns_domain_name);
5075                         length_dns_domain_name_1 = ndr_get_array_length(ndr, &r->dns_domain_name);
5076                         if (length_dns_domain_name_1 > size_dns_domain_name_1) {
5077                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dns_domain_name_1, length_dns_domain_name_1);
5078                         }
5079                         NDR_CHECK(ndr_check_string_terminator(ndr, length_dns_domain_name_1, sizeof(uint16_t)));
5080                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_domain_name, length_dns_domain_name_1, sizeof(uint16_t), CH_UTF16));
5081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5082                 }
5083                 if (r->result_name) {
5084                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5085                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5086                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5087                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5088                         size_result_name_1 = ndr_get_array_size(ndr, &r->result_name);
5089                         length_result_name_1 = ndr_get_array_length(ndr, &r->result_name);
5090                         if (length_result_name_1 > size_result_name_1) {
5091                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_result_name_1, length_result_name_1);
5092                         }
5093                         NDR_CHECK(ndr_check_string_terminator(ndr, length_result_name_1, sizeof(uint16_t)));
5094                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, length_result_name_1, sizeof(uint16_t), CH_UTF16));
5095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5096                 }
5097         }
5098         return NDR_ERR_SUCCESS;
5099 }
5100
5101 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5102 {
5103         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5104         ndr->depth++;
5105         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5106         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5107         ndr->depth++;
5108         if (r->dns_domain_name) {
5109                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5110         }
5111         ndr->depth--;
5112         ndr_print_ptr(ndr, "result_name", r->result_name);
5113         ndr->depth++;
5114         if (r->result_name) {
5115                 ndr_print_string(ndr, "result_name", r->result_name);
5116         }
5117         ndr->depth--;
5118         ndr->depth--;
5119 }
5120
5121 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5122 {
5123         uint32_t cntr_array_1;
5124         if (ndr_flags & NDR_SCALARS) {
5125                 NDR_CHECK(ndr_push_align(ndr, 4));
5126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5127                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5128         }
5129         if (ndr_flags & NDR_BUFFERS) {
5130                 if (r->array) {
5131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5132                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5133                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5134                         }
5135                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5136                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5137                         }
5138                 }
5139         }
5140         return NDR_ERR_SUCCESS;
5141 }
5142
5143 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
5144 {
5145         uint32_t _ptr_array;
5146         uint32_t size_array_1 = 0;
5147         uint32_t cntr_array_1;
5148         TALLOC_CTX *_mem_save_array_0;
5149         TALLOC_CTX *_mem_save_array_1;
5150         if (ndr_flags & NDR_SCALARS) {
5151                 NDR_CHECK(ndr_pull_align(ndr, 4));
5152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5154                 if (_ptr_array) {
5155                         NDR_PULL_ALLOC(ndr, r->array);
5156                 } else {
5157                         r->array = NULL;
5158                 }
5159         }
5160         if (ndr_flags & NDR_BUFFERS) {
5161                 if (r->array) {
5162                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5163                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5165                         size_array_1 = ndr_get_array_size(ndr, &r->array);
5166                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
5167                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5168                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5169                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5170                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5171                         }
5172                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5173                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5174                         }
5175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5177                 }
5178                 if (r->array) {
5179                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5180                 }
5181         }
5182         return NDR_ERR_SUCCESS;
5183 }
5184
5185 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
5186 {
5187         uint32_t cntr_array_1;
5188         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
5189         ndr->depth++;
5190         ndr_print_uint32(ndr, "count", r->count);
5191         ndr_print_ptr(ndr, "array", r->array);
5192         ndr->depth++;
5193         if (r->array) {
5194                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5195                 ndr->depth++;
5196                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5197                         char *idx_1=NULL;
5198                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
5199                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
5200                                 free(idx_1);
5201                         }
5202                 }
5203                 ndr->depth--;
5204         }
5205         ndr->depth--;
5206         ndr->depth--;
5207 }
5208
5209 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
5210 {
5211         if (ndr_flags & NDR_SCALARS) {
5212                 int level = ndr_push_get_switch_value(ndr, r);
5213                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5214                 switch (level) {
5215                         case 1: {
5216                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
5217                         break; }
5218
5219                         default:
5220                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5221                 }
5222         }
5223         if (ndr_flags & NDR_BUFFERS) {
5224                 int level = ndr_push_get_switch_value(ndr, r);
5225                 switch (level) {
5226                         case 1:
5227                                 if (r->ctr1) {
5228                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5229                                 }
5230                         break;
5231
5232                         default:
5233                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5234                 }
5235         }
5236         return NDR_ERR_SUCCESS;
5237 }
5238
5239 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
5240 {
5241         int level;
5242         int32_t _level;
5243         TALLOC_CTX *_mem_save_ctr1_0;
5244         uint32_t _ptr_ctr1;
5245         level = ndr_pull_get_switch_value(ndr, r);
5246         if (ndr_flags & NDR_SCALARS) {
5247                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5248                 if (_level != level) {
5249                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5250                 }
5251                 switch (level) {
5252                         case 1: {
5253                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
5254                                 if (_ptr_ctr1) {
5255                                         NDR_PULL_ALLOC(ndr, r->ctr1);
5256                                 } else {
5257                                         r->ctr1 = NULL;
5258                                 }
5259                         break; }
5260
5261                         default:
5262                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5263                 }
5264         }
5265         if (ndr_flags & NDR_BUFFERS) {
5266                 switch (level) {
5267                         case 1:
5268                                 if (r->ctr1) {
5269                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5270                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
5271                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
5272                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
5273                                 }
5274                         break;
5275
5276                         default:
5277                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5278                 }
5279         }
5280         return NDR_ERR_SUCCESS;
5281 }
5282
5283 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
5284 {
5285         int level;
5286         level = ndr_print_get_switch_value(ndr, r);
5287         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
5288         switch (level) {
5289                 case 1:
5290                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
5291                         ndr->depth++;
5292                         if (r->ctr1) {
5293                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
5294                         }
5295                         ndr->depth--;
5296                 break;
5297
5298                 default:
5299                         ndr_print_bad_level(ndr, name, level);
5300         }
5301 }
5302
5303 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
5304 {
5305         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5306         return NDR_ERR_SUCCESS;
5307 }
5308
5309 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
5310 {
5311         uint32_t v;
5312         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5313         *r = v;
5314         return NDR_ERR_SUCCESS;
5315 }
5316
5317 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
5318 {
5319         const char *val = NULL;
5320
5321         switch (r) {
5322                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
5323                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
5324                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
5325         }
5326         ndr_print_enum(ndr, name, "ENUM", val, r);
5327 }
5328
5329 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
5330 {
5331         uint32_t cntr_spn_names_1;
5332         if (ndr_flags & NDR_SCALARS) {
5333                 NDR_CHECK(ndr_push_align(ndr, 4));
5334                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
5335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5336                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
5337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5338                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
5339         }
5340         if (ndr_flags & NDR_BUFFERS) {
5341                 if (r->object_dn) {
5342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
5343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
5345                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5346                 }
5347                 if (r->spn_names) {
5348                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5349                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
5350                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
5351                         }
5352                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
5353                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
5354                         }
5355                 }
5356         }
5357         return NDR_ERR_SUCCESS;
5358 }
5359
5360 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
5361 {
5362         uint32_t _ptr_object_dn;
5363         uint32_t size_object_dn_1 = 0;
5364         uint32_t length_object_dn_1 = 0;
5365         TALLOC_CTX *_mem_save_object_dn_0;
5366         uint32_t _ptr_spn_names;
5367         uint32_t size_spn_names_1 = 0;
5368         uint32_t cntr_spn_names_1;
5369         TALLOC_CTX *_mem_save_spn_names_0;
5370         TALLOC_CTX *_mem_save_spn_names_1;
5371         if (ndr_flags & NDR_SCALARS) {
5372                 NDR_CHECK(ndr_pull_align(ndr, 4));
5373                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
5374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
5376                 if (_ptr_object_dn) {
5377                         NDR_PULL_ALLOC(ndr, r->object_dn);
5378                 } else {
5379                         r->object_dn = NULL;
5380                 }
5381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5382                 if (r->count > 10000) {
5383                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5384                 }
5385                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
5386                 if (_ptr_spn_names) {
5387                         NDR_PULL_ALLOC(ndr, r->spn_names);
5388                 } else {
5389                         r->spn_names = NULL;
5390                 }
5391         }
5392         if (ndr_flags & NDR_BUFFERS) {
5393                 if (r->object_dn) {
5394                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
5395                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
5396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
5397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
5398                         size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
5399                         length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
5400                         if (length_object_dn_1 > size_object_dn_1) {
5401                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
5402                         }
5403                         NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
5404                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
5405                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
5406                 }
5407                 if (r->spn_names) {
5408                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5409                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
5410                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
5411                         size_spn_names_1 = ndr_get_array_size(ndr, &r->spn_names);
5412                         NDR_PULL_ALLOC_N(ndr, r->spn_names, size_spn_names_1);
5413                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5414                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
5415                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < size_spn_names_1; cntr_spn_names_1++) {
5416                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
5417                         }
5418                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < size_spn_names_1; cntr_spn_names_1++) {
5419                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
5420                         }
5421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
5422                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
5423                 }
5424                 if (r->spn_names) {
5425                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
5426                 }
5427         }
5428         return NDR_ERR_SUCCESS;
5429 }
5430
5431 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
5432 {
5433         uint32_t cntr_spn_names_1;
5434         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
5435         ndr->depth++;
5436         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
5437         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5438         ndr_print_ptr(ndr, "object_dn", r->object_dn);
5439         ndr->depth++;
5440         if (r->object_dn) {
5441                 ndr_print_string(ndr, "object_dn", r->object_dn);
5442         }
5443         ndr->depth--;
5444         ndr_print_uint32(ndr, "count", r->count);
5445         ndr_print_ptr(ndr, "spn_names", r->spn_names);
5446         ndr->depth++;
5447         if (r->spn_names) {
5448                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
5449                 ndr->depth++;
5450                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
5451                         char *idx_1=NULL;
5452                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
5453                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
5454                                 free(idx_1);
5455                         }
5456                 }
5457                 ndr->depth--;
5458         }
5459         ndr->depth--;
5460         ndr->depth--;
5461 }
5462
5463 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
5464 {
5465         if (ndr_flags & NDR_SCALARS) {
5466                 int level = ndr_push_get_switch_value(ndr, r);
5467                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5468                 switch (level) {
5469                         case 1: {
5470                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
5471                         break; }
5472
5473                         default:
5474                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5475                 }
5476         }
5477         if (ndr_flags & NDR_BUFFERS) {
5478                 int level = ndr_push_get_switch_value(ndr, r);
5479                 switch (level) {
5480                         case 1:
5481                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
5482                         break;
5483
5484                         default:
5485                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5486                 }
5487         }
5488         return NDR_ERR_SUCCESS;
5489 }
5490
5491 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
5492 {
5493         int level;
5494         int32_t _level;
5495         level = ndr_pull_get_switch_value(ndr, r);
5496         if (ndr_flags & NDR_SCALARS) {
5497                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5498                 if (_level != level) {
5499                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5500                 }
5501                 switch (level) {
5502                         case 1: {
5503                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
5504                         break; }
5505
5506                         default:
5507                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5508                 }
5509         }
5510         if (ndr_flags & NDR_BUFFERS) {
5511                 switch (level) {
5512                         case 1:
5513                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
5514                         break;
5515
5516                         default:
5517                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5518                 }
5519         }
5520         return NDR_ERR_SUCCESS;
5521 }
5522
5523 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
5524 {
5525         int level;
5526         level = ndr_print_get_switch_value(ndr, r);
5527         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
5528         switch (level) {
5529                 case 1:
5530                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
5531                 break;
5532
5533                 default:
5534                         ndr_print_bad_level(ndr, name, level);
5535         }
5536 }
5537
5538 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
5539 {
5540         if (ndr_flags & NDR_SCALARS) {
5541                 NDR_CHECK(ndr_push_align(ndr, 4));
5542                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
5543         }
5544         if (ndr_flags & NDR_BUFFERS) {
5545         }
5546         return NDR_ERR_SUCCESS;
5547 }
5548
5549 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
5550 {
5551         if (ndr_flags & NDR_SCALARS) {
5552                 NDR_CHECK(ndr_pull_align(ndr, 4));
5553                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
5554         }
5555         if (ndr_flags & NDR_BUFFERS) {
5556         }
5557         return NDR_ERR_SUCCESS;
5558 }
5559
5560 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
5561 {
5562         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
5563         ndr->depth++;
5564         ndr_print_WERROR(ndr, "status", r->status);
5565         ndr->depth--;
5566 }
5567
5568 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
5569 {
5570         if (ndr_flags & NDR_SCALARS) {
5571                 int level = ndr_push_get_switch_value(ndr, r);
5572                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5573                 switch (level) {
5574                         case 1: {
5575                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
5576                         break; }
5577
5578                         default:
5579                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5580                 }
5581         }
5582         if (ndr_flags & NDR_BUFFERS) {
5583                 int level = ndr_push_get_switch_value(ndr, r);
5584                 switch (level) {
5585                         case 1:
5586                         break;
5587
5588                         default:
5589                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5590                 }
5591         }
5592         return NDR_ERR_SUCCESS;
5593 }
5594
5595 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
5596 {
5597         int level;
5598         int32_t _level;
5599         level = ndr_pull_get_switch_value(ndr, r);
5600         if (ndr_flags & NDR_SCALARS) {
5601                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5602                 if (_level != level) {
5603                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5604                 }
5605                 switch (level) {
5606                         case 1: {
5607                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
5608                         break; }
5609
5610                         default:
5611                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5612                 }
5613         }
5614         if (ndr_flags & NDR_BUFFERS) {
5615                 switch (level) {
5616                         case 1:
5617                         break;
5618
5619                         default:
5620                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5621                 }
5622         }
5623         return NDR_ERR_SUCCESS;
5624 }
5625
5626 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
5627 {
5628         int level;
5629         level = ndr_print_get_switch_value(ndr, r);
5630         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
5631         switch (level) {
5632                 case 1:
5633                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
5634                 break;
5635
5636                 default:
5637                         ndr_print_bad_level(ndr, name, level);
5638         }
5639 }
5640
5641 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
5642 {
5643         if (ndr_flags & NDR_SCALARS) {
5644                 NDR_CHECK(ndr_push_align(ndr, 4));
5645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
5646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
5647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
5648         }
5649         if (ndr_flags & NDR_BUFFERS) {
5650                 if (r->server_dn) {
5651                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
5652                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5653                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
5654                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5655                 }
5656                 if (r->domain_dn) {
5657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
5658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5659                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
5660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5661                 }
5662         }
5663         return NDR_ERR_SUCCESS;
5664 }
5665
5666 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
5667 {
5668         uint32_t _ptr_server_dn;
5669         uint32_t size_server_dn_1 = 0;
5670         uint32_t length_server_dn_1 = 0;
5671         TALLOC_CTX *_mem_save_server_dn_0;
5672         uint32_t _ptr_domain_dn;
5673         uint32_t size_domain_dn_1 = 0;
5674         uint32_t length_domain_dn_1 = 0;
5675         TALLOC_CTX *_mem_save_domain_dn_0;
5676         if (ndr_flags & NDR_SCALARS) {
5677                 NDR_CHECK(ndr_pull_align(ndr, 4));
5678                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
5679                 if (_ptr_server_dn) {
5680                         NDR_PULL_ALLOC(ndr, r->server_dn);
5681                 } else {
5682                         r->server_dn = NULL;
5683                 }
5684                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
5685                 if (_ptr_domain_dn) {
5686                         NDR_PULL_ALLOC(ndr, r->domain_dn);
5687                 } else {
5688                         r->domain_dn = NULL;
5689                 }
5690                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
5691         }
5692         if (ndr_flags & NDR_BUFFERS) {
5693                 if (r->server_dn) {
5694                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
5695                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
5696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
5697                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
5698                         size_server_dn_1 = ndr_get_array_size(ndr, &r->server_dn);
5699                         length_server_dn_1 = ndr_get_array_length(ndr, &r->server_dn);
5700                         if (length_server_dn_1 > size_server_dn_1) {
5701                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_dn_1, length_server_dn_1);
5702                         }
5703                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_dn_1, sizeof(uint16_t)));
5704                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, length_server_dn_1, sizeof(uint16_t), CH_UTF16));
5705                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
5706                 }
5707                 if (r->domain_dn) {
5708                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
5709                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
5710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
5711                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
5712                         size_domain_dn_1 = ndr_get_array_size(ndr, &r->domain_dn);
5713                         length_domain_dn_1 = ndr_get_array_length(ndr, &r->domain_dn);
5714                         if (length_domain_dn_1 > size_domain_dn_1) {
5715                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_dn_1, length_domain_dn_1);
5716                         }
5717                         NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_dn_1, sizeof(uint16_t)));
5718                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, length_domain_dn_1, sizeof(uint16_t), CH_UTF16));
5719                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
5720                 }
5721         }
5722         return NDR_ERR_SUCCESS;
5723 }
5724
5725 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
5726 {
5727         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
5728         ndr->depth++;
5729         ndr_print_ptr(ndr, "server_dn", r->server_dn);
5730         ndr->depth++;
5731         if (r->server_dn) {
5732                 ndr_print_string(ndr, "server_dn", r->server_dn);
5733         }
5734         ndr->depth--;
5735         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
5736         ndr->depth++;
5737         if (r->domain_dn) {
5738                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
5739         }
5740         ndr->depth--;
5741         ndr_print_uint32(ndr, "commit", r->commit);
5742         ndr->depth--;
5743 }
5744
5745 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
5746 {
5747         if (ndr_flags & NDR_SCALARS) {
5748                 int level = ndr_push_get_switch_value(ndr, r);
5749                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5750                 switch (level) {
5751                         case 1: {
5752                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
5753                         break; }
5754
5755                         default:
5756                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5757                 }
5758         }
5759         if (ndr_flags & NDR_BUFFERS) {
5760                 int level = ndr_push_get_switch_value(ndr, r);
5761                 switch (level) {
5762                         case 1:
5763                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
5764                         break;
5765
5766                         default:
5767                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5768                 }
5769         }
5770         return NDR_ERR_SUCCESS;
5771 }
5772
5773 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
5774 {
5775         int level;
5776         int32_t _level;
5777         level = ndr_pull_get_switch_value(ndr, r);
5778         if (ndr_flags & NDR_SCALARS) {
5779                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5780                 if (_level != level) {
5781                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5782                 }
5783                 switch (level) {
5784                         case 1: {
5785                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
5786                         break; }
5787
5788                         default:
5789                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5790                 }
5791         }
5792         if (ndr_flags & NDR_BUFFERS) {
5793                 switch (level) {
5794                         case 1:
5795                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
5796                         break;
5797
5798                         default:
5799                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5800                 }
5801         }
5802         return NDR_ERR_SUCCESS;
5803 }
5804
5805 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
5806 {
5807         int level;
5808         level = ndr_print_get_switch_value(ndr, r);
5809         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
5810         switch (level) {
5811                 case 1:
5812                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
5813                 break;
5814
5815                 default:
5816                         ndr_print_bad_level(ndr, name, level);
5817         }
5818 }
5819
5820 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
5821 {
5822         if (ndr_flags & NDR_SCALARS) {
5823                 NDR_CHECK(ndr_push_align(ndr, 4));
5824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
5825         }
5826         if (ndr_flags & NDR_BUFFERS) {
5827         }
5828         return NDR_ERR_SUCCESS;
5829 }
5830
5831 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
5832 {
5833         if (ndr_flags & NDR_SCALARS) {
5834                 NDR_CHECK(ndr_pull_align(ndr, 4));
5835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
5836         }
5837         if (ndr_flags & NDR_BUFFERS) {
5838         }
5839         return NDR_ERR_SUCCESS;
5840 }
5841
5842 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
5843 {
5844         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
5845         ndr->depth++;
5846         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
5847         ndr->depth--;
5848 }
5849
5850 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
5851 {
5852         if (ndr_flags & NDR_SCALARS) {
5853                 int level = ndr_push_get_switch_value(ndr, r);
5854                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5855                 switch (level) {
5856                         case 1: {
5857                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
5858                         break; }
5859
5860                         default:
5861                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5862                 }
5863         }
5864         if (ndr_flags & NDR_BUFFERS) {
5865                 int level = ndr_push_get_switch_value(ndr, r);
5866                 switch (level) {
5867                         case 1:
5868                         break;
5869
5870                         default:
5871                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5872                 }
5873         }
5874         return NDR_ERR_SUCCESS;
5875 }
5876
5877 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
5878 {
5879         int level;
5880         int32_t _level;
5881         level = ndr_pull_get_switch_value(ndr, r);
5882         if (ndr_flags & NDR_SCALARS) {
5883                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5884                 if (_level != level) {
5885                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5886                 }
5887                 switch (level) {
5888                         case 1: {
5889                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
5890                         break; }
5891
5892                         default:
5893                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5894                 }
5895         }
5896         if (ndr_flags & NDR_BUFFERS) {
5897                 switch (level) {
5898                         case 1:
5899                         break;
5900
5901                         default:
5902                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
5903                 }
5904         }
5905         return NDR_ERR_SUCCESS;
5906 }
5907
5908 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
5909 {
5910         int level;
5911         level = ndr_print_get_switch_value(ndr, r);
5912         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
5913         switch (level) {
5914                 case 1:
5915                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
5916                 break;
5917
5918                 default:
5919                         ndr_print_bad_level(ndr, name, level);
5920         }
5921 }
5922
5923 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
5924 {
5925         if (ndr_flags & NDR_SCALARS) {
5926                 NDR_CHECK(ndr_push_align(ndr, 4));
5927                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
5928                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
5929         }
5930         if (ndr_flags & NDR_BUFFERS) {
5931                 if (r->domain_name) {
5932                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
5933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
5935                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5936                 }
5937         }
5938         return NDR_ERR_SUCCESS;
5939 }
5940
5941 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
5942 {
5943         uint32_t _ptr_domain_name;
5944         uint32_t size_domain_name_1 = 0;
5945         uint32_t length_domain_name_1 = 0;
5946         TALLOC_CTX *_mem_save_domain_name_0;
5947         if (ndr_flags & NDR_SCALARS) {
5948                 NDR_CHECK(ndr_pull_align(ndr, 4));
5949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
5950                 if (_ptr_domain_name) {
5951                         NDR_PULL_ALLOC(ndr, r->domain_name);
5952                 } else {
5953                         r->domain_name = NULL;
5954                 }
5955                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
5956         }
5957         if (ndr_flags & NDR_BUFFERS) {
5958                 if (r->domain_name) {
5959                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5960                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
5961                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
5962                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
5963                         size_domain_name_1 = ndr_get_array_size(ndr, &r->domain_name);
5964                         length_domain_name_1 = ndr_get_array_length(ndr, &r->domain_name);
5965                         if (length_domain_name_1 > size_domain_name_1) {
5966                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_name_1, length_domain_name_1);
5967                         }
5968                         NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_name_1, sizeof(uint16_t)));
5969                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, length_domain_name_1, sizeof(uint16_t), CH_UTF16));
5970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
5971                 }
5972         }
5973         return NDR_ERR_SUCCESS;
5974 }
5975
5976 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
5977 {
5978         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
5979         ndr->depth++;
5980         ndr_print_ptr(ndr, "domain_name", r->domain_name);
5981         ndr->depth++;
5982         if (r->domain_name) {
5983                 ndr_print_string(ndr, "domain_name", r->domain_name);
5984         }
5985         ndr->depth--;
5986         ndr_print_int32(ndr, "level", r->level);
5987         ndr->depth--;
5988 }
5989
5990 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
5991 {
5992         if (ndr_flags & NDR_SCALARS) {
5993                 int level = ndr_push_get_switch_value(ndr, r);
5994                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5995                 switch (level) {
5996                         case 1: {
5997                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
5998                         break; }
5999
6000                         default:
6001                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6002                 }
6003         }
6004         if (ndr_flags & NDR_BUFFERS) {
6005                 int level = ndr_push_get_switch_value(ndr, r);
6006                 switch (level) {
6007                         case 1:
6008                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6009                         break;
6010
6011                         default:
6012                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6013                 }
6014         }
6015         return NDR_ERR_SUCCESS;
6016 }
6017
6018 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6019 {
6020         int level;
6021         int32_t _level;
6022         level = ndr_pull_get_switch_value(ndr, r);
6023         if (ndr_flags & NDR_SCALARS) {
6024                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6025                 if (_level != level) {
6026                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6027                 }
6028                 switch (level) {
6029                         case 1: {
6030                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6031                         break; }
6032
6033                         default:
6034                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6035                 }
6036         }
6037         if (ndr_flags & NDR_BUFFERS) {
6038                 switch (level) {
6039                         case 1:
6040                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6041                         break;
6042
6043                         default:
6044                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6045                 }
6046         }
6047         return NDR_ERR_SUCCESS;
6048 }
6049
6050 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6051 {
6052         int level;
6053         level = ndr_print_get_switch_value(ndr, r);
6054         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6055         switch (level) {
6056                 case 1:
6057                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6058                 break;
6059
6060                 default:
6061                         ndr_print_bad_level(ndr, name, level);
6062         }
6063 }
6064
6065 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6066 {
6067         if (ndr_flags & NDR_SCALARS) {
6068                 NDR_CHECK(ndr_push_align(ndr, 4));
6069                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6076         }
6077         if (ndr_flags & NDR_BUFFERS) {
6078                 if (r->netbios_name) {
6079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6082                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6083                 }
6084                 if (r->dns_name) {
6085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6088                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6089                 }
6090                 if (r->site_name) {
6091                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6094                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6095                 }
6096                 if (r->computer_dn) {
6097                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6100                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6101                 }
6102                 if (r->server_dn) {
6103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6106                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6107                 }
6108         }
6109         return NDR_ERR_SUCCESS;
6110 }
6111
6112 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6113 {
6114         uint32_t _ptr_netbios_name;
6115         uint32_t size_netbios_name_1 = 0;
6116         uint32_t length_netbios_name_1 = 0;
6117         TALLOC_CTX *_mem_save_netbios_name_0;
6118         uint32_t _ptr_dns_name;
6119         uint32_t size_dns_name_1 = 0;
6120         uint32_t length_dns_name_1 = 0;
6121         TALLOC_CTX *_mem_save_dns_name_0;
6122         uint32_t _ptr_site_name;
6123         uint32_t size_site_name_1 = 0;
6124         uint32_t length_site_name_1 = 0;
6125         TALLOC_CTX *_mem_save_site_name_0;
6126         uint32_t _ptr_computer_dn;
6127         uint32_t size_computer_dn_1 = 0;
6128         uint32_t length_computer_dn_1 = 0;
6129         TALLOC_CTX *_mem_save_computer_dn_0;
6130         uint32_t _ptr_server_dn;
6131         uint32_t size_server_dn_1 = 0;
6132         uint32_t length_server_dn_1 = 0;
6133         TALLOC_CTX *_mem_save_server_dn_0;
6134         if (ndr_flags & NDR_SCALARS) {
6135                 NDR_CHECK(ndr_pull_align(ndr, 4));
6136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6137                 if (_ptr_netbios_name) {
6138                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6139                 } else {
6140                         r->netbios_name = NULL;
6141                 }
6142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6143                 if (_ptr_dns_name) {
6144                         NDR_PULL_ALLOC(ndr, r->dns_name);
6145                 } else {
6146                         r->dns_name = NULL;
6147                 }
6148                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6149                 if (_ptr_site_name) {
6150                         NDR_PULL_ALLOC(ndr, r->site_name);
6151                 } else {
6152                         r->site_name = NULL;
6153                 }
6154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6155                 if (_ptr_computer_dn) {
6156                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6157                 } else {
6158                         r->computer_dn = NULL;
6159                 }
6160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6161                 if (_ptr_server_dn) {
6162                         NDR_PULL_ALLOC(ndr, r->server_dn);
6163                 } else {
6164                         r->server_dn = NULL;
6165                 }
6166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
6167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
6168         }
6169         if (ndr_flags & NDR_BUFFERS) {
6170                 if (r->netbios_name) {
6171                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6172                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
6173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
6174                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
6175                         size_netbios_name_1 = ndr_get_array_size(ndr, &r->netbios_name);
6176                         length_netbios_name_1 = ndr_get_array_length(ndr, &r->netbios_name);
6177                         if (length_netbios_name_1 > size_netbios_name_1) {
6178                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_netbios_name_1, length_netbios_name_1);
6179                         }
6180                         NDR_CHECK(ndr_check_string_terminator(ndr, length_netbios_name_1, sizeof(uint16_t)));
6181                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, length_netbios_name_1, sizeof(uint16_t), CH_UTF16));
6182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
6183                 }
6184                 if (r->dns_name) {
6185                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6186                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
6187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
6188                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
6189                         size_dns_name_1 = ndr_get_array_size(ndr, &r->dns_name);
6190                         length_dns_name_1 = ndr_get_array_length(ndr, &r->dns_name);
6191                         if (length_dns_name_1 > size_dns_name_1) {
6192                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dns_name_1, length_dns_name_1);
6193                         }
6194                         NDR_CHECK(ndr_check_string_terminator(ndr, length_dns_name_1, sizeof(uint16_t)));
6195                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, length_dns_name_1, sizeof(uint16_t), CH_UTF16));
6196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
6197                 }
6198                 if (r->site_name) {
6199                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6200                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
6201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
6202                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
6203                         size_site_name_1 = ndr_get_array_size(ndr, &r->site_name);
6204                         length_site_name_1 = ndr_get_array_length(ndr, &r->site_name);
6205                         if (length_site_name_1 > size_site_name_1) {
6206                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_name_1, length_site_name_1);
6207                         }
6208                         NDR_CHECK(ndr_check_string_terminator(ndr, length_site_name_1, sizeof(uint16_t)));
6209                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, length_site_name_1, sizeof(uint16_t), CH_UTF16));
6210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
6211                 }
6212                 if (r->computer_dn) {
6213                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6214                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
6215                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
6216                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
6217                         size_computer_dn_1 = ndr_get_array_size(ndr, &r->computer_dn);
6218                         length_computer_dn_1 = ndr_get_array_length(ndr, &r->computer_dn);
6219                         if (length_computer_dn_1 > size_computer_dn_1) {
6220                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_computer_dn_1, length_computer_dn_1);
6221                         }
6222                         NDR_CHECK(ndr_check_string_terminator(ndr, length_computer_dn_1, sizeof(uint16_t)));
6223                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, length_computer_dn_1, sizeof(uint16_t), CH_UTF16));
6224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
6225                 }
6226                 if (r->server_dn) {
6227                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6228                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6229                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6230                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6231                         size_server_dn_1 = ndr_get_array_size(ndr, &r->server_dn);
6232                         length_server_dn_1 = ndr_get_array_length(ndr, &r->server_dn);
6233                         if (length_server_dn_1 > size_server_dn_1) {
6234                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_dn_1, length_server_dn_1);
6235                         }
6236                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_dn_1, sizeof(uint16_t)));
6237                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, length_server_dn_1, sizeof(uint16_t), CH_UTF16));
6238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6239                 }
6240         }
6241         return NDR_ERR_SUCCESS;
6242 }
6243
6244 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
6245 {
6246         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
6247         ndr->depth++;
6248         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
6249         ndr->depth++;
6250         if (r->netbios_name) {
6251                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
6252         }
6253         ndr->depth--;
6254         ndr_print_ptr(ndr, "dns_name", r->dns_name);
6255         ndr->depth++;
6256         if (r->dns_name) {
6257                 ndr_print_string(ndr, "dns_name", r->dns_name);
6258         }
6259         ndr->depth--;
6260         ndr_print_ptr(ndr, "site_name", r->site_name);
6261         ndr->depth++;
6262         if (r->site_name) {
6263                 ndr_print_string(ndr, "site_name", r->site_name);
6264         }
6265         ndr->depth--;
6266         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
6267         ndr->depth++;
6268         if (r->computer_dn) {
6269                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
6270         }
6271         ndr->depth--;
6272         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6273         ndr->depth++;
6274         if (r->server_dn) {
6275                 ndr_print_string(ndr, "server_dn", r->server_dn);
6276         }
6277         ndr->depth--;
6278         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
6279         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
6280         ndr->depth--;
6281 }
6282
6283 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
6284 {
6285         uint32_t cntr_array_1;
6286         if (ndr_flags & NDR_SCALARS) {
6287                 NDR_CHECK(ndr_push_align(ndr, 4));
6288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6290         }
6291         if (ndr_flags & NDR_BUFFERS) {
6292                 if (r->array) {
6293                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6294                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6295                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6296                         }
6297                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6298                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6299                         }
6300                 }
6301         }
6302         return NDR_ERR_SUCCESS;
6303 }
6304
6305 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
6306 {
6307         uint32_t _ptr_array;
6308         uint32_t size_array_1 = 0;
6309         uint32_t cntr_array_1;
6310         TALLOC_CTX *_mem_save_array_0;
6311         TALLOC_CTX *_mem_save_array_1;
6312         if (ndr_flags & NDR_SCALARS) {
6313                 NDR_CHECK(ndr_pull_align(ndr, 4));
6314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6315                 if (r->count > 10000) {
6316                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6317                 }
6318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6319                 if (_ptr_array) {
6320                         NDR_PULL_ALLOC(ndr, r->array);
6321                 } else {
6322                         r->array = NULL;
6323                 }
6324         }
6325         if (ndr_flags & NDR_BUFFERS) {
6326                 if (r->array) {
6327                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6328                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6330                         size_array_1 = ndr_get_array_size(ndr, &r->array);
6331                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
6332                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6333                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6334                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
6335                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6336                         }
6337                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
6338                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6339                         }
6340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6341                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6342                 }
6343                 if (r->array) {
6344                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6345                 }
6346         }
6347         return NDR_ERR_SUCCESS;
6348 }
6349
6350 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
6351 {
6352         uint32_t cntr_array_1;
6353         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
6354         ndr->depth++;
6355         ndr_print_uint32(ndr, "count", r->count);
6356         ndr_print_ptr(ndr, "array", r->array);
6357         ndr->depth++;
6358         if (r->array) {
6359                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6360                 ndr->depth++;
6361                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6362                         char *idx_1=NULL;
6363                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6364                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
6365                                 free(idx_1);
6366                         }
6367                 }
6368                 ndr->depth--;
6369         }
6370         ndr->depth--;
6371         ndr->depth--;
6372 }
6373
6374 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
6375 {
6376         if (ndr_flags & NDR_SCALARS) {
6377                 NDR_CHECK(ndr_push_align(ndr, 4));
6378                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6381                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
6382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
6385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
6388                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
6389                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
6390                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
6391                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
6392         }
6393         if (ndr_flags & NDR_BUFFERS) {
6394                 if (r->netbios_name) {
6395                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6398                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6399                 }
6400                 if (r->dns_name) {
6401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6404                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6405                 }
6406                 if (r->site_name) {
6407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6411                 }
6412                 if (r->site_dn) {
6413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6416                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6417                 }
6418                 if (r->computer_dn) {
6419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6421                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6422                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6423                 }
6424                 if (r->server_dn) {
6425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6428                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6429                 }
6430                 if (r->ntds_dn) {
6431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6435                 }
6436         }
6437         return NDR_ERR_SUCCESS;
6438 }
6439
6440 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
6441 {
6442         uint32_t _ptr_netbios_name;
6443         uint32_t size_netbios_name_1 = 0;
6444         uint32_t length_netbios_name_1 = 0;
6445         TALLOC_CTX *_mem_save_netbios_name_0;
6446         uint32_t _ptr_dns_name;
6447         uint32_t size_dns_name_1 = 0;
6448         uint32_t length_dns_name_1 = 0;
6449         TALLOC_CTX *_mem_save_dns_name_0;
6450         uint32_t _ptr_site_name;
6451         uint32_t size_site_name_1 = 0;
6452         uint32_t length_site_name_1 = 0;
6453         TALLOC_CTX *_mem_save_site_name_0;
6454         uint32_t _ptr_site_dn;
6455         uint32_t size_site_dn_1 = 0;
6456         uint32_t length_site_dn_1 = 0;
6457         TALLOC_CTX *_mem_save_site_dn_0;
6458         uint32_t _ptr_computer_dn;
6459         uint32_t size_computer_dn_1 = 0;
6460         uint32_t length_computer_dn_1 = 0;
6461         TALLOC_CTX *_mem_save_computer_dn_0;
6462         uint32_t _ptr_server_dn;
6463         uint32_t size_server_dn_1 = 0;
6464         uint32_t length_server_dn_1 = 0;
6465         TALLOC_CTX *_mem_save_server_dn_0;
6466         uint32_t _ptr_ntds_dn;
6467         uint32_t size_ntds_dn_1 = 0;
6468         uint32_t length_ntds_dn_1 = 0;
6469         TALLOC_CTX *_mem_save_ntds_dn_0;
6470         if (ndr_flags & NDR_SCALARS) {
6471                 NDR_CHECK(ndr_pull_align(ndr, 4));
6472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6473                 if (_ptr_netbios_name) {
6474                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6475                 } else {
6476                         r->netbios_name = NULL;
6477                 }
6478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6479                 if (_ptr_dns_name) {
6480                         NDR_PULL_ALLOC(ndr, r->dns_name);
6481                 } else {
6482                         r->dns_name = NULL;
6483                 }
6484                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6485                 if (_ptr_site_name) {
6486                         NDR_PULL_ALLOC(ndr, r->site_name);
6487                 } else {
6488                         r->site_name = NULL;
6489                 }
6490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
6491                 if (_ptr_site_dn) {
6492                         NDR_PULL_ALLOC(ndr, r->site_dn);
6493                 } else {
6494                         r->site_dn = NULL;
6495                 }
6496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6497                 if (_ptr_computer_dn) {
6498                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6499                 } else {
6500                         r->computer_dn = NULL;
6501                 }
6502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6503                 if (_ptr_server_dn) {
6504                         NDR_PULL_ALLOC(ndr, r->server_dn);
6505                 } else {
6506                         r->server_dn = NULL;
6507                 }
6508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
6509                 if (_ptr_ntds_dn) {
6510                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
6511                 } else {
6512                         r->ntds_dn = NULL;
6513                 }
6514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
6515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
6516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
6517                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
6518                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
6519                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
6520                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
6521         }
6522         if (ndr_flags & NDR_BUFFERS) {
6523                 if (r->netbios_name) {
6524                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6525                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
6526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
6527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
6528                         size_netbios_name_1 = ndr_get_array_size(ndr, &r->netbios_name);
6529                         length_netbios_name_1 = ndr_get_array_length(ndr, &r->netbios_name);
6530                         if (length_netbios_name_1 > size_netbios_name_1) {
6531                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_netbios_name_1, length_netbios_name_1);
6532                         }
6533                         NDR_CHECK(ndr_check_string_terminator(ndr, length_netbios_name_1, sizeof(uint16_t)));
6534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, length_netbios_name_1, sizeof(uint16_t), CH_UTF16));
6535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
6536                 }
6537                 if (r->dns_name) {
6538                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6539                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
6540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
6541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
6542                         size_dns_name_1 = ndr_get_array_size(ndr, &r->dns_name);
6543                         length_dns_name_1 = ndr_get_array_length(ndr, &r->dns_name);
6544                         if (length_dns_name_1 > size_dns_name_1) {
6545                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dns_name_1, length_dns_name_1);
6546                         }
6547                         NDR_CHECK(ndr_check_string_terminator(ndr, length_dns_name_1, sizeof(uint16_t)));
6548                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, length_dns_name_1, sizeof(uint16_t), CH_UTF16));
6549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
6550                 }
6551                 if (r->site_name) {
6552                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6553                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
6554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
6555                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
6556                         size_site_name_1 = ndr_get_array_size(ndr, &r->site_name);
6557                         length_site_name_1 = ndr_get_array_length(ndr, &r->site_name);
6558                         if (length_site_name_1 > size_site_name_1) {
6559                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_name_1, length_site_name_1);
6560                         }
6561                         NDR_CHECK(ndr_check_string_terminator(ndr, length_site_name_1, sizeof(uint16_t)));
6562                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, length_site_name_1, sizeof(uint16_t), CH_UTF16));
6563                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
6564                 }
6565                 if (r->site_dn) {
6566                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6567                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
6568                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
6569                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
6570                         size_site_dn_1 = ndr_get_array_size(ndr, &r->site_dn);
6571                         length_site_dn_1 = ndr_get_array_length(ndr, &r->site_dn);
6572                         if (length_site_dn_1 > size_site_dn_1) {
6573                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_dn_1, length_site_dn_1);
6574                         }
6575                         NDR_CHECK(ndr_check_string_terminator(ndr, length_site_dn_1, sizeof(uint16_t)));
6576                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, length_site_dn_1, sizeof(uint16_t), CH_UTF16));
6577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
6578                 }
6579                 if (r->computer_dn) {
6580                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6581                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
6582                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
6583                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
6584                         size_computer_dn_1 = ndr_get_array_size(ndr, &r->computer_dn);
6585                         length_computer_dn_1 = ndr_get_array_length(ndr, &r->computer_dn);
6586                         if (length_computer_dn_1 > size_computer_dn_1) {
6587                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_computer_dn_1, length_computer_dn_1);
6588                         }
6589                         NDR_CHECK(ndr_check_string_terminator(ndr, length_computer_dn_1, sizeof(uint16_t)));
6590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, length_computer_dn_1, sizeof(uint16_t), CH_UTF16));
6591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
6592                 }
6593                 if (r->server_dn) {
6594                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6595                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6598                         size_server_dn_1 = ndr_get_array_size(ndr, &r->server_dn);
6599                         length_server_dn_1 = ndr_get_array_length(ndr, &r->server_dn);
6600                         if (length_server_dn_1 > size_server_dn_1) {
6601                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_dn_1, length_server_dn_1);
6602                         }
6603                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_dn_1, sizeof(uint16_t)));
6604                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, length_server_dn_1, sizeof(uint16_t), CH_UTF16));
6605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6606                 }
6607                 if (r->ntds_dn) {
6608                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6609                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
6610                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
6611                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
6612                         size_ntds_dn_1 = ndr_get_array_size(ndr, &r->ntds_dn);
6613                         length_ntds_dn_1 = ndr_get_array_length(ndr, &r->ntds_dn);
6614                         if (length_ntds_dn_1 > size_ntds_dn_1) {
6615                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ntds_dn_1, length_ntds_dn_1);
6616                         }
6617                         NDR_CHECK(ndr_check_string_terminator(ndr, length_ntds_dn_1, sizeof(uint16_t)));
6618                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, length_ntds_dn_1, sizeof(uint16_t), CH_UTF16));
6619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
6620                 }
6621         }
6622         return NDR_ERR_SUCCESS;
6623 }
6624
6625 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
6626 {
6627         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
6628         ndr->depth++;
6629         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
6630         ndr->depth++;
6631         if (r->netbios_name) {
6632                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
6633         }
6634         ndr->depth--;
6635         ndr_print_ptr(ndr, "dns_name", r->dns_name);
6636         ndr->depth++;
6637         if (r->dns_name) {
6638                 ndr_print_string(ndr, "dns_name", r->dns_name);
6639         }
6640         ndr->depth--;
6641         ndr_print_ptr(ndr, "site_name", r->site_name);
6642         ndr->depth++;
6643         if (r->site_name) {
6644                 ndr_print_string(ndr, "site_name", r->site_name);
6645         }
6646         ndr->depth--;
6647         ndr_print_ptr(ndr, "site_dn", r->site_dn);
6648         ndr->depth++;
6649         if (r->site_dn) {
6650                 ndr_print_string(ndr, "site_dn", r->site_dn);
6651         }
6652         ndr->depth--;
6653         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
6654         ndr->depth++;
6655         if (r->computer_dn) {
6656                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
6657         }
6658         ndr->depth--;
6659         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6660         ndr->depth++;
6661         if (r->server_dn) {
6662                 ndr_print_string(ndr, "server_dn", r->server_dn);
6663         }
6664         ndr->depth--;
6665         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
6666         ndr->depth++;
6667         if (r->ntds_dn) {
6668                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
6669         }
6670         ndr->depth--;
6671         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
6672         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
6673         ndr_print_uint32(ndr, "is_gc", r->is_gc);
6674         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
6675         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
6676         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
6677         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
6678         ndr->depth--;
6679 }
6680
6681 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
6682 {
6683         uint32_t cntr_array_1;
6684         if (ndr_flags & NDR_SCALARS) {
6685                 NDR_CHECK(ndr_push_align(ndr, 4));
6686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6688         }
6689         if (ndr_flags & NDR_BUFFERS) {
6690                 if (r->array) {
6691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6692                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6693                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6694                         }
6695                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6696                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6697                         }
6698                 }
6699         }
6700         return NDR_ERR_SUCCESS;
6701 }
6702
6703 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
6704 {
6705         uint32_t _ptr_array;
6706         uint32_t size_array_1 = 0;
6707         uint32_t cntr_array_1;
6708         TALLOC_CTX *_mem_save_array_0;
6709         TALLOC_CTX *_mem_save_array_1;
6710         if (ndr_flags & NDR_SCALARS) {
6711                 NDR_CHECK(ndr_pull_align(ndr, 4));
6712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6713                 if (r->count > 10000) {
6714                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6715                 }
6716                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6717                 if (_ptr_array) {
6718                         NDR_PULL_ALLOC(ndr, r->array);
6719                 } else {
6720                         r->array = NULL;
6721                 }
6722         }
6723         if (ndr_flags & NDR_BUFFERS) {
6724                 if (r->array) {
6725                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6726                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6727                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6728                         size_array_1 = ndr_get_array_size(ndr, &r->array);
6729                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
6730                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6731                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6732                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
6733                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6734                         }
6735                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
6736                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6737                         }
6738                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6739                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6740                 }
6741                 if (r->array) {
6742                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6743                 }
6744         }
6745         return NDR_ERR_SUCCESS;
6746 }
6747
6748 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
6749 {
6750         uint32_t cntr_array_1;
6751         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
6752         ndr->depth++;
6753         ndr_print_uint32(ndr, "count", r->count);
6754         ndr_print_ptr(ndr, "array", r->array);
6755         ndr->depth++;
6756         if (r->array) {
6757                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6758                 ndr->depth++;
6759                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6760                         char *idx_1=NULL;
6761                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6762                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
6763                                 free(idx_1);
6764                         }
6765                 }
6766                 ndr->depth--;
6767         }
6768         ndr->depth--;
6769         ndr->depth--;
6770 }
6771
6772 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
6773 {
6774         if (ndr_flags & NDR_SCALARS) {
6775                 NDR_CHECK(ndr_push_align(ndr, 4));
6776                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6778                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
6780                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
6783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
6786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
6787                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
6788                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
6789                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
6790                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
6791         }
6792         if (ndr_flags & NDR_BUFFERS) {
6793                 if (r->netbios_name) {
6794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6795                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6796                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6798                 }
6799                 if (r->dns_name) {
6800                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6801                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6802                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6804                 }
6805                 if (r->site_name) {
6806                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6807                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6808                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6809                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6810                 }
6811                 if (r->site_dn) {
6812                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6813                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6814                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
6815                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6816                 }
6817                 if (r->computer_dn) {
6818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6822                 }
6823                 if (r->server_dn) {
6824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6825                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6827                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6828                 }
6829                 if (r->ntds_dn) {
6830                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6831                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6832                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
6833                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6834                 }
6835         }
6836         return NDR_ERR_SUCCESS;
6837 }
6838
6839 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
6840 {
6841         uint32_t _ptr_netbios_name;
6842         uint32_t size_netbios_name_1 = 0;
6843         uint32_t length_netbios_name_1 = 0;
6844         TALLOC_CTX *_mem_save_netbios_name_0;
6845         uint32_t _ptr_dns_name;
6846         uint32_t size_dns_name_1 = 0;
6847         uint32_t length_dns_name_1 = 0;
6848         TALLOC_CTX *_mem_save_dns_name_0;
6849         uint32_t _ptr_site_name;
6850         uint32_t size_site_name_1 = 0;
6851         uint32_t length_site_name_1 = 0;
6852         TALLOC_CTX *_mem_save_site_name_0;
6853         uint32_t _ptr_site_dn;
6854         uint32_t size_site_dn_1 = 0;
6855         uint32_t length_site_dn_1 = 0;
6856         TALLOC_CTX *_mem_save_site_dn_0;
6857         uint32_t _ptr_computer_dn;
6858         uint32_t size_computer_dn_1 = 0;
6859         uint32_t length_computer_dn_1 = 0;
6860         TALLOC_CTX *_mem_save_computer_dn_0;
6861         uint32_t _ptr_server_dn;
6862         uint32_t size_server_dn_1 = 0;
6863         uint32_t length_server_dn_1 = 0;
6864         TALLOC_CTX *_mem_save_server_dn_0;
6865         uint32_t _ptr_ntds_dn;
6866         uint32_t size_ntds_dn_1 = 0;
6867         uint32_t length_ntds_dn_1 = 0;
6868         TALLOC_CTX *_mem_save_ntds_dn_0;
6869         if (ndr_flags & NDR_SCALARS) {
6870                 NDR_CHECK(ndr_pull_align(ndr, 4));
6871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6872                 if (_ptr_netbios_name) {
6873                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6874                 } else {
6875                         r->netbios_name = NULL;
6876                 }
6877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6878                 if (_ptr_dns_name) {
6879                         NDR_PULL_ALLOC(ndr, r->dns_name);
6880                 } else {
6881                         r->dns_name = NULL;
6882                 }
6883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6884                 if (_ptr_site_name) {
6885                         NDR_PULL_ALLOC(ndr, r->site_name);
6886                 } else {
6887                         r->site_name = NULL;
6888                 }
6889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
6890                 if (_ptr_site_dn) {
6891                         NDR_PULL_ALLOC(ndr, r->site_dn);
6892                 } else {
6893                         r->site_dn = NULL;
6894                 }
6895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6896                 if (_ptr_computer_dn) {
6897                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6898                 } else {
6899                         r->computer_dn = NULL;
6900                 }
6901                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6902                 if (_ptr_server_dn) {
6903                         NDR_PULL_ALLOC(ndr, r->server_dn);
6904                 } else {
6905                         r->server_dn = NULL;
6906                 }
6907                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
6908                 if (_ptr_ntds_dn) {
6909                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
6910                 } else {
6911                         r->ntds_dn = NULL;
6912                 }
6913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
6914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
6915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
6916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
6917                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
6918                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
6919                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
6920                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
6921         }
6922         if (ndr_flags & NDR_BUFFERS) {
6923                 if (r->netbios_name) {
6924                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6925                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
6926                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
6927                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
6928                         size_netbios_name_1 = ndr_get_array_size(ndr, &r->netbios_name);
6929                         length_netbios_name_1 = ndr_get_array_length(ndr, &r->netbios_name);
6930                         if (length_netbios_name_1 > size_netbios_name_1) {
6931                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_netbios_name_1, length_netbios_name_1);
6932                         }
6933                         NDR_CHECK(ndr_check_string_terminator(ndr, length_netbios_name_1, sizeof(uint16_t)));
6934                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, length_netbios_name_1, sizeof(uint16_t), CH_UTF16));
6935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
6936                 }
6937                 if (r->dns_name) {
6938                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6939                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
6940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
6941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
6942                         size_dns_name_1 = ndr_get_array_size(ndr, &r->dns_name);
6943                         length_dns_name_1 = ndr_get_array_length(ndr, &r->dns_name);
6944                         if (length_dns_name_1 > size_dns_name_1) {
6945                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dns_name_1, length_dns_name_1);
6946                         }
6947                         NDR_CHECK(ndr_check_string_terminator(ndr, length_dns_name_1, sizeof(uint16_t)));
6948                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, length_dns_name_1, sizeof(uint16_t), CH_UTF16));
6949                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
6950                 }
6951                 if (r->site_name) {
6952                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6953                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
6954                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
6955                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
6956                         size_site_name_1 = ndr_get_array_size(ndr, &r->site_name);
6957                         length_site_name_1 = ndr_get_array_length(ndr, &r->site_name);
6958                         if (length_site_name_1 > size_site_name_1) {
6959                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_name_1, length_site_name_1);
6960                         }
6961                         NDR_CHECK(ndr_check_string_terminator(ndr, length_site_name_1, sizeof(uint16_t)));
6962                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, length_site_name_1, sizeof(uint16_t), CH_UTF16));
6963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
6964                 }
6965                 if (r->site_dn) {
6966                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6967                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
6968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
6969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
6970                         size_site_dn_1 = ndr_get_array_size(ndr, &r->site_dn);
6971                         length_site_dn_1 = ndr_get_array_length(ndr, &r->site_dn);
6972                         if (length_site_dn_1 > size_site_dn_1) {
6973                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_dn_1, length_site_dn_1);
6974                         }
6975                         NDR_CHECK(ndr_check_string_terminator(ndr, length_site_dn_1, sizeof(uint16_t)));
6976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, length_site_dn_1, sizeof(uint16_t), CH_UTF16));
6977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
6978                 }
6979                 if (r->computer_dn) {
6980                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6981                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
6982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
6983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
6984                         size_computer_dn_1 = ndr_get_array_size(ndr, &r->computer_dn);
6985                         length_computer_dn_1 = ndr_get_array_length(ndr, &r->computer_dn);
6986                         if (length_computer_dn_1 > size_computer_dn_1) {
6987                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_computer_dn_1, length_computer_dn_1);
6988                         }
6989                         NDR_CHECK(ndr_check_string_terminator(ndr, length_computer_dn_1, sizeof(uint16_t)));
6990                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, length_computer_dn_1, sizeof(uint16_t), CH_UTF16));
6991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
6992                 }
6993                 if (r->server_dn) {
6994                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6995                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6996                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6997                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6998                         size_server_dn_1 = ndr_get_array_size(ndr, &r->server_dn);
6999                         length_server_dn_1 = ndr_get_array_length(ndr, &r->server_dn);
7000                         if (length_server_dn_1 > size_server_dn_1) {
7001                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_dn_1, length_server_dn_1);
7002                         }
7003                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_dn_1, sizeof(uint16_t)));
7004                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, length_server_dn_1, sizeof(uint16_t), CH_UTF16));
7005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7006                 }
7007                 if (r->ntds_dn) {
7008                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7009                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7010                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7011                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7012                         size_ntds_dn_1 = ndr_get_array_size(ndr, &r->ntds_dn);
7013                         length_ntds_dn_1 = ndr_get_array_length(ndr, &r->ntds_dn);
7014                         if (length_ntds_dn_1 > size_ntds_dn_1) {
7015                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ntds_dn_1, length_ntds_dn_1);
7016                         }
7017                         NDR_CHECK(ndr_check_string_terminator(ndr, length_ntds_dn_1, sizeof(uint16_t)));
7018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, length_ntds_dn_1, sizeof(uint16_t), CH_UTF16));
7019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7020                 }
7021         }
7022         return NDR_ERR_SUCCESS;
7023 }
7024
7025 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7026 {
7027         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7028         ndr->depth++;
7029         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7030         ndr->depth++;
7031         if (r->netbios_name) {
7032                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7033         }
7034         ndr->depth--;
7035         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7036         ndr->depth++;
7037         if (r->dns_name) {
7038                 ndr_print_string(ndr, "dns_name", r->dns_name);
7039         }
7040         ndr->depth--;
7041         ndr_print_ptr(ndr, "site_name", r->site_name);
7042         ndr->depth++;
7043         if (r->site_name) {
7044                 ndr_print_string(ndr, "site_name", r->site_name);
7045         }
7046         ndr->depth--;
7047         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7048         ndr->depth++;
7049         if (r->site_dn) {
7050                 ndr_print_string(ndr, "site_dn", r->site_dn);
7051         }
7052         ndr->depth--;
7053         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7054         ndr->depth++;
7055         if (r->computer_dn) {
7056                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7057         }
7058         ndr->depth--;
7059         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7060         ndr->depth++;
7061         if (r->server_dn) {
7062                 ndr_print_string(ndr, "server_dn", r->server_dn);
7063         }
7064         ndr->depth--;
7065         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7066         ndr->depth++;
7067         if (r->ntds_dn) {
7068                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7069         }
7070         ndr->depth--;
7071         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7072         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7073         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7074         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7075         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7076         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7077         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7078         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7079         ndr->depth--;
7080 }
7081
7082 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7083 {
7084         uint32_t cntr_array_1;
7085         if (ndr_flags & NDR_SCALARS) {
7086                 NDR_CHECK(ndr_push_align(ndr, 4));
7087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7088                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7089         }
7090         if (ndr_flags & NDR_BUFFERS) {
7091                 if (r->array) {
7092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7093                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7094                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7095                         }
7096                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7097                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7098                         }
7099                 }
7100         }
7101         return NDR_ERR_SUCCESS;
7102 }
7103
7104 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7105 {
7106         uint32_t _ptr_array;
7107         uint32_t size_array_1 = 0;
7108         uint32_t cntr_array_1;
7109         TALLOC_CTX *_mem_save_array_0;
7110         TALLOC_CTX *_mem_save_array_1;
7111         if (ndr_flags & NDR_SCALARS) {
7112                 NDR_CHECK(ndr_pull_align(ndr, 4));
7113                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7114                 if (r->count > 10000) {
7115                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7116                 }
7117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7118                 if (_ptr_array) {
7119                         NDR_PULL_ALLOC(ndr, r->array);
7120                 } else {
7121                         r->array = NULL;
7122                 }
7123         }
7124         if (ndr_flags & NDR_BUFFERS) {
7125                 if (r->array) {
7126                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7127                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7129                         size_array_1 = ndr_get_array_size(ndr, &r->array);
7130                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
7131                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7132                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7133                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7134                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7135                         }
7136                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7137                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7138                         }
7139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7141                 }
7142                 if (r->array) {
7143                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7144                 }
7145         }
7146         return NDR_ERR_SUCCESS;
7147 }
7148
7149 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7150 {
7151         uint32_t cntr_array_1;
7152         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7153         ndr->depth++;
7154         ndr_print_uint32(ndr, "count", r->count);
7155         ndr_print_ptr(ndr, "array", r->array);
7156         ndr->depth++;
7157         if (r->array) {
7158                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7159                 ndr->depth++;
7160                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7161                         char *idx_1=NULL;
7162                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7163                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7164                                 free(idx_1);
7165                         }
7166                 }
7167                 ndr->depth--;
7168         }
7169         ndr->depth--;
7170         ndr->depth--;
7171 }
7172
7173 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7174 {
7175         if (ndr_flags & NDR_SCALARS) {
7176                 NDR_CHECK(ndr_push_align(ndr, 4));
7177                 {
7178                         uint32_t _flags_save_ipv4address = ndr->flags;
7179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7180                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7181                         ndr->flags = _flags_save_ipv4address;
7182                 }
7183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7189         }
7190         if (ndr_flags & NDR_BUFFERS) {
7191                 if (r->client_account) {
7192                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7193                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7195                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7196                 }
7197         }
7198         return NDR_ERR_SUCCESS;
7199 }
7200
7201 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
7202 {
7203         uint32_t _ptr_client_account;
7204         uint32_t size_client_account_1 = 0;
7205         uint32_t length_client_account_1 = 0;
7206         TALLOC_CTX *_mem_save_client_account_0;
7207         if (ndr_flags & NDR_SCALARS) {
7208                 NDR_CHECK(ndr_pull_align(ndr, 4));
7209                 {
7210                         uint32_t _flags_save_ipv4address = ndr->flags;
7211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7212                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
7213                         ndr->flags = _flags_save_ipv4address;
7214                 }
7215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
7217                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
7218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
7219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
7220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
7221                 if (_ptr_client_account) {
7222                         NDR_PULL_ALLOC(ndr, r->client_account);
7223                 } else {
7224                         r->client_account = NULL;
7225                 }
7226         }
7227         if (ndr_flags & NDR_BUFFERS) {
7228                 if (r->client_account) {
7229                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7230                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
7231                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
7232                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
7233                         size_client_account_1 = ndr_get_array_size(ndr, &r->client_account);
7234                         length_client_account_1 = ndr_get_array_length(ndr, &r->client_account);
7235                         if (length_client_account_1 > size_client_account_1) {
7236                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_account_1, length_client_account_1);
7237                         }
7238                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_account_1, sizeof(uint16_t)));
7239                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, length_client_account_1, sizeof(uint16_t), CH_UTF16));
7240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
7241                 }
7242         }
7243         return NDR_ERR_SUCCESS;
7244 }
7245
7246 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
7247 {
7248         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
7249         ndr->depth++;
7250         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
7251         ndr_print_uint32(ndr, "unknown2", r->unknown2);
7252         ndr_print_uint32(ndr, "connection_time", r->connection_time);
7253         ndr_print_uint32(ndr, "unknown4", r->unknown4);
7254         ndr_print_uint32(ndr, "unknown5", r->unknown5);
7255         ndr_print_uint32(ndr, "unknown6", r->unknown6);
7256         ndr_print_ptr(ndr, "client_account", r->client_account);
7257         ndr->depth++;
7258         if (r->client_account) {
7259                 ndr_print_string(ndr, "client_account", r->client_account);
7260         }
7261         ndr->depth--;
7262         ndr->depth--;
7263 }
7264
7265 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
7266 {
7267         uint32_t cntr_array_1;
7268         if (ndr_flags & NDR_SCALARS) {
7269                 NDR_CHECK(ndr_push_align(ndr, 4));
7270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7271                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7272         }
7273         if (ndr_flags & NDR_BUFFERS) {
7274                 if (r->array) {
7275                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7276                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7277                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7278                         }
7279                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7280                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7281                         }
7282                 }
7283         }
7284         return NDR_ERR_SUCCESS;
7285 }
7286
7287 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
7288 {
7289         uint32_t _ptr_array;
7290         uint32_t size_array_1 = 0;
7291         uint32_t cntr_array_1;
7292         TALLOC_CTX *_mem_save_array_0;
7293         TALLOC_CTX *_mem_save_array_1;
7294         if (ndr_flags & NDR_SCALARS) {
7295                 NDR_CHECK(ndr_pull_align(ndr, 4));
7296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7297                 if (r->count > 10000) {
7298                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7299                 }
7300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7301                 if (_ptr_array) {
7302                         NDR_PULL_ALLOC(ndr, r->array);
7303                 } else {
7304                         r->array = NULL;
7305                 }
7306         }
7307         if (ndr_flags & NDR_BUFFERS) {
7308                 if (r->array) {
7309                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7310                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7312                         size_array_1 = ndr_get_array_size(ndr, &r->array);
7313                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
7314                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7315                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7316                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7317                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7318                         }
7319                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7320                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7321                         }
7322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7324                 }
7325                 if (r->array) {
7326                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7327                 }
7328         }
7329         return NDR_ERR_SUCCESS;
7330 }
7331
7332 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
7333 {
7334         uint32_t cntr_array_1;
7335         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
7336         ndr->depth++;
7337         ndr_print_uint32(ndr, "count", r->count);
7338         ndr_print_ptr(ndr, "array", r->array);
7339         ndr->depth++;
7340         if (r->array) {
7341                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7342                 ndr->depth++;
7343                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7344                         char *idx_1=NULL;
7345                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7346                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
7347                                 free(idx_1);
7348                         }
7349                 }
7350                 ndr->depth--;
7351         }
7352         ndr->depth--;
7353         ndr->depth--;
7354 }
7355
7356 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
7357 {
7358         if (ndr_flags & NDR_SCALARS) {
7359                 int level = ndr_push_get_switch_value(ndr, r);
7360                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
7361                 switch (level) {
7362                         case DRSUAPI_DC_INFO_CTR_1: {
7363                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
7364                         break; }
7365
7366                         case DRSUAPI_DC_INFO_CTR_2: {
7367                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
7368                         break; }
7369
7370                         case DRSUAPI_DC_INFO_CTR_3: {
7371                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
7372                         break; }
7373
7374                         case DRSUAPI_DC_CONNECTION_CTR_01: {
7375                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
7376                         break; }
7377
7378                         default:
7379                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7380                 }
7381         }
7382         if (ndr_flags & NDR_BUFFERS) {
7383                 int level = ndr_push_get_switch_value(ndr, r);
7384                 switch (level) {
7385                         case DRSUAPI_DC_INFO_CTR_1:
7386                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
7387                         break;
7388
7389                         case DRSUAPI_DC_INFO_CTR_2:
7390                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
7391                         break;
7392
7393                         case DRSUAPI_DC_INFO_CTR_3:
7394                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
7395                         break;
7396
7397                         case DRSUAPI_DC_CONNECTION_CTR_01:
7398                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
7399                         break;
7400
7401                         default:
7402                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7403                 }
7404         }
7405         return NDR_ERR_SUCCESS;
7406 }
7407
7408 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
7409 {
7410         int level;
7411         int32_t _level;
7412         level = ndr_pull_get_switch_value(ndr, r);
7413         if (ndr_flags & NDR_SCALARS) {
7414                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
7415                 if (_level != level) {
7416                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7417                 }
7418                 switch (level) {
7419                         case DRSUAPI_DC_INFO_CTR_1: {
7420                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
7421                         break; }
7422
7423                         case DRSUAPI_DC_INFO_CTR_2: {
7424                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
7425                         break; }
7426
7427                         case DRSUAPI_DC_INFO_CTR_3: {
7428                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
7429                         break; }
7430
7431                         case DRSUAPI_DC_CONNECTION_CTR_01: {
7432                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
7433                         break; }
7434
7435                         default:
7436                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7437                 }
7438         }
7439         if (ndr_flags & NDR_BUFFERS) {
7440                 switch (level) {
7441                         case DRSUAPI_DC_INFO_CTR_1:
7442                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
7443                         break;
7444
7445                         case DRSUAPI_DC_INFO_CTR_2:
7446                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
7447                         break;
7448
7449                         case DRSUAPI_DC_INFO_CTR_3:
7450                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
7451                         break;
7452
7453                         case DRSUAPI_DC_CONNECTION_CTR_01:
7454                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
7455                         break;
7456
7457                         default:
7458                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7459                 }
7460         }
7461         return NDR_ERR_SUCCESS;
7462 }
7463
7464 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
7465 {
7466         int level;
7467         level = ndr_print_get_switch_value(ndr, r);
7468         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
7469         switch (level) {
7470                 case DRSUAPI_DC_INFO_CTR_1:
7471                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
7472                 break;
7473
7474                 case DRSUAPI_DC_INFO_CTR_2:
7475                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
7476                 break;
7477
7478                 case DRSUAPI_DC_INFO_CTR_3:
7479                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
7480                 break;
7481
7482                 case DRSUAPI_DC_CONNECTION_CTR_01:
7483                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
7484                 break;
7485
7486                 default:
7487                         ndr_print_bad_level(ndr, name, level);
7488         }
7489 }
7490
7491 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
7492 {
7493         if (ndr_flags & NDR_SCALARS) {
7494                 NDR_CHECK(ndr_push_align(ndr, 4));
7495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
7496                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
7497         }
7498         if (ndr_flags & NDR_BUFFERS) {
7499                 if (r->next_object) {
7500                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
7501                 }
7502                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
7503         }
7504         return NDR_ERR_SUCCESS;
7505 }
7506
7507 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
7508 {
7509         uint32_t _ptr_next_object;
7510         TALLOC_CTX *_mem_save_next_object_0;
7511         if (ndr_flags & NDR_SCALARS) {
7512                 NDR_CHECK(ndr_pull_align(ndr, 4));
7513                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
7514                 if (_ptr_next_object) {
7515                         NDR_PULL_ALLOC(ndr, r->next_object);
7516                 } else {
7517                         r->next_object = NULL;
7518                 }
7519                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
7520         }
7521         if (ndr_flags & NDR_BUFFERS) {
7522                 if (r->next_object) {
7523                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
7524                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
7525                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
7526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
7527                 }
7528                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
7529         }
7530         return NDR_ERR_SUCCESS;
7531 }
7532
7533 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
7534 {
7535         if (ndr_flags & NDR_SCALARS) {
7536                 NDR_CHECK(ndr_push_align(ndr, 4));
7537                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
7538         }
7539         if (ndr_flags & NDR_BUFFERS) {
7540                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
7541         }
7542         return NDR_ERR_SUCCESS;
7543 }
7544
7545 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
7546 {
7547         if (ndr_flags & NDR_SCALARS) {
7548                 NDR_CHECK(ndr_pull_align(ndr, 4));
7549                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
7550         }
7551         if (ndr_flags & NDR_BUFFERS) {
7552                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
7553         }
7554         return NDR_ERR_SUCCESS;
7555 }
7556
7557 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
7558 {
7559         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
7560         ndr->depth++;
7561         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
7562         ndr->depth--;
7563 }
7564
7565 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
7566 {
7567         if (ndr_flags & NDR_SCALARS) {
7568                 int level = ndr_push_get_switch_value(ndr, r);
7569                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
7570                 switch (level) {
7571                         case 2: {
7572                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
7573                         break; }
7574
7575                         default:
7576                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7577                 }
7578         }
7579         if (ndr_flags & NDR_BUFFERS) {
7580                 int level = ndr_push_get_switch_value(ndr, r);
7581                 switch (level) {
7582                         case 2:
7583                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
7584                         break;
7585
7586                         default:
7587                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7588                 }
7589         }
7590         return NDR_ERR_SUCCESS;
7591 }
7592
7593 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
7594 {
7595         int level;
7596         int32_t _level;
7597         level = ndr_pull_get_switch_value(ndr, r);
7598         if (ndr_flags & NDR_SCALARS) {
7599                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
7600                 if (_level != level) {
7601                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7602                 }
7603                 switch (level) {
7604                         case 2: {
7605                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
7606                         break; }
7607
7608                         default:
7609                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7610                 }
7611         }
7612         if (ndr_flags & NDR_BUFFERS) {
7613                 switch (level) {
7614                         case 2:
7615                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
7616                         break;
7617
7618                         default:
7619                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7620                 }
7621         }
7622         return NDR_ERR_SUCCESS;
7623 }
7624
7625 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
7626 {
7627         int level;
7628         level = ndr_print_get_switch_value(ndr, r);
7629         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
7630         switch (level) {
7631                 case 2:
7632                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
7633                 break;
7634
7635                 default:
7636                         ndr_print_bad_level(ndr, name, level);
7637         }
7638 }
7639
7640 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
7641 {
7642         if (ndr_flags & NDR_SCALARS) {
7643                 NDR_CHECK(ndr_push_align(ndr, 4));
7644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
7645                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
7646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7647                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
7648         }
7649         if (ndr_flags & NDR_BUFFERS) {
7650         }
7651         return NDR_ERR_SUCCESS;
7652 }
7653
7654 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
7655 {
7656         if (ndr_flags & NDR_SCALARS) {
7657                 NDR_CHECK(ndr_pull_align(ndr, 4));
7658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
7659                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
7660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7661                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
7662         }
7663         if (ndr_flags & NDR_BUFFERS) {
7664         }
7665         return NDR_ERR_SUCCESS;
7666 }
7667
7668 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
7669 {
7670         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
7671         ndr->depth++;
7672         ndr_print_uint32(ndr, "unknown1", r->unknown1);
7673         ndr_print_WERROR(ndr, "status", r->status);
7674         ndr_print_uint32(ndr, "unknown2", r->unknown2);
7675         ndr_print_uint16(ndr, "unknown3", r->unknown3);
7676         ndr->depth--;
7677 }
7678
7679 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
7680 {
7681         if (ndr_flags & NDR_SCALARS) {
7682                 NDR_CHECK(ndr_push_align(ndr, 4));
7683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
7684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
7685         }
7686         if (ndr_flags & NDR_BUFFERS) {
7687                 if (r->data) {
7688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
7689                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
7690                 }
7691         }
7692         return NDR_ERR_SUCCESS;
7693 }
7694
7695 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
7696 {
7697         uint32_t _ptr_data;
7698         uint32_t size_data_1 = 0;
7699         TALLOC_CTX *_mem_save_data_0;
7700         if (ndr_flags & NDR_SCALARS) {
7701                 NDR_CHECK(ndr_pull_align(ndr, 4));
7702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
7703                 if (r->size > 10485760) {
7704                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7705                 }
7706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
7707                 if (_ptr_data) {
7708                         NDR_PULL_ALLOC(ndr, r->data);
7709                 } else {
7710                         r->data = NULL;
7711                 }
7712         }
7713         if (ndr_flags & NDR_BUFFERS) {
7714                 if (r->data) {
7715                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
7716                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
7717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
7718                         size_data_1 = ndr_get_array_size(ndr, &r->data);
7719                         NDR_PULL_ALLOC_N(ndr, r->data, size_data_1);
7720                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_1));
7721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
7722                 }
7723                 if (r->data) {
7724                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
7725                 }
7726         }
7727         return NDR_ERR_SUCCESS;
7728 }
7729
7730 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
7731 {
7732         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
7733         ndr->depth++;
7734         ndr_print_uint32(ndr, "size", r->size);
7735         ndr_print_ptr(ndr, "data", r->data);
7736         ndr->depth++;
7737         if (r->data) {
7738                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
7739         }
7740         ndr->depth--;
7741         ndr->depth--;
7742 }
7743
7744 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
7745 {
7746         if (ndr_flags & NDR_SCALARS) {
7747                 NDR_CHECK(ndr_push_align(ndr, 4));
7748                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
7749                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
7750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7751                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
7752         }
7753         if (ndr_flags & NDR_BUFFERS) {
7754                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
7755         }
7756         return NDR_ERR_SUCCESS;
7757 }
7758
7759 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
7760 {
7761         if (ndr_flags & NDR_SCALARS) {
7762                 NDR_CHECK(ndr_pull_align(ndr, 4));
7763                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
7764                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
7765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7766                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
7767         }
7768         if (ndr_flags & NDR_BUFFERS) {
7769                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
7770         }
7771         return NDR_ERR_SUCCESS;
7772 }
7773
7774 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
7775 {
7776         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
7777         ndr->depth++;
7778         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
7779         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
7780         ndr_print_uint32(ndr, "unknown2", r->unknown2);
7781         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
7782         ndr->depth--;
7783 }
7784
7785 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
7786 {
7787         if (ndr_flags & NDR_SCALARS) {
7788                 NDR_CHECK(ndr_push_align(ndr, 4));
7789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
7790                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
7791         }
7792         if (ndr_flags & NDR_BUFFERS) {
7793                 if (r->next) {
7794                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
7795                 }
7796                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
7797         }
7798         return NDR_ERR_SUCCESS;
7799 }
7800
7801 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
7802 {
7803         uint32_t _ptr_next;
7804         TALLOC_CTX *_mem_save_next_0;
7805         if (ndr_flags & NDR_SCALARS) {
7806                 NDR_CHECK(ndr_pull_align(ndr, 4));
7807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
7808                 if (_ptr_next) {
7809                         NDR_PULL_ALLOC(ndr, r->next);
7810                 } else {
7811                         r->next = NULL;
7812                 }
7813                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
7814         }
7815         if (ndr_flags & NDR_BUFFERS) {
7816                 if (r->next) {
7817                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
7818                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
7819                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
7820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
7821                 }
7822                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
7823         }
7824         return NDR_ERR_SUCCESS;
7825 }
7826
7827 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
7828 {
7829         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
7830         ndr->depth++;
7831         ndr_print_ptr(ndr, "next", r->next);
7832         ndr->depth++;
7833         if (r->next) {
7834                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
7835         }
7836         ndr->depth--;
7837         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
7838         ndr->depth--;
7839 }
7840
7841 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
7842 {
7843         if (ndr_flags & NDR_SCALARS) {
7844                 NDR_CHECK(ndr_push_align(ndr, 4));
7845                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
7846                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
7847                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
7848         }
7849         if (ndr_flags & NDR_BUFFERS) {
7850                 if (r->id) {
7851                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
7852                 }
7853                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
7854         }
7855         return NDR_ERR_SUCCESS;
7856 }
7857
7858 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
7859 {
7860         uint32_t _ptr_id;
7861         TALLOC_CTX *_mem_save_id_0;
7862         if (ndr_flags & NDR_SCALARS) {
7863                 NDR_CHECK(ndr_pull_align(ndr, 4));
7864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
7865                 if (_ptr_id) {
7866                         NDR_PULL_ALLOC(ndr, r->id);
7867                 } else {
7868                         r->id = NULL;
7869                 }
7870                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
7871                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
7872         }
7873         if (ndr_flags & NDR_BUFFERS) {
7874                 if (r->id) {
7875                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
7876                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
7877                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
7878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
7879                 }
7880                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
7881         }
7882         return NDR_ERR_SUCCESS;
7883 }
7884
7885 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
7886 {
7887         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
7888         ndr->depth++;
7889         ndr_print_ptr(ndr, "id", r->id);
7890         ndr->depth++;
7891         if (r->id) {
7892                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
7893         }
7894         ndr->depth--;
7895         ndr_print_WERROR(ndr, "status", r->status);
7896         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
7897         ndr->depth--;
7898 }
7899
7900 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
7901 {
7902         if (ndr_flags & NDR_SCALARS) {
7903                 int level = ndr_push_get_switch_value(ndr, r);
7904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7905                 switch (level) {
7906                         case 1: {
7907                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
7908                         break; }
7909
7910                         case 4: {
7911                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7912                         break; }
7913
7914                         case 5: {
7915                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7916                         break; }
7917
7918                         case 6: {
7919                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7920                         break; }
7921
7922                         case 7: {
7923                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7924                         break; }
7925
7926                         default:
7927                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7928                 }
7929         }
7930         if (ndr_flags & NDR_BUFFERS) {
7931                 int level = ndr_push_get_switch_value(ndr, r);
7932                 switch (level) {
7933                         case 1:
7934                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
7935                         break;
7936
7937                         case 4:
7938                         break;
7939
7940                         case 5:
7941                         break;
7942
7943                         case 6:
7944                         break;
7945
7946                         case 7:
7947                         break;
7948
7949                         default:
7950                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7951                 }
7952         }
7953         return NDR_ERR_SUCCESS;
7954 }
7955
7956 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
7957 {
7958         int level;
7959         uint32_t _level;
7960         level = ndr_pull_get_switch_value(ndr, r);
7961         if (ndr_flags & NDR_SCALARS) {
7962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7963                 if (_level != level) {
7964                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7965                 }
7966                 switch (level) {
7967                         case 1: {
7968                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
7969                         break; }
7970
7971                         case 4: {
7972                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7973                         break; }
7974
7975                         case 5: {
7976                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7977                         break; }
7978
7979                         case 6: {
7980                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7981                         break; }
7982
7983                         case 7: {
7984                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
7985                         break; }
7986
7987                         default:
7988                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7989                 }
7990         }
7991         if (ndr_flags & NDR_BUFFERS) {
7992                 switch (level) {
7993                         case 1:
7994                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
7995                         break;
7996
7997                         case 4:
7998                         break;
7999
8000                         case 5:
8001                         break;
8002
8003                         case 6:
8004                         break;
8005
8006                         case 7:
8007                         break;
8008
8009                         default:
8010                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8011                 }
8012         }
8013         return NDR_ERR_SUCCESS;
8014 }
8015
8016 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8017 {
8018         int level;
8019         level = ndr_print_get_switch_value(ndr, r);
8020         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8021         switch (level) {
8022                 case 1:
8023                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8024                 break;
8025
8026                 case 4:
8027                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8028                 break;
8029
8030                 case 5:
8031                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8032                 break;
8033
8034                 case 6:
8035                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8036                 break;
8037
8038                 case 7:
8039                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8040                 break;
8041
8042                 default:
8043                         ndr_print_bad_level(ndr, name, level);
8044         }
8045 }
8046
8047 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8048 {
8049         if (ndr_flags & NDR_SCALARS) {
8050                 NDR_CHECK(ndr_push_align(ndr, 4));
8051                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8054         }
8055         if (ndr_flags & NDR_BUFFERS) {
8056                 if (r->info) {
8057                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8058                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8059                 }
8060         }
8061         return NDR_ERR_SUCCESS;
8062 }
8063
8064 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8065 {
8066         uint32_t _ptr_info;
8067         TALLOC_CTX *_mem_save_info_0;
8068         if (ndr_flags & NDR_SCALARS) {
8069                 NDR_CHECK(ndr_pull_align(ndr, 4));
8070                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8072                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8073                 if (_ptr_info) {
8074                         NDR_PULL_ALLOC(ndr, r->info);
8075                 } else {
8076                         r->info = NULL;
8077                 }
8078         }
8079         if (ndr_flags & NDR_BUFFERS) {
8080                 if (r->info) {
8081                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8082                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8083                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8084                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8085                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8086                 }
8087         }
8088         return NDR_ERR_SUCCESS;
8089 }
8090
8091 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8092 {
8093         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8094         ndr->depth++;
8095         ndr_print_WERROR(ndr, "status", r->status);
8096         ndr_print_uint32(ndr, "level", r->level);
8097         ndr_print_ptr(ndr, "info", r->info);
8098         ndr->depth++;
8099         if (r->info) {
8100                 ndr_print_set_switch_value(ndr, r->info, r->level);
8101                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8102         }
8103         ndr->depth--;
8104         ndr->depth--;
8105 }
8106
8107 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8108 {
8109         if (ndr_flags & NDR_SCALARS) {
8110                 int level = ndr_push_get_switch_value(ndr, r);
8111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8112                 switch (level) {
8113                         case 1: {
8114                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8115                         break; }
8116
8117                         default:
8118                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8119                 }
8120         }
8121         if (ndr_flags & NDR_BUFFERS) {
8122                 int level = ndr_push_get_switch_value(ndr, r);
8123                 switch (level) {
8124                         case 1:
8125                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8126                         break;
8127
8128                         default:
8129                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8130                 }
8131         }
8132         return NDR_ERR_SUCCESS;
8133 }
8134
8135 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8136 {
8137         int level;
8138         uint32_t _level;
8139         level = ndr_pull_get_switch_value(ndr, r);
8140         if (ndr_flags & NDR_SCALARS) {
8141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8142                 if (_level != level) {
8143                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8144                 }
8145                 switch (level) {
8146                         case 1: {
8147                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8148                         break; }
8149
8150                         default:
8151                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8152                 }
8153         }
8154         if (ndr_flags & NDR_BUFFERS) {
8155                 switch (level) {
8156                         case 1:
8157                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8158                         break;
8159
8160                         default:
8161                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8162                 }
8163         }
8164         return NDR_ERR_SUCCESS;
8165 }
8166
8167 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8168 {
8169         int level;
8170         level = ndr_print_get_switch_value(ndr, r);
8171         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8172         switch (level) {
8173                 case 1:
8174                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8175                 break;
8176
8177                 default:
8178                         ndr_print_bad_level(ndr, name, level);
8179         }
8180 }
8181
8182 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8183 {
8184         if (ndr_flags & NDR_SCALARS) {
8185                 NDR_CHECK(ndr_push_align(ndr, 4));
8186                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
8187                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8188         }
8189         if (ndr_flags & NDR_BUFFERS) {
8190                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8191         }
8192         return NDR_ERR_SUCCESS;
8193 }
8194
8195 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
8196 {
8197         if (ndr_flags & NDR_SCALARS) {
8198                 NDR_CHECK(ndr_pull_align(ndr, 4));
8199                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
8200                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8201         }
8202         if (ndr_flags & NDR_BUFFERS) {
8203                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8204         }
8205         return NDR_ERR_SUCCESS;
8206 }
8207
8208 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8209 {
8210         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
8211         ndr->depth++;
8212         ndr_print_GUID(ndr, "guid", &r->guid);
8213         ndr_print_dom_sid28(ndr, "sid", &r->sid);
8214         ndr->depth--;
8215 }
8216
8217 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
8218 {
8219         uint32_t cntr_objects_1;
8220         if (ndr_flags & NDR_SCALARS) {
8221                 NDR_CHECK(ndr_push_align(ndr, 4));
8222                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8224                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8226                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
8227         }
8228         if (ndr_flags & NDR_BUFFERS) {
8229                 if (r->id) {
8230                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8231                 }
8232                 if (r->objects) {
8233                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8234                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8235                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8236                         }
8237                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8238                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8239                         }
8240                 }
8241         }
8242         return NDR_ERR_SUCCESS;
8243 }
8244
8245 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
8246 {
8247         uint32_t _ptr_id;
8248         TALLOC_CTX *_mem_save_id_0;
8249         uint32_t _ptr_objects;
8250         uint32_t size_objects_1 = 0;
8251         uint32_t cntr_objects_1;
8252         TALLOC_CTX *_mem_save_objects_0;
8253         TALLOC_CTX *_mem_save_objects_1;
8254         if (ndr_flags & NDR_SCALARS) {
8255                 NDR_CHECK(ndr_pull_align(ndr, 4));
8256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8257                 if (_ptr_id) {
8258                         NDR_PULL_ALLOC(ndr, r->id);
8259                 } else {
8260                         r->id = NULL;
8261                 }
8262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8263                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8265                 if (r->count > 10000) {
8266                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8267                 }
8268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
8269                 if (_ptr_objects) {
8270                         NDR_PULL_ALLOC(ndr, r->objects);
8271                 } else {
8272                         r->objects = NULL;
8273                 }
8274         }
8275         if (ndr_flags & NDR_BUFFERS) {
8276                 if (r->id) {
8277                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8278                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8279                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8281                 }
8282                 if (r->objects) {
8283                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
8284                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
8286                         size_objects_1 = ndr_get_array_size(ndr, &r->objects);
8287                         NDR_PULL_ALLOC_N(ndr, r->objects, size_objects_1);
8288                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
8289                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8290                         for (cntr_objects_1 = 0; cntr_objects_1 < size_objects_1; cntr_objects_1++) {
8291                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8292                         }
8293                         for (cntr_objects_1 = 0; cntr_objects_1 < size_objects_1; cntr_objects_1++) {
8294                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8295                         }
8296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
8297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
8298                 }
8299                 if (r->objects) {
8300                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
8301                 }
8302         }
8303         return NDR_ERR_SUCCESS;
8304 }
8305
8306 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
8307 {
8308         uint32_t cntr_objects_1;
8309         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
8310         ndr->depth++;
8311         ndr_print_ptr(ndr, "id", r->id);
8312         ndr->depth++;
8313         if (r->id) {
8314                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8315         }
8316         ndr->depth--;
8317         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8318         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8319         ndr_print_uint32(ndr, "count", r->count);
8320         ndr_print_ptr(ndr, "objects", r->objects);
8321         ndr->depth++;
8322         if (r->objects) {
8323                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
8324                 ndr->depth++;
8325                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
8326                         char *idx_1=NULL;
8327                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
8328                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
8329                                 free(idx_1);
8330                         }
8331                 }
8332                 ndr->depth--;
8333         }
8334         ndr->depth--;
8335         ndr->depth--;
8336 }
8337
8338 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
8339 {
8340         uint32_t cntr_objects_1;
8341         if (ndr_flags & NDR_SCALARS) {
8342                 NDR_CHECK(ndr_push_align(ndr, 4));
8343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
8346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
8348         }
8349         if (ndr_flags & NDR_BUFFERS) {
8350                 if (r->id) {
8351                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8352                 }
8353                 if (r->error) {
8354                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
8355                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
8356                 }
8357                 if (r->objects) {
8358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8359                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8360                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8361                         }
8362                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
8363                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8364                         }
8365                 }
8366         }
8367         return NDR_ERR_SUCCESS;
8368 }
8369
8370 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
8371 {
8372         uint32_t _ptr_id;
8373         TALLOC_CTX *_mem_save_id_0;
8374         uint32_t _ptr_error;
8375         TALLOC_CTX *_mem_save_error_0;
8376         uint32_t _ptr_objects;
8377         uint32_t size_objects_1 = 0;
8378         uint32_t cntr_objects_1;
8379         TALLOC_CTX *_mem_save_objects_0;
8380         TALLOC_CTX *_mem_save_objects_1;
8381         if (ndr_flags & NDR_SCALARS) {
8382                 NDR_CHECK(ndr_pull_align(ndr, 4));
8383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8384                 if (_ptr_id) {
8385                         NDR_PULL_ALLOC(ndr, r->id);
8386                 } else {
8387                         r->id = NULL;
8388                 }
8389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
8391                 if (_ptr_error) {
8392                         NDR_PULL_ALLOC(ndr, r->error);
8393                 } else {
8394                         r->error = NULL;
8395                 }
8396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8397                 if (r->count > 10000) {
8398                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8399                 }
8400                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
8401                 if (_ptr_objects) {
8402                         NDR_PULL_ALLOC(ndr, r->objects);
8403                 } else {
8404                         r->objects = NULL;
8405                 }
8406         }
8407         if (ndr_flags & NDR_BUFFERS) {
8408                 if (r->id) {
8409                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8410                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8411                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8412                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8413                 }
8414                 if (r->error) {
8415                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
8416                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
8417                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
8418                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
8419                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
8420                 }
8421                 if (r->objects) {
8422                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
8423                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8424                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
8425                         size_objects_1 = ndr_get_array_size(ndr, &r->objects);
8426                         NDR_PULL_ALLOC_N(ndr, r->objects, size_objects_1);
8427                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
8428                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
8429                         for (cntr_objects_1 = 0; cntr_objects_1 < size_objects_1; cntr_objects_1++) {
8430                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
8431                         }
8432                         for (cntr_objects_1 = 0; cntr_objects_1 < size_objects_1; cntr_objects_1++) {
8433                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
8434                         }
8435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
8436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
8437                 }
8438                 if (r->objects) {
8439                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
8440                 }
8441         }
8442         return NDR_ERR_SUCCESS;
8443 }
8444
8445 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
8446 {
8447         uint32_t cntr_objects_1;
8448         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
8449         ndr->depth++;
8450         ndr_print_ptr(ndr, "id", r->id);
8451         ndr->depth++;
8452         if (r->id) {
8453                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8454         }
8455         ndr->depth--;
8456         ndr_print_uint32(ndr, "level", r->level);
8457         ndr_print_ptr(ndr, "error", r->error);
8458         ndr->depth++;
8459         if (r->error) {
8460                 ndr_print_set_switch_value(ndr, r->error, r->level);
8461                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
8462         }
8463         ndr->depth--;
8464         ndr_print_uint32(ndr, "count", r->count);
8465         ndr_print_ptr(ndr, "objects", r->objects);
8466         ndr->depth++;
8467         if (r->objects) {
8468                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
8469                 ndr->depth++;
8470                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
8471                         char *idx_1=NULL;
8472                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
8473                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
8474                                 free(idx_1);
8475                         }
8476                 }
8477                 ndr->depth--;
8478         }
8479         ndr->depth--;
8480         ndr->depth--;
8481 }
8482
8483 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
8484 {
8485         if (ndr_flags & NDR_SCALARS) {
8486                 int level = ndr_push_get_switch_value(ndr, r);
8487                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8488                 switch (level) {
8489                         case 2: {
8490                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
8491                         break; }
8492
8493                         case 3: {
8494                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
8495                         break; }
8496
8497                         default:
8498                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8499                 }
8500         }
8501         if (ndr_flags & NDR_BUFFERS) {
8502                 int level = ndr_push_get_switch_value(ndr, r);
8503                 switch (level) {
8504                         case 2:
8505                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8506                         break;
8507
8508                         case 3:
8509                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8510                         break;
8511
8512                         default:
8513                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8514                 }
8515         }
8516         return NDR_ERR_SUCCESS;
8517 }
8518
8519 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
8520 {
8521         int level;
8522         int32_t _level;
8523         level = ndr_pull_get_switch_value(ndr, r);
8524         if (ndr_flags & NDR_SCALARS) {
8525                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8526                 if (_level != level) {
8527                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8528                 }
8529                 switch (level) {
8530                         case 2: {
8531                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
8532                         break; }
8533
8534                         case 3: {
8535                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
8536                         break; }
8537
8538                         default:
8539                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8540                 }
8541         }
8542         if (ndr_flags & NDR_BUFFERS) {
8543                 switch (level) {
8544                         case 2:
8545                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8546                         break;
8547
8548                         case 3:
8549                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8550                         break;
8551
8552                         default:
8553                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8554                 }
8555         }
8556         return NDR_ERR_SUCCESS;
8557 }
8558
8559 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
8560 {
8561         int level;
8562         level = ndr_print_get_switch_value(ndr, r);
8563         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
8564         switch (level) {
8565                 case 2:
8566                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
8567                 break;
8568
8569                 case 3:
8570                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
8571                 break;
8572
8573                 default:
8574                         ndr_print_bad_level(ndr, name, level);
8575         }
8576 }
8577
8578 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
8579 {
8580         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8581         return NDR_ERR_SUCCESS;
8582 }
8583
8584 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
8585 {
8586         uint32_t v;
8587         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8588         *r = v;
8589         return NDR_ERR_SUCCESS;
8590 }
8591
8592 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
8593 {
8594         const char *val = NULL;
8595
8596         switch (r) {
8597                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
8598                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
8599         }
8600         ndr_print_enum(ndr, name, "ENUM", val, r);
8601 }
8602
8603 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
8604 {
8605         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8606         return NDR_ERR_SUCCESS;
8607 }
8608
8609 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
8610 {
8611         uint32_t v;
8612         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8613         *r = v;
8614         return NDR_ERR_SUCCESS;
8615 }
8616
8617 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
8618 {
8619         const char *val = NULL;
8620
8621         switch (r) {
8622                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
8623                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
8624                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
8625                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
8626                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
8627                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
8628                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
8629                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
8630                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
8631                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
8632                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
8633                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
8634                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
8635                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
8636                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
8637         }
8638         ndr_print_enum(ndr, name, "ENUM", val, r);
8639 }
8640
8641 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
8642 {
8643         if (ndr_flags & NDR_SCALARS) {
8644                 NDR_CHECK(ndr_push_align(ndr, 4));
8645                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
8646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
8647                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
8648         }
8649         if (ndr_flags & NDR_BUFFERS) {
8650                 if (r->object_dn) {
8651                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
8652                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8653                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
8654                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8655                 }
8656         }
8657         return NDR_ERR_SUCCESS;
8658 }
8659
8660 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
8661 {
8662         uint32_t _ptr_object_dn;
8663         uint32_t size_object_dn_1 = 0;
8664         uint32_t length_object_dn_1 = 0;
8665         TALLOC_CTX *_mem_save_object_dn_0;
8666         if (ndr_flags & NDR_SCALARS) {
8667                 NDR_CHECK(ndr_pull_align(ndr, 4));
8668                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
8669                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
8670                 if (_ptr_object_dn) {
8671                         NDR_PULL_ALLOC(ndr, r->object_dn);
8672                 } else {
8673                         r->object_dn = NULL;
8674                 }
8675                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
8676         }
8677         if (ndr_flags & NDR_BUFFERS) {
8678                 if (r->object_dn) {
8679                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
8680                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
8681                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
8682                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
8683                         size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
8684                         length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
8685                         if (length_object_dn_1 > size_object_dn_1) {
8686                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
8687                         }
8688                         NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
8689                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
8690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
8691                 }
8692         }
8693         return NDR_ERR_SUCCESS;
8694 }
8695
8696 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
8697 {
8698         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
8699         ndr->depth++;
8700         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
8701         ndr_print_ptr(ndr, "object_dn", r->object_dn);
8702         ndr->depth++;
8703         if (r->object_dn) {
8704                 ndr_print_string(ndr, "object_dn", r->object_dn);
8705         }
8706         ndr->depth--;
8707         ndr_print_GUID(ndr, "guid1", &r->guid1);
8708         ndr->depth--;
8709 }
8710
8711 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
8712 {
8713         if (ndr_flags & NDR_SCALARS) {
8714                 NDR_CHECK(ndr_push_align(ndr, 4));
8715                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
8716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
8717                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
8718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
8720                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
8721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8722         }
8723         if (ndr_flags & NDR_BUFFERS) {
8724                 if (r->object_dn) {
8725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
8726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
8728                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8729                 }
8730                 if (r->string1) {
8731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
8732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
8734                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8735                 }
8736                 if (r->string2) {
8737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
8738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
8740                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8741                 }
8742         }
8743         return NDR_ERR_SUCCESS;
8744 }
8745
8746 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
8747 {
8748         uint32_t _ptr_object_dn;
8749         uint32_t size_object_dn_1 = 0;
8750         uint32_t length_object_dn_1 = 0;
8751         TALLOC_CTX *_mem_save_object_dn_0;
8752         uint32_t _ptr_string1;
8753         uint32_t size_string1_1 = 0;
8754         uint32_t length_string1_1 = 0;
8755         TALLOC_CTX *_mem_save_string1_0;
8756         uint32_t _ptr_string2;
8757         uint32_t size_string2_1 = 0;
8758         uint32_t length_string2_1 = 0;
8759         TALLOC_CTX *_mem_save_string2_0;
8760         if (ndr_flags & NDR_SCALARS) {
8761                 NDR_CHECK(ndr_pull_align(ndr, 4));
8762                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
8763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
8764                 if (_ptr_object_dn) {
8765                         NDR_PULL_ALLOC(ndr, r->object_dn);
8766                 } else {
8767                         r->object_dn = NULL;
8768                 }
8769                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
8770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8771                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
8772                 if (_ptr_string1) {
8773                         NDR_PULL_ALLOC(ndr, r->string1);
8774                 } else {
8775                         r->string1 = NULL;
8776                 }
8777                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
8778                 if (_ptr_string2) {
8779                         NDR_PULL_ALLOC(ndr, r->string2);
8780                 } else {
8781                         r->string2 = NULL;
8782                 }
8783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8784         }
8785         if (ndr_flags & NDR_BUFFERS) {
8786                 if (r->object_dn) {
8787                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
8788                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
8789                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
8790                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
8791                         size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
8792                         length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
8793                         if (length_object_dn_1 > size_object_dn_1) {
8794                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
8795                         }
8796                         NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
8797                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
8798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
8799                 }
8800                 if (r->string1) {
8801                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
8802                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
8803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
8804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
8805                         size_string1_1 = ndr_get_array_size(ndr, &r->string1);
8806                         length_string1_1 = ndr_get_array_length(ndr, &r->string1);
8807                         if (length_string1_1 > size_string1_1) {
8808                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_string1_1, length_string1_1);
8809                         }
8810                         NDR_CHECK(ndr_check_string_terminator(ndr, length_string1_1, sizeof(uint16_t)));
8811                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, length_string1_1, sizeof(uint16_t), CH_UTF16));
8812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
8813                 }
8814                 if (r->string2) {
8815                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
8816                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
8817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
8818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
8819                         size_string2_1 = ndr_get_array_size(ndr, &r->string2);
8820                         length_string2_1 = ndr_get_array_length(ndr, &r->string2);
8821                         if (length_string2_1 > size_string2_1) {
8822                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_string2_1, length_string2_1);
8823                         }
8824                         NDR_CHECK(ndr_check_string_terminator(ndr, length_string2_1, sizeof(uint16_t)));
8825                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, length_string2_1, sizeof(uint16_t), CH_UTF16));
8826                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
8827                 }
8828         }
8829         return NDR_ERR_SUCCESS;
8830 }
8831
8832 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
8833 {
8834         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
8835         ndr->depth++;
8836         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
8837         ndr_print_ptr(ndr, "object_dn", r->object_dn);
8838         ndr->depth++;
8839         if (r->object_dn) {
8840                 ndr_print_string(ndr, "object_dn", r->object_dn);
8841         }
8842         ndr->depth--;
8843         ndr_print_GUID(ndr, "guid1", &r->guid1);
8844         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8845         ndr_print_ptr(ndr, "string1", r->string1);
8846         ndr->depth++;
8847         if (r->string1) {
8848                 ndr_print_string(ndr, "string1", r->string1);
8849         }
8850         ndr->depth--;
8851         ndr_print_ptr(ndr, "string2", r->string2);
8852         ndr->depth++;
8853         if (r->string2) {
8854                 ndr_print_string(ndr, "string2", r->string2);
8855         }
8856         ndr->depth--;
8857         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8858         ndr->depth--;
8859 }
8860
8861 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
8862 {
8863         if (ndr_flags & NDR_SCALARS) {
8864                 int level = ndr_push_get_switch_value(ndr, r);
8865                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
8866                 switch (level) {
8867                         case DRSUAPI_DS_REPLICA_GET_INFO: {
8868                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
8869                         break; }
8870
8871                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
8872                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
8873                         break; }
8874
8875                         default:
8876                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8877                 }
8878         }
8879         if (ndr_flags & NDR_BUFFERS) {
8880                 int level = ndr_push_get_switch_value(ndr, r);
8881                 switch (level) {
8882                         case DRSUAPI_DS_REPLICA_GET_INFO:
8883                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
8884                         break;
8885
8886                         case DRSUAPI_DS_REPLICA_GET_INFO2:
8887                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
8888                         break;
8889
8890                         default:
8891                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8892                 }
8893         }
8894         return NDR_ERR_SUCCESS;
8895 }
8896
8897 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
8898 {
8899         int level;
8900         uint32_t _level;
8901         level = ndr_pull_get_switch_value(ndr, r);
8902         if (ndr_flags & NDR_SCALARS) {
8903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8904                 if (_level != level) {
8905                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8906                 }
8907                 switch (level) {
8908                         case DRSUAPI_DS_REPLICA_GET_INFO: {
8909                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
8910                         break; }
8911
8912                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
8913                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
8914                         break; }
8915
8916                         default:
8917                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8918                 }
8919         }
8920         if (ndr_flags & NDR_BUFFERS) {
8921                 switch (level) {
8922                         case DRSUAPI_DS_REPLICA_GET_INFO:
8923                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
8924                         break;
8925
8926                         case DRSUAPI_DS_REPLICA_GET_INFO2:
8927                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
8928                         break;
8929
8930                         default:
8931                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8932                 }
8933         }
8934         return NDR_ERR_SUCCESS;
8935 }
8936
8937 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
8938 {
8939         int level;
8940         level = ndr_print_get_switch_value(ndr, r);
8941         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
8942         switch (level) {
8943                 case DRSUAPI_DS_REPLICA_GET_INFO:
8944                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
8945                 break;
8946
8947                 case DRSUAPI_DS_REPLICA_GET_INFO2:
8948                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
8949                 break;
8950
8951                 default:
8952                         ndr_print_bad_level(ndr, name, level);
8953         }
8954 }
8955
8956 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
8957 {
8958         if (ndr_flags & NDR_SCALARS) {
8959                 NDR_CHECK(ndr_push_align(ndr, 8));
8960                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
8961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
8962                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
8963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
8964                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
8965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
8966                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
8967                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
8968                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
8969                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
8970                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
8971                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
8972                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
8973                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
8974                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
8975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
8976         }
8977         if (ndr_flags & NDR_BUFFERS) {
8978                 if (r->naming_context_dn) {
8979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
8980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
8982                         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));
8983                 }
8984                 if (r->source_dsa_obj_dn) {
8985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
8986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8987                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
8988                         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));
8989                 }
8990                 if (r->source_dsa_address) {
8991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
8992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
8994                         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));
8995                 }
8996                 if (r->transport_obj_dn) {
8997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
8998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9000                         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));
9001                 }
9002         }
9003         return NDR_ERR_SUCCESS;
9004 }
9005
9006 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9007 {
9008         uint32_t _ptr_naming_context_dn;
9009         uint32_t size_naming_context_dn_1 = 0;
9010         uint32_t length_naming_context_dn_1 = 0;
9011         TALLOC_CTX *_mem_save_naming_context_dn_0;
9012         uint32_t _ptr_source_dsa_obj_dn;
9013         uint32_t size_source_dsa_obj_dn_1 = 0;
9014         uint32_t length_source_dsa_obj_dn_1 = 0;
9015         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9016         uint32_t _ptr_source_dsa_address;
9017         uint32_t size_source_dsa_address_1 = 0;
9018         uint32_t length_source_dsa_address_1 = 0;
9019         TALLOC_CTX *_mem_save_source_dsa_address_0;
9020         uint32_t _ptr_transport_obj_dn;
9021         uint32_t size_transport_obj_dn_1 = 0;
9022         uint32_t length_transport_obj_dn_1 = 0;
9023         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9024         if (ndr_flags & NDR_SCALARS) {
9025                 NDR_CHECK(ndr_pull_align(ndr, 8));
9026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9027                 if (_ptr_naming_context_dn) {
9028                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9029                 } else {
9030                         r->naming_context_dn = NULL;
9031                 }
9032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9033                 if (_ptr_source_dsa_obj_dn) {
9034                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9035                 } else {
9036                         r->source_dsa_obj_dn = NULL;
9037                 }
9038                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9039                 if (_ptr_source_dsa_address) {
9040                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9041                 } else {
9042                         r->source_dsa_address = NULL;
9043                 }
9044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9045                 if (_ptr_transport_obj_dn) {
9046                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9047                 } else {
9048                         r->transport_obj_dn = NULL;
9049                 }
9050                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
9051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9052                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9053                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9054                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9055                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9056                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9057                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9058                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
9059                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
9060                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
9061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
9062         }
9063         if (ndr_flags & NDR_BUFFERS) {
9064                 if (r->naming_context_dn) {
9065                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9066                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
9067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
9068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
9069                         size_naming_context_dn_1 = ndr_get_array_size(ndr, &r->naming_context_dn);
9070                         length_naming_context_dn_1 = ndr_get_array_length(ndr, &r->naming_context_dn);
9071                         if (length_naming_context_dn_1 > size_naming_context_dn_1) {
9072                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_naming_context_dn_1, length_naming_context_dn_1);
9073                         }
9074                         NDR_CHECK(ndr_check_string_terminator(ndr, length_naming_context_dn_1, sizeof(uint16_t)));
9075                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->naming_context_dn, length_naming_context_dn_1, sizeof(uint16_t), CH_UTF16));
9076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
9077                 }
9078                 if (r->source_dsa_obj_dn) {
9079                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9080                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
9081                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
9082                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
9083                         size_source_dsa_obj_dn_1 = ndr_get_array_size(ndr, &r->source_dsa_obj_dn);
9084                         length_source_dsa_obj_dn_1 = ndr_get_array_length(ndr, &r->source_dsa_obj_dn);
9085                         if (length_source_dsa_obj_dn_1 > size_source_dsa_obj_dn_1) {
9086                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dsa_obj_dn_1, length_source_dsa_obj_dn_1);
9087                         }
9088                         NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dsa_obj_dn_1, sizeof(uint16_t)));
9089                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_obj_dn, length_source_dsa_obj_dn_1, sizeof(uint16_t), CH_UTF16));
9090                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
9091                 }
9092                 if (r->source_dsa_address) {
9093                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
9094                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
9095                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
9096                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
9097                         size_source_dsa_address_1 = ndr_get_array_size(ndr, &r->source_dsa_address);
9098                         length_source_dsa_address_1 = ndr_get_array_length(ndr, &r->source_dsa_address);
9099                         if (length_source_dsa_address_1 > size_source_dsa_address_1) {
9100                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dsa_address_1, length_source_dsa_address_1);
9101                         }
9102                         NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dsa_address_1, sizeof(uint16_t)));
9103                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, length_source_dsa_address_1, sizeof(uint16_t), CH_UTF16));
9104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
9105                 }
9106                 if (r->transport_obj_dn) {
9107                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9108                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
9109                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
9110                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
9111                         size_transport_obj_dn_1 = ndr_get_array_size(ndr, &r->transport_obj_dn);
9112                         length_transport_obj_dn_1 = ndr_get_array_length(ndr, &r->transport_obj_dn);
9113                         if (length_transport_obj_dn_1 > size_transport_obj_dn_1) {
9114                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_transport_obj_dn_1, length_transport_obj_dn_1);
9115                         }
9116                         NDR_CHECK(ndr_check_string_terminator(ndr, length_transport_obj_dn_1, sizeof(uint16_t)));
9117                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->transport_obj_dn, length_transport_obj_dn_1, sizeof(uint16_t), CH_UTF16));
9118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
9119                 }
9120         }
9121         return NDR_ERR_SUCCESS;
9122 }
9123
9124 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
9125 {
9126         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
9127         ndr->depth++;
9128         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
9129         ndr->depth++;
9130         if (r->naming_context_dn) {
9131                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
9132         }
9133         ndr->depth--;
9134         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
9135         ndr->depth++;
9136         if (r->source_dsa_obj_dn) {
9137                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
9138         }
9139         ndr->depth--;
9140         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
9141         ndr->depth++;
9142         if (r->source_dsa_address) {
9143                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
9144         }
9145         ndr->depth--;
9146         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
9147         ndr->depth++;
9148         if (r->transport_obj_dn) {
9149                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
9150         }
9151         ndr->depth--;
9152         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
9153         ndr_print_uint32(ndr, "reserved", r->reserved);
9154         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
9155         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
9156         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
9157         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
9158         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
9159         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
9160         ndr_print_NTTIME(ndr, "last_success", r->last_success);
9161         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
9162         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
9163         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
9164         ndr->depth--;
9165 }
9166
9167 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
9168 {
9169         uint32_t cntr_array_0;
9170         if (ndr_flags & NDR_SCALARS) {
9171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9172                 NDR_CHECK(ndr_push_align(ndr, 8));
9173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9175                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9176                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9177                 }
9178         }
9179         if (ndr_flags & NDR_BUFFERS) {
9180                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9181                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9182                 }
9183         }
9184         return NDR_ERR_SUCCESS;
9185 }
9186
9187 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
9188 {
9189         uint32_t size_array_0 = 0;
9190         uint32_t cntr_array_0;
9191         TALLOC_CTX *_mem_save_array_0;
9192         if (ndr_flags & NDR_SCALARS) {
9193                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9194                 NDR_CHECK(ndr_pull_align(ndr, 8));
9195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9197                 size_array_0 = ndr_get_array_size(ndr, &r->array);
9198                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
9199                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9200                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9201                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
9202                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9203                 }
9204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9205                 if (r->array) {
9206                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9207                 }
9208         }
9209         if (ndr_flags & NDR_BUFFERS) {
9210                 size_array_0 = ndr_get_array_size(ndr, &r->array);
9211                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9212                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9213                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
9214                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9215                 }
9216                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9217         }
9218         return NDR_ERR_SUCCESS;
9219 }
9220
9221 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
9222 {
9223         uint32_t cntr_array_0;
9224         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
9225         ndr->depth++;
9226         ndr_print_uint32(ndr, "count", r->count);
9227         ndr_print_uint32(ndr, "reserved", r->reserved);
9228         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9229         ndr->depth++;
9230         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9231                 char *idx_0=NULL;
9232                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9233                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
9234                         free(idx_0);
9235                 }
9236         }
9237         ndr->depth--;
9238         ndr->depth--;
9239 }
9240
9241 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
9242 {
9243         uint32_t cntr_array_0;
9244         if (ndr_flags & NDR_SCALARS) {
9245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9246                 NDR_CHECK(ndr_push_align(ndr, 8));
9247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9249                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9250                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9251                 }
9252         }
9253         if (ndr_flags & NDR_BUFFERS) {
9254         }
9255         return NDR_ERR_SUCCESS;
9256 }
9257
9258 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
9259 {
9260         uint32_t size_array_0 = 0;
9261         uint32_t cntr_array_0;
9262         TALLOC_CTX *_mem_save_array_0;
9263         if (ndr_flags & NDR_SCALARS) {
9264                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9265                 NDR_CHECK(ndr_pull_align(ndr, 8));
9266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9268                 size_array_0 = ndr_get_array_size(ndr, &r->array);
9269                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
9270                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9271                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9272                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
9273                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9274                 }
9275                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9276                 if (r->array) {
9277                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9278                 }
9279         }
9280         if (ndr_flags & NDR_BUFFERS) {
9281         }
9282         return NDR_ERR_SUCCESS;
9283 }
9284
9285 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
9286 {
9287         uint32_t cntr_array_0;
9288         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
9289         ndr->depth++;
9290         ndr_print_uint32(ndr, "count", r->count);
9291         ndr_print_uint32(ndr, "reserved", r->reserved);
9292         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9293         ndr->depth++;
9294         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9295                 char *idx_0=NULL;
9296                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9297                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
9298                         free(idx_0);
9299                 }
9300         }
9301         ndr->depth--;
9302         ndr->depth--;
9303 }
9304
9305 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
9306 {
9307         if (ndr_flags & NDR_SCALARS) {
9308                 NDR_CHECK(ndr_push_align(ndr, 8));
9309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
9310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
9311                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
9312                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9313                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
9314                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
9315         }
9316         if (ndr_flags & NDR_BUFFERS) {
9317                 if (r->attribute_name) {
9318                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9320                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9321                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9322                 }
9323         }
9324         return NDR_ERR_SUCCESS;
9325 }
9326
9327 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
9328 {
9329         uint32_t _ptr_attribute_name;
9330         uint32_t size_attribute_name_1 = 0;
9331         uint32_t length_attribute_name_1 = 0;
9332         TALLOC_CTX *_mem_save_attribute_name_0;
9333         if (ndr_flags & NDR_SCALARS) {
9334                 NDR_CHECK(ndr_pull_align(ndr, 8));
9335                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
9336                 if (_ptr_attribute_name) {
9337                         NDR_PULL_ALLOC(ndr, r->attribute_name);
9338                 } else {
9339                         r->attribute_name = NULL;
9340                 }
9341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
9342                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
9343                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
9344                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
9345                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
9346         }
9347         if (ndr_flags & NDR_BUFFERS) {
9348                 if (r->attribute_name) {
9349                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9350                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
9351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
9352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
9353                         size_attribute_name_1 = ndr_get_array_size(ndr, &r->attribute_name);
9354                         length_attribute_name_1 = ndr_get_array_length(ndr, &r->attribute_name);
9355                         if (length_attribute_name_1 > size_attribute_name_1) {
9356                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_attribute_name_1, length_attribute_name_1);
9357                         }
9358                         NDR_CHECK(ndr_check_string_terminator(ndr, length_attribute_name_1, sizeof(uint16_t)));
9359                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, length_attribute_name_1, sizeof(uint16_t), CH_UTF16));
9360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
9361                 }
9362         }
9363         return NDR_ERR_SUCCESS;
9364 }
9365
9366 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
9367 {
9368         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
9369         ndr->depth++;
9370         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
9371         ndr->depth++;
9372         if (r->attribute_name) {
9373                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
9374         }
9375         ndr->depth--;
9376         ndr_print_uint32(ndr, "version", r->version);
9377         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
9378         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
9379         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
9380         ndr_print_hyper(ndr, "local_usn", r->local_usn);
9381         ndr->depth--;
9382 }
9383
9384 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
9385 {
9386         uint32_t cntr_array_0;
9387         if (ndr_flags & NDR_SCALARS) {
9388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9389                 NDR_CHECK(ndr_push_align(ndr, 8));
9390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9392                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9393                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9394                 }
9395         }
9396         if (ndr_flags & NDR_BUFFERS) {
9397                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9398                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9399                 }
9400         }
9401         return NDR_ERR_SUCCESS;
9402 }
9403
9404 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
9405 {
9406         uint32_t size_array_0 = 0;
9407         uint32_t cntr_array_0;
9408         TALLOC_CTX *_mem_save_array_0;
9409         if (ndr_flags & NDR_SCALARS) {
9410                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9411                 NDR_CHECK(ndr_pull_align(ndr, 8));
9412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9414                 size_array_0 = ndr_get_array_size(ndr, &r->array);
9415                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
9416                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9417                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9418                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
9419                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9420                 }
9421                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9422                 if (r->array) {
9423                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9424                 }
9425         }
9426         if (ndr_flags & NDR_BUFFERS) {
9427                 size_array_0 = ndr_get_array_size(ndr, &r->array);
9428                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9429                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9430                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
9431                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9432                 }
9433                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9434         }
9435         return NDR_ERR_SUCCESS;
9436 }
9437
9438 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
9439 {
9440         uint32_t cntr_array_0;
9441         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
9442         ndr->depth++;
9443         ndr_print_uint32(ndr, "count", r->count);
9444         ndr_print_uint32(ndr, "reserved", r->reserved);
9445         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9446         ndr->depth++;
9447         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9448                 char *idx_0=NULL;
9449                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9450                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
9451                         free(idx_0);
9452                 }
9453         }
9454         ndr->depth--;
9455         ndr->depth--;
9456 }
9457
9458 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
9459 {
9460         if (ndr_flags & NDR_SCALARS) {
9461                 NDR_CHECK(ndr_push_align(ndr, 4));
9462                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
9463                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
9464                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
9465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
9466                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
9467         }
9468         if (ndr_flags & NDR_BUFFERS) {
9469                 if (r->dsa_obj_dn) {
9470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
9471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
9473                         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));
9474                 }
9475         }
9476         return NDR_ERR_SUCCESS;
9477 }
9478
9479 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
9480 {
9481         uint32_t _ptr_dsa_obj_dn;
9482         uint32_t size_dsa_obj_dn_1 = 0;
9483         uint32_t length_dsa_obj_dn_1 = 0;
9484         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
9485         if (ndr_flags & NDR_SCALARS) {
9486                 NDR_CHECK(ndr_pull_align(ndr, 4));
9487                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
9488                 if (_ptr_dsa_obj_dn) {
9489                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
9490                 } else {
9491                         r->dsa_obj_dn = NULL;
9492                 }
9493                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
9494                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
9495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
9496                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
9497         }
9498         if (ndr_flags & NDR_BUFFERS) {
9499                 if (r->dsa_obj_dn) {
9500                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9501                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
9502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
9503                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
9504                         size_dsa_obj_dn_1 = ndr_get_array_size(ndr, &r->dsa_obj_dn);
9505                         length_dsa_obj_dn_1 = ndr_get_array_length(ndr, &r->dsa_obj_dn);
9506                         if (length_dsa_obj_dn_1 > size_dsa_obj_dn_1) {
9507                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dsa_obj_dn_1, length_dsa_obj_dn_1);
9508                         }
9509                         NDR_CHECK(ndr_check_string_terminator(ndr, length_dsa_obj_dn_1, sizeof(uint16_t)));
9510                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dsa_obj_dn, length_dsa_obj_dn_1, sizeof(uint16_t), CH_UTF16));
9511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
9512                 }
9513         }
9514         return NDR_ERR_SUCCESS;
9515 }
9516
9517 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
9518 {
9519         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
9520         ndr->depth++;
9521         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
9522         ndr->depth++;
9523         if (r->dsa_obj_dn) {
9524                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
9525         }
9526         ndr->depth--;
9527         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
9528         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
9529         ndr_print_uint32(ndr, "num_failures", r->num_failures);
9530         ndr_print_WERROR(ndr, "last_result", r->last_result);
9531         ndr->depth--;
9532 }
9533
9534 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
9535 {
9536         uint32_t cntr_array_0;
9537         if (ndr_flags & NDR_SCALARS) {
9538                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9539                 NDR_CHECK(ndr_push_align(ndr, 4));
9540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9542                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9543                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9544                 }
9545         }
9546         if (ndr_flags & NDR_BUFFERS) {
9547                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9548                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9549                 }
9550         }
9551         return NDR_ERR_SUCCESS;
9552 }
9553
9554 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
9555 {
9556         uint32_t size_array_0 = 0;
9557         uint32_t cntr_array_0;
9558         TALLOC_CTX *_mem_save_array_0;
9559         if (ndr_flags & NDR_SCALARS) {
9560                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9561                 NDR_CHECK(ndr_pull_align(ndr, 4));
9562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9564                 size_array_0 = ndr_get_array_size(ndr, &r->array);
9565                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
9566                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9567                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9568                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
9569                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9570                 }
9571                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9572                 if (r->array) {
9573                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9574                 }
9575         }
9576         if (ndr_flags & NDR_BUFFERS) {
9577                 size_array_0 = ndr_get_array_size(ndr, &r->array);
9578                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9579                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9580                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
9581                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9582                 }
9583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9584         }
9585         return NDR_ERR_SUCCESS;
9586 }
9587
9588 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
9589 {
9590         uint32_t cntr_array_0;
9591         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
9592         ndr->depth++;
9593         ndr_print_uint32(ndr, "count", r->count);
9594         ndr_print_uint32(ndr, "reserved", r->reserved);
9595         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
9596         ndr->depth++;
9597         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
9598                 char *idx_0=NULL;
9599                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
9600                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
9601                         free(idx_0);
9602                 }
9603         }
9604         ndr->depth--;
9605         ndr->depth--;
9606 }
9607
9608 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
9609 {
9610         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
9611         return NDR_ERR_SUCCESS;
9612 }
9613
9614 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
9615 {
9616         uint16_t v;
9617         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
9618         *r = v;
9619         return NDR_ERR_SUCCESS;
9620 }
9621
9622 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
9623 {
9624         const char *val = NULL;
9625
9626         switch (r) {
9627                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
9628                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
9629                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
9630                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
9631                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
9632         }
9633         ndr_print_enum(ndr, name, "ENUM", val, r);
9634 }
9635
9636 static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
9637 {
9638         if (ndr_flags & NDR_SCALARS) {
9639                 int level = ndr_push_get_switch_value(ndr, r);
9640                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
9641                 switch (level) {
9642                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
9643                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
9644                         break; }
9645
9646                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
9647                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
9648                         break; }
9649
9650                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
9651                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
9652                         break; }
9653
9654                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
9655                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
9656                         break; }
9657
9658                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
9659                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
9660                         break; }
9661
9662                         default: {
9663                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
9664                         break; }
9665
9666                 }
9667         }
9668         if (ndr_flags & NDR_BUFFERS) {
9669                 int level = ndr_push_get_switch_value(ndr, r);
9670                 switch (level) {
9671                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
9672                         break;
9673
9674                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
9675                         break;
9676
9677                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
9678                         break;
9679
9680                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
9681                         break;
9682
9683                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
9684                         break;
9685
9686                         default:
9687                         break;
9688
9689                 }
9690         }
9691         return NDR_ERR_SUCCESS;
9692 }
9693
9694 static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
9695 {
9696         int level;
9697         uint16_t _level;
9698         level = ndr_pull_get_switch_value(ndr, r);
9699         if (ndr_flags & NDR_SCALARS) {
9700                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
9701                 if (_level != level) {
9702                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9703                 }
9704                 switch (level) {
9705                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
9706                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
9707                         break; }
9708
9709                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
9710                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
9711                         break; }
9712
9713                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
9714                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
9715                         break; }
9716
9717                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
9718                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
9719                         break; }
9720
9721                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
9722                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
9723                         break; }
9724
9725                         default: {
9726                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
9727                         break; }
9728
9729                 }
9730         }
9731         if (ndr_flags & NDR_BUFFERS) {
9732                 switch (level) {
9733                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
9734                         break;
9735
9736                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
9737                         break;
9738
9739                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
9740                         break;
9741
9742                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
9743                         break;
9744
9745                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
9746                         break;
9747
9748                         default:
9749                         break;
9750
9751                 }
9752         }
9753         return NDR_ERR_SUCCESS;
9754 }
9755
9756 _PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
9757 {
9758         int level;
9759         level = ndr_print_get_switch_value(ndr, r);
9760         ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
9761         switch (level) {
9762                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
9763                         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
9764                 break;
9765
9766                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
9767                         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
9768                 break;
9769
9770                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
9771                         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
9772                 break;
9773
9774                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
9775                         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
9776                 break;
9777
9778                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
9779                         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
9780                 break;
9781
9782                 default:
9783                         ndr_print_uint32(ndr, "unknown", r->unknown);
9784                 break;
9785
9786         }
9787 }
9788
9789 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
9790 {
9791         if (ndr_flags & NDR_SCALARS) {
9792                 NDR_CHECK(ndr_push_align(ndr, 4));
9793                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
9794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
9795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
9796                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
9797                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
9798                 NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
9799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
9800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
9801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
9802                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
9803                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
9804         }
9805         if (ndr_flags & NDR_BUFFERS) {
9806                 if (r->nc_dn) {
9807                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
9808                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9809                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
9810                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9811                 }
9812                 if (r->remote_dsa_obj_dn) {
9813                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
9814                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
9816                         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));
9817                 }
9818                 if (r->remote_dsa_address) {
9819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
9820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
9822                         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));
9823                 }
9824         }
9825         return NDR_ERR_SUCCESS;
9826 }
9827
9828 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
9829 {
9830         uint32_t _ptr_nc_dn;
9831         uint32_t size_nc_dn_1 = 0;
9832         uint32_t length_nc_dn_1 = 0;
9833         TALLOC_CTX *_mem_save_nc_dn_0;
9834         uint32_t _ptr_remote_dsa_obj_dn;
9835         uint32_t size_remote_dsa_obj_dn_1 = 0;
9836         uint32_t length_remote_dsa_obj_dn_1 = 0;
9837         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
9838         uint32_t _ptr_remote_dsa_address;
9839         uint32_t size_remote_dsa_address_1 = 0;
9840         uint32_t length_remote_dsa_address_1 = 0;
9841         TALLOC_CTX *_mem_save_remote_dsa_address_0;
9842         if (ndr_flags & NDR_SCALARS) {
9843                 NDR_CHECK(ndr_pull_align(ndr, 4));
9844                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
9845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
9846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
9847                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
9848                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
9849                 NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
9850                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
9851                 if (_ptr_nc_dn) {
9852                         NDR_PULL_ALLOC(ndr, r->nc_dn);
9853                 } else {
9854                         r->nc_dn = NULL;
9855                 }
9856                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
9857                 if (_ptr_remote_dsa_obj_dn) {
9858                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
9859                 } else {
9860                         r->remote_dsa_obj_dn = NULL;
9861                 }
9862                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
9863                 if (_ptr_remote_dsa_address) {
9864                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
9865                 } else {
9866                         r->remote_dsa_address = NULL;
9867                 }
9868                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
9869                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
9870         }
9871         if (ndr_flags & NDR_BUFFERS) {
9872                 if (r->nc_dn) {
9873                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9874                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
9875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
9876                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
9877                         size_nc_dn_1 = ndr_get_array_size(ndr, &r->nc_dn);
9878                         length_nc_dn_1 = ndr_get_array_length(ndr, &r->nc_dn);
9879                         if (length_nc_dn_1 > size_nc_dn_1) {
9880                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_nc_dn_1, length_nc_dn_1);
9881                         }
9882                         NDR_CHECK(ndr_check_string_terminator(ndr, length_nc_dn_1, sizeof(uint16_t)));
9883                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, length_nc_dn_1, sizeof(uint16_t), CH_UTF16));
9884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
9885                 }
9886                 if (r->remote_dsa_obj_dn) {
9887                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9888                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
9889                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
9890                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
9891                         size_remote_dsa_obj_dn_1 = ndr_get_array_size(ndr, &r->remote_dsa_obj_dn);
9892                         length_remote_dsa_obj_dn_1 = ndr_get_array_length(ndr, &r->remote_dsa_obj_dn);
9893                         if (length_remote_dsa_obj_dn_1 > size_remote_dsa_obj_dn_1) {
9894                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_remote_dsa_obj_dn_1, length_remote_dsa_obj_dn_1);
9895                         }
9896                         NDR_CHECK(ndr_check_string_terminator(ndr, length_remote_dsa_obj_dn_1, sizeof(uint16_t)));
9897                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote_dsa_obj_dn, length_remote_dsa_obj_dn_1, sizeof(uint16_t), CH_UTF16));
9898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
9899                 }
9900                 if (r->remote_dsa_address) {
9901                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
9902                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
9903                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
9904                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
9905                         size_remote_dsa_address_1 = ndr_get_array_size(ndr, &r->remote_dsa_address);
9906                         length_remote_dsa_address_1 = ndr_get_array_length(ndr, &r->remote_dsa_address);
9907                         if (length_remote_dsa_address_1 > size_remote_dsa_address_1) {
9908                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_remote_dsa_address_1, length_remote_dsa_address_1);
9909                         }
9910                         NDR_CHECK(ndr_check_string_terminator(ndr, length_remote_dsa_address_1, sizeof(uint16_t)));
9911                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote_dsa_address, length_remote_dsa_address_1, sizeof(uint16_t), CH_UTF16));
9912                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
9913                 }
9914         }
9915         return NDR_ERR_SUCCESS;
9916 }
9917
9918 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
9919 {
9920         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
9921         ndr->depth++;
9922         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
9923         ndr_print_uint32(ndr, "serial_num", r->serial_num);
9924         ndr_print_uint32(ndr, "priority", r->priority);
9925         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
9926         ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
9927         ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
9928         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
9929         ndr->depth++;
9930         if (r->nc_dn) {
9931                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
9932         }
9933         ndr->depth--;
9934         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
9935         ndr->depth++;
9936         if (r->remote_dsa_obj_dn) {
9937                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
9938         }
9939         ndr->depth--;
9940         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
9941         ndr->depth++;
9942         if (r->remote_dsa_address) {
9943                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
9944         }
9945         ndr->depth--;
9946         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
9947         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
9948         ndr->depth--;
9949 }
9950
9951 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
9952 {
9953         uint32_t cntr_array_0;
9954         if (ndr_flags & NDR_SCALARS) {
9955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9956                 NDR_CHECK(ndr_push_align(ndr, 4));
9957                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
9958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9959                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9960                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9961                 }
9962         }
9963         if (ndr_flags & NDR_BUFFERS) {
9964                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
9965                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9966                 }
9967         }
9968         return NDR_ERR_SUCCESS;
9969 }
9970
9971 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
9972 {
9973         uint32_t size_array_0 = 0;
9974         uint32_t cntr_array_0;
9975         TALLOC_CTX *_mem_save_array_0;
9976         if (ndr_flags & NDR_SCALARS) {
9977                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
9978                 NDR_CHECK(ndr_pull_align(ndr, 4));
9979                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
9980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9981                 size_array_0 = ndr_get_array_size(ndr, &r->array);
9982                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
9983                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9984                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9985                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
9986                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
9987                 }
9988                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
9989                 if (r->array) {
9990                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
9991                 }
9992         }
9993         if (ndr_flags & NDR_BUFFERS) {
9994                 size_array_0 = ndr_get_array_size(ndr, &r->array);
9995                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
9996                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
9997                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
9998                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
9999                 }
10000                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10001         }
10002         return NDR_ERR_SUCCESS;
10003 }
10004
10005 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10006 {
10007         uint32_t cntr_array_0;
10008         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10009         ndr->depth++;
10010         ndr_print_NTTIME(ndr, "time", r->time);
10011         ndr_print_uint32(ndr, "count", r->count);
10012         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10013         ndr->depth++;
10014         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10015                 char *idx_0=NULL;
10016                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10017                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10018                         free(idx_0);
10019                 }
10020         }
10021         ndr->depth--;
10022         ndr->depth--;
10023 }
10024
10025 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10026 {
10027         if (ndr_flags & NDR_SCALARS) {
10028                 NDR_CHECK(ndr_push_align(ndr, 8));
10029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10033                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10034                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10036                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10037                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10038                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10039                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10040         }
10041         if (ndr_flags & NDR_BUFFERS) {
10042                 if (r->attribute_name) {
10043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10046                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10047                 }
10048                 if (r->object_dn) {
10049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10052                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10053                 }
10054                 if (r->binary) {
10055                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10056                 }
10057         }
10058         return NDR_ERR_SUCCESS;
10059 }
10060
10061 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10062 {
10063         uint32_t _ptr_attribute_name;
10064         uint32_t size_attribute_name_1 = 0;
10065         uint32_t length_attribute_name_1 = 0;
10066         TALLOC_CTX *_mem_save_attribute_name_0;
10067         uint32_t _ptr_object_dn;
10068         uint32_t size_object_dn_1 = 0;
10069         uint32_t length_object_dn_1 = 0;
10070         TALLOC_CTX *_mem_save_object_dn_0;
10071         uint32_t _ptr_binary;
10072         TALLOC_CTX *_mem_save_binary_0;
10073         if (ndr_flags & NDR_SCALARS) {
10074                 NDR_CHECK(ndr_pull_align(ndr, 8));
10075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10076                 if (_ptr_attribute_name) {
10077                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10078                 } else {
10079                         r->attribute_name = NULL;
10080                 }
10081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10082                 if (_ptr_object_dn) {
10083                         NDR_PULL_ALLOC(ndr, r->object_dn);
10084                 } else {
10085                         r->object_dn = NULL;
10086                 }
10087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10089                 if (_ptr_binary) {
10090                         NDR_PULL_ALLOC(ndr, r->binary);
10091                 } else {
10092                         r->binary = NULL;
10093                 }
10094                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10095                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10097                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10098                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10099                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10100                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10101         }
10102         if (ndr_flags & NDR_BUFFERS) {
10103                 if (r->attribute_name) {
10104                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10105                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10108                         size_attribute_name_1 = ndr_get_array_size(ndr, &r->attribute_name);
10109                         length_attribute_name_1 = ndr_get_array_length(ndr, &r->attribute_name);
10110                         if (length_attribute_name_1 > size_attribute_name_1) {
10111                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_attribute_name_1, length_attribute_name_1);
10112                         }
10113                         NDR_CHECK(ndr_check_string_terminator(ndr, length_attribute_name_1, sizeof(uint16_t)));
10114                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, length_attribute_name_1, sizeof(uint16_t), CH_UTF16));
10115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10116                 }
10117                 if (r->object_dn) {
10118                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10119                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10120                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10121                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10122                         size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
10123                         length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
10124                         if (length_object_dn_1 > size_object_dn_1) {
10125                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
10126                         }
10127                         NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
10128                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
10129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10130                 }
10131                 if (r->binary) {
10132                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10133                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10134                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10136                 }
10137         }
10138         return NDR_ERR_SUCCESS;
10139 }
10140
10141 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10142 {
10143         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10144         ndr->depth++;
10145         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10146         ndr->depth++;
10147         if (r->attribute_name) {
10148                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10149         }
10150         ndr->depth--;
10151         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10152         ndr->depth++;
10153         if (r->object_dn) {
10154                 ndr_print_string(ndr, "object_dn", r->object_dn);
10155         }
10156         ndr->depth--;
10157         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);
10158         ndr_print_ptr(ndr, "binary", r->binary);
10159         ndr->depth++;
10160         if (r->binary) {
10161                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10162         }
10163         ndr->depth--;
10164         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10165         ndr_print_NTTIME(ndr, "created", r->created);
10166         ndr_print_uint32(ndr, "version", r->version);
10167         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10168         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10169         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10170         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10171         ndr->depth--;
10172 }
10173
10174 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10175 {
10176         uint32_t cntr_array_0;
10177         if (ndr_flags & NDR_SCALARS) {
10178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10179                 NDR_CHECK(ndr_push_align(ndr, 8));
10180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10181                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10182                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10183                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10184                 }
10185         }
10186         if (ndr_flags & NDR_BUFFERS) {
10187                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10188                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10189                 }
10190         }
10191         return NDR_ERR_SUCCESS;
10192 }
10193
10194 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10195 {
10196         uint32_t size_array_0 = 0;
10197         uint32_t cntr_array_0;
10198         TALLOC_CTX *_mem_save_array_0;
10199         if (ndr_flags & NDR_SCALARS) {
10200                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10201                 NDR_CHECK(ndr_pull_align(ndr, 8));
10202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10203                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10204                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10205                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10206                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10207                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10208                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10209                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10210                 }
10211                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10212                 if (r->array) {
10213                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10214                 }
10215         }
10216         if (ndr_flags & NDR_BUFFERS) {
10217                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10218                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10219                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10220                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10221                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10222                 }
10223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10224         }
10225         return NDR_ERR_SUCCESS;
10226 }
10227
10228 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10229 {
10230         uint32_t cntr_array_0;
10231         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10232         ndr->depth++;
10233         ndr_print_uint32(ndr, "count", r->count);
10234         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10235         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10236         ndr->depth++;
10237         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10238                 char *idx_0=NULL;
10239                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10240                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10241                         free(idx_0);
10242                 }
10243         }
10244         ndr->depth--;
10245         ndr->depth--;
10246 }
10247
10248 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
10249 {
10250         uint32_t cntr_array_0;
10251         if (ndr_flags & NDR_SCALARS) {
10252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10253                 NDR_CHECK(ndr_push_align(ndr, 8));
10254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10255                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10256                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10257                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10258                 }
10259         }
10260         if (ndr_flags & NDR_BUFFERS) {
10261         }
10262         return NDR_ERR_SUCCESS;
10263 }
10264
10265 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
10266 {
10267         uint32_t size_array_0 = 0;
10268         uint32_t cntr_array_0;
10269         TALLOC_CTX *_mem_save_array_0;
10270         if (ndr_flags & NDR_SCALARS) {
10271                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10272                 NDR_CHECK(ndr_pull_align(ndr, 8));
10273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10274                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10275                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10276                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10277                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10278                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10279                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10280                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10281                 }
10282                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10283                 if (r->array) {
10284                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10285                 }
10286         }
10287         if (ndr_flags & NDR_BUFFERS) {
10288         }
10289         return NDR_ERR_SUCCESS;
10290 }
10291
10292 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
10293 {
10294         uint32_t cntr_array_0;
10295         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
10296         ndr->depth++;
10297         ndr_print_uint32(ndr, "count", r->count);
10298         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10299         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10300         ndr->depth++;
10301         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10302                 char *idx_0=NULL;
10303                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10304                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
10305                         free(idx_0);
10306                 }
10307         }
10308         ndr->depth--;
10309         ndr->depth--;
10310 }
10311
10312 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
10313 {
10314         if (ndr_flags & NDR_SCALARS) {
10315                 NDR_CHECK(ndr_push_align(ndr, 8));
10316                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10317                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
10318                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
10319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
10320         }
10321         if (ndr_flags & NDR_BUFFERS) {
10322                 if (r->source_dsa_obj_dn) {
10323                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10326                         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));
10327                 }
10328         }
10329         return NDR_ERR_SUCCESS;
10330 }
10331
10332 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
10333 {
10334         uint32_t _ptr_source_dsa_obj_dn;
10335         uint32_t size_source_dsa_obj_dn_1 = 0;
10336         uint32_t length_source_dsa_obj_dn_1 = 0;
10337         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
10338         if (ndr_flags & NDR_SCALARS) {
10339                 NDR_CHECK(ndr_pull_align(ndr, 8));
10340                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10341                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
10342                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
10343                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
10344                 if (_ptr_source_dsa_obj_dn) {
10345                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
10346                 } else {
10347                         r->source_dsa_obj_dn = NULL;
10348                 }
10349         }
10350         if (ndr_flags & NDR_BUFFERS) {
10351                 if (r->source_dsa_obj_dn) {
10352                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10353                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10354                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10355                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10356                         size_source_dsa_obj_dn_1 = ndr_get_array_size(ndr, &r->source_dsa_obj_dn);
10357                         length_source_dsa_obj_dn_1 = ndr_get_array_length(ndr, &r->source_dsa_obj_dn);
10358                         if (length_source_dsa_obj_dn_1 > size_source_dsa_obj_dn_1) {
10359                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dsa_obj_dn_1, length_source_dsa_obj_dn_1);
10360                         }
10361                         NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dsa_obj_dn_1, sizeof(uint16_t)));
10362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_obj_dn, length_source_dsa_obj_dn_1, sizeof(uint16_t), CH_UTF16));
10363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10364                 }
10365         }
10366         return NDR_ERR_SUCCESS;
10367 }
10368
10369 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
10370 {
10371         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
10372         ndr->depth++;
10373         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10374         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10375         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
10376         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10377         ndr->depth++;
10378         if (r->source_dsa_obj_dn) {
10379                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10380         }
10381         ndr->depth--;
10382         ndr->depth--;
10383 }
10384
10385 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
10386 {
10387         uint32_t cntr_array_0;
10388         if (ndr_flags & NDR_SCALARS) {
10389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10390                 NDR_CHECK(ndr_push_align(ndr, 8));
10391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10392                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10393                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10394                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10395                 }
10396         }
10397         if (ndr_flags & NDR_BUFFERS) {
10398                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10399                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10400                 }
10401         }
10402         return NDR_ERR_SUCCESS;
10403 }
10404
10405 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
10406 {
10407         uint32_t size_array_0 = 0;
10408         uint32_t cntr_array_0;
10409         TALLOC_CTX *_mem_save_array_0;
10410         if (ndr_flags & NDR_SCALARS) {
10411                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10412                 NDR_CHECK(ndr_pull_align(ndr, 8));
10413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10414                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10415                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10416                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10417                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10418                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10419                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10420                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10421                 }
10422                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10423                 if (r->array) {
10424                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10425                 }
10426         }
10427         if (ndr_flags & NDR_BUFFERS) {
10428                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10429                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10430                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10431                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10432                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10433                 }
10434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10435         }
10436         return NDR_ERR_SUCCESS;
10437 }
10438
10439 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
10440 {
10441         uint32_t cntr_array_0;
10442         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
10443         ndr->depth++;
10444         ndr_print_uint32(ndr, "count", r->count);
10445         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10446         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10447         ndr->depth++;
10448         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10449                 char *idx_0=NULL;
10450                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10451                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
10452                         free(idx_0);
10453                 }
10454         }
10455         ndr->depth--;
10456         ndr->depth--;
10457 }
10458
10459 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
10460 {
10461         if (ndr_flags & NDR_SCALARS) {
10462                 NDR_CHECK(ndr_push_align(ndr, 8));
10463                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10465                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10466                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10467                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10468                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10469                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
10470         }
10471         if (ndr_flags & NDR_BUFFERS) {
10472                 if (r->attribute_name) {
10473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10476                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10477                 }
10478                 if (r->originating_dsa_dn) {
10479                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10482                         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));
10483                 }
10484         }
10485         return NDR_ERR_SUCCESS;
10486 }
10487
10488 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
10489 {
10490         uint32_t _ptr_attribute_name;
10491         uint32_t size_attribute_name_1 = 0;
10492         uint32_t length_attribute_name_1 = 0;
10493         TALLOC_CTX *_mem_save_attribute_name_0;
10494         uint32_t _ptr_originating_dsa_dn;
10495         uint32_t size_originating_dsa_dn_1 = 0;
10496         uint32_t length_originating_dsa_dn_1 = 0;
10497         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
10498         if (ndr_flags & NDR_SCALARS) {
10499                 NDR_CHECK(ndr_pull_align(ndr, 8));
10500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10501                 if (_ptr_attribute_name) {
10502                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10503                 } else {
10504                         r->attribute_name = NULL;
10505                 }
10506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10507                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10508                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10509                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10510                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10511                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
10512                 if (_ptr_originating_dsa_dn) {
10513                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
10514                 } else {
10515                         r->originating_dsa_dn = NULL;
10516                 }
10517         }
10518         if (ndr_flags & NDR_BUFFERS) {
10519                 if (r->attribute_name) {
10520                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10521                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10522                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10523                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10524                         size_attribute_name_1 = ndr_get_array_size(ndr, &r->attribute_name);
10525                         length_attribute_name_1 = ndr_get_array_length(ndr, &r->attribute_name);
10526                         if (length_attribute_name_1 > size_attribute_name_1) {
10527                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_attribute_name_1, length_attribute_name_1);
10528                         }
10529                         NDR_CHECK(ndr_check_string_terminator(ndr, length_attribute_name_1, sizeof(uint16_t)));
10530                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, length_attribute_name_1, sizeof(uint16_t), CH_UTF16));
10531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10532                 }
10533                 if (r->originating_dsa_dn) {
10534                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10535                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
10536                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
10537                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
10538                         size_originating_dsa_dn_1 = ndr_get_array_size(ndr, &r->originating_dsa_dn);
10539                         length_originating_dsa_dn_1 = ndr_get_array_length(ndr, &r->originating_dsa_dn);
10540                         if (length_originating_dsa_dn_1 > size_originating_dsa_dn_1) {
10541                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_originating_dsa_dn_1, length_originating_dsa_dn_1);
10542                         }
10543                         NDR_CHECK(ndr_check_string_terminator(ndr, length_originating_dsa_dn_1, sizeof(uint16_t)));
10544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->originating_dsa_dn, length_originating_dsa_dn_1, sizeof(uint16_t), CH_UTF16));
10545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
10546                 }
10547         }
10548         return NDR_ERR_SUCCESS;
10549 }
10550
10551 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
10552 {
10553         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
10554         ndr->depth++;
10555         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10556         ndr->depth++;
10557         if (r->attribute_name) {
10558                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10559         }
10560         ndr->depth--;
10561         ndr_print_uint32(ndr, "version", r->version);
10562         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10563         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10564         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10565         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10566         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10567         ndr->depth++;
10568         if (r->originating_dsa_dn) {
10569                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10570         }
10571         ndr->depth--;
10572         ndr->depth--;
10573 }
10574
10575 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
10576 {
10577         uint32_t cntr_array_0;
10578         if (ndr_flags & NDR_SCALARS) {
10579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10580                 NDR_CHECK(ndr_push_align(ndr, 8));
10581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10582                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10583                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10584                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10585                 }
10586         }
10587         if (ndr_flags & NDR_BUFFERS) {
10588                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10589                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10590                 }
10591         }
10592         return NDR_ERR_SUCCESS;
10593 }
10594
10595 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
10596 {
10597         uint32_t size_array_0 = 0;
10598         uint32_t cntr_array_0;
10599         TALLOC_CTX *_mem_save_array_0;
10600         if (ndr_flags & NDR_SCALARS) {
10601                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10602                 NDR_CHECK(ndr_pull_align(ndr, 8));
10603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10604                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10605                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10606                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10607                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10608                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10609                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10610                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10611                 }
10612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10613                 if (r->array) {
10614                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10615                 }
10616         }
10617         if (ndr_flags & NDR_BUFFERS) {
10618                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10619                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10620                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10621                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10622                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10623                 }
10624                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10625         }
10626         return NDR_ERR_SUCCESS;
10627 }
10628
10629 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
10630 {
10631         uint32_t cntr_array_0;
10632         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
10633         ndr->depth++;
10634         ndr_print_uint32(ndr, "count", r->count);
10635         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10636         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10637         ndr->depth++;
10638         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10639                 char *idx_0=NULL;
10640                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10641                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
10642                         free(idx_0);
10643                 }
10644         }
10645         ndr->depth--;
10646         ndr->depth--;
10647 }
10648
10649 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
10650 {
10651         if (ndr_flags & NDR_SCALARS) {
10652                 NDR_CHECK(ndr_push_align(ndr, 8));
10653                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10654                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10656                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10657                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10658                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10660                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10661                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10662                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10663                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10664                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
10665         }
10666         if (ndr_flags & NDR_BUFFERS) {
10667                 if (r->attribute_name) {
10668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10671                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10672                 }
10673                 if (r->object_dn) {
10674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10676                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10677                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10678                 }
10679                 if (r->binary) {
10680                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10681                 }
10682                 if (r->originating_dsa_dn) {
10683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
10686                         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));
10687                 }
10688         }
10689         return NDR_ERR_SUCCESS;
10690 }
10691
10692 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
10693 {
10694         uint32_t _ptr_attribute_name;
10695         uint32_t size_attribute_name_1 = 0;
10696         uint32_t length_attribute_name_1 = 0;
10697         TALLOC_CTX *_mem_save_attribute_name_0;
10698         uint32_t _ptr_object_dn;
10699         uint32_t size_object_dn_1 = 0;
10700         uint32_t length_object_dn_1 = 0;
10701         TALLOC_CTX *_mem_save_object_dn_0;
10702         uint32_t _ptr_binary;
10703         TALLOC_CTX *_mem_save_binary_0;
10704         uint32_t _ptr_originating_dsa_dn;
10705         uint32_t size_originating_dsa_dn_1 = 0;
10706         uint32_t length_originating_dsa_dn_1 = 0;
10707         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
10708         if (ndr_flags & NDR_SCALARS) {
10709                 NDR_CHECK(ndr_pull_align(ndr, 8));
10710                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10711                 if (_ptr_attribute_name) {
10712                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10713                 } else {
10714                         r->attribute_name = NULL;
10715                 }
10716                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10717                 if (_ptr_object_dn) {
10718                         NDR_PULL_ALLOC(ndr, r->object_dn);
10719                 } else {
10720                         r->object_dn = NULL;
10721                 }
10722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10724                 if (_ptr_binary) {
10725                         NDR_PULL_ALLOC(ndr, r->binary);
10726                 } else {
10727                         r->binary = NULL;
10728                 }
10729                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10730                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10732                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10733                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10734                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10735                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
10737                 if (_ptr_originating_dsa_dn) {
10738                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
10739                 } else {
10740                         r->originating_dsa_dn = NULL;
10741                 }
10742         }
10743         if (ndr_flags & NDR_BUFFERS) {
10744                 if (r->attribute_name) {
10745                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10746                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10747                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10748                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10749                         size_attribute_name_1 = ndr_get_array_size(ndr, &r->attribute_name);
10750                         length_attribute_name_1 = ndr_get_array_length(ndr, &r->attribute_name);
10751                         if (length_attribute_name_1 > size_attribute_name_1) {
10752                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_attribute_name_1, length_attribute_name_1);
10753                         }
10754                         NDR_CHECK(ndr_check_string_terminator(ndr, length_attribute_name_1, sizeof(uint16_t)));
10755                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, length_attribute_name_1, sizeof(uint16_t), CH_UTF16));
10756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10757                 }
10758                 if (r->object_dn) {
10759                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10760                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10761                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10762                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10763                         size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
10764                         length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
10765                         if (length_object_dn_1 > size_object_dn_1) {
10766                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
10767                         }
10768                         NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
10769                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
10770                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10771                 }
10772                 if (r->binary) {
10773                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10774                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10775                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10776                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10777                 }
10778                 if (r->originating_dsa_dn) {
10779                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10780                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
10781                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
10782                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
10783                         size_originating_dsa_dn_1 = ndr_get_array_size(ndr, &r->originating_dsa_dn);
10784                         length_originating_dsa_dn_1 = ndr_get_array_length(ndr, &r->originating_dsa_dn);
10785                         if (length_originating_dsa_dn_1 > size_originating_dsa_dn_1) {
10786                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_originating_dsa_dn_1, length_originating_dsa_dn_1);
10787                         }
10788                         NDR_CHECK(ndr_check_string_terminator(ndr, length_originating_dsa_dn_1, sizeof(uint16_t)));
10789                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->originating_dsa_dn, length_originating_dsa_dn_1, sizeof(uint16_t), CH_UTF16));
10790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
10791                 }
10792         }
10793         return NDR_ERR_SUCCESS;
10794 }
10795
10796 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
10797 {
10798         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
10799         ndr->depth++;
10800         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10801         ndr->depth++;
10802         if (r->attribute_name) {
10803                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10804         }
10805         ndr->depth--;
10806         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10807         ndr->depth++;
10808         if (r->object_dn) {
10809                 ndr_print_string(ndr, "object_dn", r->object_dn);
10810         }
10811         ndr->depth--;
10812         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);
10813         ndr_print_ptr(ndr, "binary", r->binary);
10814         ndr->depth++;
10815         if (r->binary) {
10816                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10817         }
10818         ndr->depth--;
10819         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10820         ndr_print_NTTIME(ndr, "created", r->created);
10821         ndr_print_uint32(ndr, "version", r->version);
10822         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10823         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10824         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10825         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10826         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10827         ndr->depth++;
10828         if (r->originating_dsa_dn) {
10829                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
10830         }
10831         ndr->depth--;
10832         ndr->depth--;
10833 }
10834
10835 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
10836 {
10837         uint32_t cntr_array_0;
10838         if (ndr_flags & NDR_SCALARS) {
10839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10840                 NDR_CHECK(ndr_push_align(ndr, 8));
10841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10842                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
10843                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10844                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10845                 }
10846         }
10847         if (ndr_flags & NDR_BUFFERS) {
10848                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10849                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10850                 }
10851         }
10852         return NDR_ERR_SUCCESS;
10853 }
10854
10855 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
10856 {
10857         uint32_t size_array_0 = 0;
10858         uint32_t cntr_array_0;
10859         TALLOC_CTX *_mem_save_array_0;
10860         if (ndr_flags & NDR_SCALARS) {
10861                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10862                 NDR_CHECK(ndr_pull_align(ndr, 8));
10863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10864                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
10865                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10866                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10867                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10868                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10869                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10870                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10871                 }
10872                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10873                 if (r->array) {
10874                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10875                 }
10876         }
10877         if (ndr_flags & NDR_BUFFERS) {
10878                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10879                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10880                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10881                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10882                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10883                 }
10884                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10885         }
10886         return NDR_ERR_SUCCESS;
10887 }
10888
10889 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
10890 {
10891         uint32_t cntr_array_0;
10892         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
10893         ndr->depth++;
10894         ndr_print_uint32(ndr, "count", r->count);
10895         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
10896         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10897         ndr->depth++;
10898         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10899                 char *idx_0=NULL;
10900                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10901                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
10902                         free(idx_0);
10903                 }
10904         }
10905         ndr->depth--;
10906         ndr->depth--;
10907 }
10908
10909 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
10910 {
10911         if (ndr_flags & NDR_SCALARS) {
10912                 NDR_CHECK(ndr_push_align(ndr, 8));
10913                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
10914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
10915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
10916                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
10917                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
10918                 {
10919                         uint32_t _flags_save_ipv4address = ndr->flags;
10920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
10921                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
10922                         ndr->flags = _flags_save_ipv4address;
10923                 }
10924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
10925         }
10926         if (ndr_flags & NDR_BUFFERS) {
10927         }
10928         return NDR_ERR_SUCCESS;
10929 }
10930
10931 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
10932 {
10933         if (ndr_flags & NDR_SCALARS) {
10934                 NDR_CHECK(ndr_pull_align(ndr, 8));
10935                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
10936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
10937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
10938                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
10939                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
10940                 {
10941                         uint32_t _flags_save_ipv4address = ndr->flags;
10942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
10943                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
10944                         ndr->flags = _flags_save_ipv4address;
10945                 }
10946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
10947         }
10948         if (ndr_flags & NDR_BUFFERS) {
10949         }
10950         return NDR_ERR_SUCCESS;
10951 }
10952
10953 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
10954 {
10955         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
10956         ndr->depth++;
10957         ndr_print_hyper(ndr, "u1", r->u1);
10958         ndr_print_uint32(ndr, "u2", r->u2);
10959         ndr_print_uint32(ndr, "u3", r->u3);
10960         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
10961         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
10962         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
10963         ndr_print_uint32(ndr, "u5", r->u5);
10964         ndr->depth--;
10965 }
10966
10967 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
10968 {
10969         uint32_t cntr_array_0;
10970         if (ndr_flags & NDR_SCALARS) {
10971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10972                 NDR_CHECK(ndr_push_align(ndr, 8));
10973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10975                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10976                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10977                 }
10978         }
10979         if (ndr_flags & NDR_BUFFERS) {
10980         }
10981         return NDR_ERR_SUCCESS;
10982 }
10983
10984 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
10985 {
10986         uint32_t size_array_0 = 0;
10987         uint32_t cntr_array_0;
10988         TALLOC_CTX *_mem_save_array_0;
10989         if (ndr_flags & NDR_SCALARS) {
10990                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10991                 NDR_CHECK(ndr_pull_align(ndr, 8));
10992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10993                 if (r->count > 10000) {
10994                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
10995                 }
10996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10997                 size_array_0 = ndr_get_array_size(ndr, &r->array);
10998                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10999                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11000                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11001                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11002                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11003                 }
11004                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11005                 if (r->array) {
11006                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11007                 }
11008         }
11009         if (ndr_flags & NDR_BUFFERS) {
11010         }
11011         return NDR_ERR_SUCCESS;
11012 }
11013
11014 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11015 {
11016         uint32_t cntr_array_0;
11017         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11018         ndr->depth++;
11019         ndr_print_uint32(ndr, "count", r->count);
11020         ndr_print_uint32(ndr, "reserved", r->reserved);
11021         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11022         ndr->depth++;
11023         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11024                 char *idx_0=NULL;
11025                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11026                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11027                         free(idx_0);
11028                 }
11029         }
11030         ndr->depth--;
11031         ndr->depth--;
11032 }
11033
11034 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11035 {
11036         if (ndr_flags & NDR_SCALARS) {
11037                 NDR_CHECK(ndr_push_align(ndr, 8));
11038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11044                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11046         }
11047         if (ndr_flags & NDR_BUFFERS) {
11048                 if (r->str1) {
11049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11052                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11053                 }
11054         }
11055         return NDR_ERR_SUCCESS;
11056 }
11057
11058 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11059 {
11060         uint32_t _ptr_str1;
11061         uint32_t size_str1_1 = 0;
11062         uint32_t length_str1_1 = 0;
11063         TALLOC_CTX *_mem_save_str1_0;
11064         if (ndr_flags & NDR_SCALARS) {
11065                 NDR_CHECK(ndr_pull_align(ndr, 8));
11066                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11067                 if (_ptr_str1) {
11068                         NDR_PULL_ALLOC(ndr, r->str1);
11069                 } else {
11070                         r->str1 = NULL;
11071                 }
11072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11075                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11077                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11078                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11079         }
11080         if (ndr_flags & NDR_BUFFERS) {
11081                 if (r->str1) {
11082                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11083                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11086                         size_str1_1 = ndr_get_array_size(ndr, &r->str1);
11087                         length_str1_1 = ndr_get_array_length(ndr, &r->str1);
11088                         if (length_str1_1 > size_str1_1) {
11089                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_str1_1, length_str1_1);
11090                         }
11091                         NDR_CHECK(ndr_check_string_terminator(ndr, length_str1_1, sizeof(uint16_t)));
11092                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, length_str1_1, sizeof(uint16_t), CH_UTF16));
11093                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11094                 }
11095         }
11096         return NDR_ERR_SUCCESS;
11097 }
11098
11099 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11100 {
11101         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11102         ndr->depth++;
11103         ndr_print_ptr(ndr, "str1", r->str1);
11104         ndr->depth++;
11105         if (r->str1) {
11106                 ndr_print_string(ndr, "str1", r->str1);
11107         }
11108         ndr->depth--;
11109         ndr_print_uint32(ndr, "u1", r->u1);
11110         ndr_print_uint32(ndr, "u2", r->u2);
11111         ndr_print_uint32(ndr, "u3", r->u3);
11112         ndr_print_uint32(ndr, "u4", r->u4);
11113         ndr_print_uint32(ndr, "u5", r->u5);
11114         ndr_print_hyper(ndr, "u6", r->u6);
11115         ndr_print_uint32(ndr, "u7", r->u7);
11116         ndr->depth--;
11117 }
11118
11119 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11120 {
11121         uint32_t cntr_array_0;
11122         if (ndr_flags & NDR_SCALARS) {
11123                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11124                 NDR_CHECK(ndr_push_align(ndr, 8));
11125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11127                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11128                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11129                 }
11130         }
11131         if (ndr_flags & NDR_BUFFERS) {
11132                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11133                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11134                 }
11135         }
11136         return NDR_ERR_SUCCESS;
11137 }
11138
11139 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11140 {
11141         uint32_t size_array_0 = 0;
11142         uint32_t cntr_array_0;
11143         TALLOC_CTX *_mem_save_array_0;
11144         if (ndr_flags & NDR_SCALARS) {
11145                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11146                 NDR_CHECK(ndr_pull_align(ndr, 8));
11147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11148                 if (r->count > 256) {
11149                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11150                 }
11151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11152                 size_array_0 = ndr_get_array_size(ndr, &r->array);
11153                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
11154                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11155                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11156                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11157                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11158                 }
11159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11160                 if (r->array) {
11161                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11162                 }
11163         }
11164         if (ndr_flags & NDR_BUFFERS) {
11165                 size_array_0 = ndr_get_array_size(ndr, &r->array);
11166                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11167                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11168                 for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11169                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11170                 }
11171                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11172         }
11173         return NDR_ERR_SUCCESS;
11174 }
11175
11176 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11177 {
11178         uint32_t cntr_array_0;
11179         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11180         ndr->depth++;
11181         ndr_print_uint32(ndr, "count", r->count);
11182         ndr_print_uint32(ndr, "reserved", r->reserved);
11183         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11184         ndr->depth++;
11185         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11186                 char *idx_0=NULL;
11187                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11188                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11189                         free(idx_0);
11190                 }
11191         }
11192         ndr->depth--;
11193         ndr->depth--;
11194 }
11195
11196 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11197 {
11198         if (ndr_flags & NDR_SCALARS) {
11199                 int level = ndr_push_get_switch_value(ndr, r);
11200                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11201                 switch (level) {
11202                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11203                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11204                         break; }
11205
11206                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11207                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11208                         break; }
11209
11210                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11211                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11212                         break; }
11213
11214                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11216                         break; }
11217
11218                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11220                         break; }
11221
11222                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11223                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11224                         break; }
11225
11226                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11227                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11228                         break; }
11229
11230                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11231                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11232                         break; }
11233
11234                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11235                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11236                         break; }
11237
11238                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11239                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11240                         break; }
11241
11242                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11243                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11244                         break; }
11245
11246                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11247                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
11248                         break; }
11249
11250                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
11251                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
11252                         break; }
11253
11254                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
11255                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
11256                         break; }
11257
11258                         case DRSUAPI_DS_REPLICA_INFO_06: {
11259                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
11260                         break; }
11261
11262                         default:
11263                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11264                 }
11265         }
11266         if (ndr_flags & NDR_BUFFERS) {
11267                 int level = ndr_push_get_switch_value(ndr, r);
11268                 switch (level) {
11269                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11270                                 if (r->neighbours) {
11271                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11272                                 }
11273                         break;
11274
11275                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11276                                 if (r->cursors) {
11277                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11278                                 }
11279                         break;
11280
11281                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11282                                 if (r->objmetadata) {
11283                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11284                                 }
11285                         break;
11286
11287                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11288                                 if (r->connectfailures) {
11289                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11290                                 }
11291                         break;
11292
11293                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11294                                 if (r->linkfailures) {
11295                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
11296                                 }
11297                         break;
11298
11299                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11300                                 if (r->pendingops) {
11301                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
11302                                 }
11303                         break;
11304
11305                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11306                                 if (r->attrvalmetadata) {
11307                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
11308                                 }
11309                         break;
11310
11311                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11312                                 if (r->cursors2) {
11313                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
11314                                 }
11315                         break;
11316
11317                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11318                                 if (r->cursors3) {
11319                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
11320                                 }
11321                         break;
11322
11323                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11324                                 if (r->objmetadata2) {
11325                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
11326                                 }
11327                         break;
11328
11329                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
11330                                 if (r->attrvalmetadata2) {
11331                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
11332                                 }
11333                         break;
11334
11335                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
11336                                 if (r->neighbours02) {
11337                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
11338                                 }
11339                         break;
11340
11341                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
11342                                 if (r->connections04) {
11343                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
11344                                 }
11345                         break;
11346
11347                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
11348                                 if (r->cursors05) {
11349                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
11350                                 }
11351                         break;
11352
11353                         case DRSUAPI_DS_REPLICA_INFO_06:
11354                                 if (r->i06) {
11355                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
11356                                 }
11357                         break;
11358
11359                         default:
11360                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11361                 }
11362         }
11363         return NDR_ERR_SUCCESS;
11364 }
11365
11366 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
11367 {
11368         int level;
11369         uint32_t _level;
11370         TALLOC_CTX *_mem_save_neighbours_0;
11371         uint32_t _ptr_neighbours;
11372         TALLOC_CTX *_mem_save_cursors_0;
11373         uint32_t _ptr_cursors;
11374         TALLOC_CTX *_mem_save_objmetadata_0;
11375         uint32_t _ptr_objmetadata;
11376         TALLOC_CTX *_mem_save_connectfailures_0;
11377         uint32_t _ptr_connectfailures;
11378         TALLOC_CTX *_mem_save_linkfailures_0;
11379         uint32_t _ptr_linkfailures;
11380         TALLOC_CTX *_mem_save_pendingops_0;
11381         uint32_t _ptr_pendingops;
11382         TALLOC_CTX *_mem_save_attrvalmetadata_0;
11383         uint32_t _ptr_attrvalmetadata;
11384         TALLOC_CTX *_mem_save_cursors2_0;
11385         uint32_t _ptr_cursors2;
11386         TALLOC_CTX *_mem_save_cursors3_0;
11387         uint32_t _ptr_cursors3;
11388         TALLOC_CTX *_mem_save_objmetadata2_0;
11389         uint32_t _ptr_objmetadata2;
11390         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
11391         uint32_t _ptr_attrvalmetadata2;
11392         TALLOC_CTX *_mem_save_neighbours02_0;
11393         uint32_t _ptr_neighbours02;
11394         TALLOC_CTX *_mem_save_connections04_0;
11395         uint32_t _ptr_connections04;
11396         TALLOC_CTX *_mem_save_cursors05_0;
11397         uint32_t _ptr_cursors05;
11398         TALLOC_CTX *_mem_save_i06_0;
11399         uint32_t _ptr_i06;
11400         level = ndr_pull_get_switch_value(ndr, r);
11401         if (ndr_flags & NDR_SCALARS) {
11402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11403                 if (_level != level) {
11404                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11405                 }
11406                 switch (level) {
11407                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11408                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
11409                                 if (_ptr_neighbours) {
11410                                         NDR_PULL_ALLOC(ndr, r->neighbours);
11411                                 } else {
11412                                         r->neighbours = NULL;
11413                                 }
11414                         break; }
11415
11416                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11417                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
11418                                 if (_ptr_cursors) {
11419                                         NDR_PULL_ALLOC(ndr, r->cursors);
11420                                 } else {
11421                                         r->cursors = NULL;
11422                                 }
11423                         break; }
11424
11425                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11426                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
11427                                 if (_ptr_objmetadata) {
11428                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
11429                                 } else {
11430                                         r->objmetadata = NULL;
11431                                 }
11432                         break; }
11433
11434                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11435                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
11436                                 if (_ptr_connectfailures) {
11437                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
11438                                 } else {
11439                                         r->connectfailures = NULL;
11440                                 }
11441                         break; }
11442
11443                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11444                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
11445                                 if (_ptr_linkfailures) {
11446                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
11447                                 } else {
11448                                         r->linkfailures = NULL;
11449                                 }
11450                         break; }
11451
11452                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11453                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
11454                                 if (_ptr_pendingops) {
11455                                         NDR_PULL_ALLOC(ndr, r->pendingops);
11456                                 } else {
11457                                         r->pendingops = NULL;
11458                                 }
11459                         break; }
11460
11461                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11462                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
11463                                 if (_ptr_attrvalmetadata) {
11464                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
11465                                 } else {
11466                                         r->attrvalmetadata = NULL;
11467                                 }
11468                         break; }
11469
11470                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11471                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
11472                                 if (_ptr_cursors2) {
11473                                         NDR_PULL_ALLOC(ndr, r->cursors2);
11474                                 } else {
11475                                         r->cursors2 = NULL;
11476                                 }
11477                         break; }
11478
11479                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11480                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
11481                                 if (_ptr_cursors3) {
11482                                         NDR_PULL_ALLOC(ndr, r->cursors3);
11483                                 } else {
11484                                         r->cursors3 = NULL;
11485                                 }
11486                         break; }
11487
11488                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11489                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
11490                                 if (_ptr_objmetadata2) {
11491                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
11492                                 } else {
11493                                         r->objmetadata2 = NULL;
11494                                 }
11495                         break; }
11496
11497                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11498                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
11499                                 if (_ptr_attrvalmetadata2) {
11500                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
11501                                 } else {
11502                                         r->attrvalmetadata2 = NULL;
11503                                 }
11504                         break; }
11505
11506                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11507                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
11508                                 if (_ptr_neighbours02) {
11509                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
11510                                 } else {
11511                                         r->neighbours02 = NULL;
11512                                 }
11513                         break; }
11514
11515                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
11516                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
11517                                 if (_ptr_connections04) {
11518                                         NDR_PULL_ALLOC(ndr, r->connections04);
11519                                 } else {
11520                                         r->connections04 = NULL;
11521                                 }
11522                         break; }
11523
11524                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
11525                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
11526                                 if (_ptr_cursors05) {
11527                                         NDR_PULL_ALLOC(ndr, r->cursors05);
11528                                 } else {
11529                                         r->cursors05 = NULL;
11530                                 }
11531                         break; }
11532
11533                         case DRSUAPI_DS_REPLICA_INFO_06: {
11534                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
11535                                 if (_ptr_i06) {
11536                                         NDR_PULL_ALLOC(ndr, r->i06);
11537                                 } else {
11538                                         r->i06 = NULL;
11539                                 }
11540                         break; }
11541
11542                         default:
11543                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11544                 }
11545         }
11546         if (ndr_flags & NDR_BUFFERS) {
11547                 switch (level) {
11548                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11549                                 if (r->neighbours) {
11550                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
11551                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
11552                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11553                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
11554                                 }
11555                         break;
11556
11557                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11558                                 if (r->cursors) {
11559                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
11560                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
11561                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11562                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
11563                                 }
11564                         break;
11565
11566                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11567                                 if (r->objmetadata) {
11568                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
11569                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
11570                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11571                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
11572                                 }
11573                         break;
11574
11575                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11576                                 if (r->connectfailures) {
11577                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
11578                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
11579                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11580                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
11581                                 }
11582                         break;
11583
11584                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11585                                 if (r->linkfailures) {
11586                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
11587                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
11588                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
11589                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
11590                                 }
11591                         break;
11592
11593                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11594                                 if (r->pendingops) {
11595                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
11596                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
11597                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
11598                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
11599                                 }
11600                         break;
11601
11602                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11603                                 if (r->attrvalmetadata) {
11604                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
11605                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
11606                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
11607                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
11608                                 }
11609                         break;
11610
11611                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11612                                 if (r->cursors2) {
11613                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
11614                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
11615                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
11616                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
11617                                 }
11618                         break;
11619
11620                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11621                                 if (r->cursors3) {
11622                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
11623                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
11624                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
11625                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
11626                                 }
11627                         break;
11628
11629                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11630                                 if (r->objmetadata2) {
11631                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
11632                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
11633                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
11634                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
11635                                 }
11636                         break;
11637
11638                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
11639                                 if (r->attrvalmetadata2) {
11640                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
11641                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
11642                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
11643                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
11644                                 }
11645                         break;
11646
11647                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
11648                                 if (r->neighbours02) {
11649                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
11650                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
11651                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
11652                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
11653                                 }
11654                         break;
11655
11656                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
11657                                 if (r->connections04) {
11658                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
11659                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
11660                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
11661                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
11662                                 }
11663                         break;
11664
11665                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
11666                                 if (r->cursors05) {
11667                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
11668                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
11669                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
11670                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
11671                                 }
11672                         break;
11673
11674                         case DRSUAPI_DS_REPLICA_INFO_06:
11675                                 if (r->i06) {
11676                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
11677                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
11678                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
11679                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
11680                                 }
11681                         break;
11682
11683                         default:
11684                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11685                 }
11686         }
11687         return NDR_ERR_SUCCESS;
11688 }
11689
11690 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
11691 {
11692         int level;
11693         level = ndr_print_get_switch_value(ndr, r);
11694         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
11695         switch (level) {
11696                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11697                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
11698                         ndr->depth++;
11699                         if (r->neighbours) {
11700                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
11701                         }
11702                         ndr->depth--;
11703                 break;
11704
11705                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11706                         ndr_print_ptr(ndr, "cursors", r->cursors);
11707                         ndr->depth++;
11708                         if (r->cursors) {
11709                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
11710                         }
11711                         ndr->depth--;
11712                 break;
11713
11714                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11715                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
11716                         ndr->depth++;
11717                         if (r->objmetadata) {
11718                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
11719                         }
11720                         ndr->depth--;
11721                 break;
11722
11723                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11724                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
11725                         ndr->depth++;
11726                         if (r->connectfailures) {
11727                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
11728                         }
11729                         ndr->depth--;
11730                 break;
11731
11732                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11733                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
11734                         ndr->depth++;
11735                         if (r->linkfailures) {
11736                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
11737                         }
11738                         ndr->depth--;
11739                 break;
11740
11741                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11742                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
11743                         ndr->depth++;
11744                         if (r->pendingops) {
11745                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
11746                         }
11747                         ndr->depth--;
11748                 break;
11749
11750                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11751                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
11752                         ndr->depth++;
11753                         if (r->attrvalmetadata) {
11754                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
11755                         }
11756                         ndr->depth--;
11757                 break;
11758
11759                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11760                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
11761                         ndr->depth++;
11762                         if (r->cursors2) {
11763                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
11764                         }
11765                         ndr->depth--;
11766                 break;
11767
11768                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
11769                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
11770                         ndr->depth++;
11771                         if (r->cursors3) {
11772                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
11773                         }
11774                         ndr->depth--;
11775                 break;
11776
11777                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
11778                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
11779                         ndr->depth++;
11780                         if (r->objmetadata2) {
11781                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
11782                         }
11783                         ndr->depth--;
11784                 break;
11785
11786                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
11787                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
11788                         ndr->depth++;
11789                         if (r->attrvalmetadata2) {
11790                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
11791                         }
11792                         ndr->depth--;
11793                 break;
11794
11795                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
11796                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
11797                         ndr->depth++;
11798                         if (r->neighbours02) {
11799                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
11800                         }
11801                         ndr->depth--;
11802                 break;
11803
11804                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
11805                         ndr_print_ptr(ndr, "connections04", r->connections04);
11806                         ndr->depth++;
11807                         if (r->connections04) {
11808                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
11809                         }
11810                         ndr->depth--;
11811                 break;
11812
11813                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
11814                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
11815                         ndr->depth++;
11816                         if (r->cursors05) {
11817                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
11818                         }
11819                         ndr->depth--;
11820                 break;
11821
11822                 case DRSUAPI_DS_REPLICA_INFO_06:
11823                         ndr_print_ptr(ndr, "i06", r->i06);
11824                         ndr->depth++;
11825                         if (r->i06) {
11826                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
11827                         }
11828                         ndr->depth--;
11829                 break;
11830
11831                 default:
11832                         ndr_print_bad_level(ndr, name, level);
11833         }
11834 }
11835
11836 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
11837 {
11838         if (ndr_flags & NDR_SCALARS) {
11839                 int level = ndr_push_get_switch_value(ndr, r);
11840                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
11841                 switch (level) {
11842                         case 1: {
11843                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
11844                         break; }
11845
11846                         default:
11847                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11848                 }
11849         }
11850         if (ndr_flags & NDR_BUFFERS) {
11851                 int level = ndr_push_get_switch_value(ndr, r);
11852                 switch (level) {
11853                         case 1:
11854                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
11855                         break;
11856
11857                         default:
11858                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11859                 }
11860         }
11861         return NDR_ERR_SUCCESS;
11862 }
11863
11864 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
11865 {
11866         int level;
11867         int32_t _level;
11868         level = ndr_pull_get_switch_value(ndr, r);
11869         if (ndr_flags & NDR_SCALARS) {
11870                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
11871                 if (_level != level) {
11872                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11873                 }
11874                 switch (level) {
11875                         case 1: {
11876                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
11877                         break; }
11878
11879                         default:
11880                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11881                 }
11882         }
11883         if (ndr_flags & NDR_BUFFERS) {
11884                 switch (level) {
11885                         case 1:
11886                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
11887                         break;
11888
11889                         default:
11890                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
11891                 }
11892         }
11893         return NDR_ERR_SUCCESS;
11894 }
11895
11896 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
11897 {
11898         int level;
11899         level = ndr_print_get_switch_value(ndr, r);
11900         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
11901         switch (level) {
11902                 case 1:
11903                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
11904                 break;
11905
11906                 default:
11907                         ndr_print_bad_level(ndr, name, level);
11908         }
11909 }
11910
11911 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
11912 {
11913         uint32_t cntr_req_array_1;
11914         if (ndr_flags & NDR_SCALARS) {
11915                 NDR_CHECK(ndr_push_align(ndr, 4));
11916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
11917                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
11918         }
11919         if (ndr_flags & NDR_BUFFERS) {
11920                 if (r->req_array) {
11921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
11922                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
11923                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
11924                         }
11925                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
11926                                 if (r->req_array[cntr_req_array_1]) {
11927                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
11928                                 }
11929                         }
11930                 }
11931         }
11932         return NDR_ERR_SUCCESS;
11933 }
11934
11935 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
11936 {
11937         uint32_t _ptr_req_array;
11938         uint32_t size_req_array_1 = 0;
11939         uint32_t cntr_req_array_1;
11940         TALLOC_CTX *_mem_save_req_array_0;
11941         TALLOC_CTX *_mem_save_req_array_1;
11942         TALLOC_CTX *_mem_save_req_array_2;
11943         if (ndr_flags & NDR_SCALARS) {
11944                 NDR_CHECK(ndr_pull_align(ndr, 4));
11945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
11946                 if (r->num_req < 1 || r->num_req > 10000) {
11947                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11948                 }
11949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
11950                 if (_ptr_req_array) {
11951                         NDR_PULL_ALLOC(ndr, r->req_array);
11952                 } else {
11953                         r->req_array = NULL;
11954                 }
11955         }
11956         if (ndr_flags & NDR_BUFFERS) {
11957                 if (r->req_array) {
11958                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11959                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
11960                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
11961                         size_req_array_1 = ndr_get_array_size(ndr, &r->req_array);
11962                         NDR_PULL_ALLOC_N(ndr, r->req_array, size_req_array_1);
11963                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
11964                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
11965                         for (cntr_req_array_1 = 0; cntr_req_array_1 < size_req_array_1; cntr_req_array_1++) {
11966                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
11967                                 if (_ptr_req_array) {
11968                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
11969                                 } else {
11970                                         r->req_array[cntr_req_array_1] = NULL;
11971                                 }
11972                         }
11973                         for (cntr_req_array_1 = 0; cntr_req_array_1 < size_req_array_1; cntr_req_array_1++) {
11974                                 if (r->req_array[cntr_req_array_1]) {
11975                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
11976                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
11977                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
11978                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
11979                                 }
11980                         }
11981                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
11982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
11983                 }
11984                 if (r->req_array) {
11985                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
11986                 }
11987         }
11988         return NDR_ERR_SUCCESS;
11989 }
11990
11991 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
11992 {
11993         uint32_t cntr_req_array_1;
11994         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
11995         ndr->depth++;
11996         ndr_print_uint32(ndr, "num_req", r->num_req);
11997         ndr_print_ptr(ndr, "req_array", r->req_array);
11998         ndr->depth++;
11999         if (r->req_array) {
12000                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12001                 ndr->depth++;
12002                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12003                         char *idx_1=NULL;
12004                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12005                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12006                                 ndr->depth++;
12007                                 if (r->req_array[cntr_req_array_1]) {
12008                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12009                                 }
12010                                 ndr->depth--;
12011                                 free(idx_1);
12012                         }
12013                 }
12014                 ndr->depth--;
12015         }
12016         ndr->depth--;
12017         ndr->depth--;
12018 }
12019
12020 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12021 {
12022         if (ndr_flags & NDR_SCALARS) {
12023                 int level = ndr_push_get_switch_value(ndr, r);
12024                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12025                 switch (level) {
12026                         case 1: {
12027                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12028                         break; }
12029
12030                         default:
12031                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12032                 }
12033         }
12034         if (ndr_flags & NDR_BUFFERS) {
12035                 int level = ndr_push_get_switch_value(ndr, r);
12036                 switch (level) {
12037                         case 1:
12038                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12039                         break;
12040
12041                         default:
12042                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12043                 }
12044         }
12045         return NDR_ERR_SUCCESS;
12046 }
12047
12048 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12049 {
12050         int level;
12051         int32_t _level;
12052         level = ndr_pull_get_switch_value(ndr, r);
12053         if (ndr_flags & NDR_SCALARS) {
12054                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12055                 if (_level != level) {
12056                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12057                 }
12058                 switch (level) {
12059                         case 1: {
12060                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12061                         break; }
12062
12063                         default:
12064                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12065                 }
12066         }
12067         if (ndr_flags & NDR_BUFFERS) {
12068                 switch (level) {
12069                         case 1:
12070                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12071                         break;
12072
12073                         default:
12074                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12075                 }
12076         }
12077         return NDR_ERR_SUCCESS;
12078 }
12079
12080 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12081 {
12082         int level;
12083         level = ndr_print_get_switch_value(ndr, r);
12084         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12085         switch (level) {
12086                 case 1:
12087                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12088                 break;
12089
12090                 default:
12091                         ndr_print_bad_level(ndr, name, level);
12092         }
12093 }
12094
12095 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12096 {
12097         if (ndr_flags & NDR_SCALARS) {
12098                 NDR_CHECK(ndr_push_align(ndr, 4));
12099                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12101         }
12102         if (ndr_flags & NDR_BUFFERS) {
12103         }
12104         return NDR_ERR_SUCCESS;
12105 }
12106
12107 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12108 {
12109         if (ndr_flags & NDR_SCALARS) {
12110                 NDR_CHECK(ndr_pull_align(ndr, 4));
12111                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12113         }
12114         if (ndr_flags & NDR_BUFFERS) {
12115         }
12116         return NDR_ERR_SUCCESS;
12117 }
12118
12119 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12120 {
12121         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12122         ndr->depth++;
12123         ndr_print_WERROR(ndr, "error_code", r->error_code);
12124         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12125         ndr->depth--;
12126 }
12127
12128 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12129 {
12130         uint32_t cntr_info_1;
12131         if (ndr_flags & NDR_SCALARS) {
12132                 NDR_CHECK(ndr_push_align(ndr, 4));
12133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12134                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12136         }
12137         if (ndr_flags & NDR_BUFFERS) {
12138                 if (r->info) {
12139                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12140                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12141                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12142                         }
12143                 }
12144         }
12145         return NDR_ERR_SUCCESS;
12146 }
12147
12148 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12149 {
12150         uint32_t _ptr_info;
12151         uint32_t size_info_1 = 0;
12152         uint32_t cntr_info_1;
12153         TALLOC_CTX *_mem_save_info_0;
12154         TALLOC_CTX *_mem_save_info_1;
12155         if (ndr_flags & NDR_SCALARS) {
12156                 NDR_CHECK(ndr_pull_align(ndr, 4));
12157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12158                 if (r->num_info > 10000) {
12159                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12160                 }
12161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12162                 if (_ptr_info) {
12163                         NDR_PULL_ALLOC(ndr, r->info);
12164                 } else {
12165                         r->info = NULL;
12166                 }
12167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12168         }
12169         if (ndr_flags & NDR_BUFFERS) {
12170                 if (r->info) {
12171                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12172                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12174                         size_info_1 = ndr_get_array_size(ndr, &r->info);
12175                         NDR_PULL_ALLOC_N(ndr, r->info, size_info_1);
12176                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12177                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12178                         for (cntr_info_1 = 0; cntr_info_1 < size_info_1; cntr_info_1++) {
12179                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12180                         }
12181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12183                 }
12184                 if (r->info) {
12185                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12186                 }
12187         }
12188         return NDR_ERR_SUCCESS;
12189 }
12190
12191 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12192 {
12193         uint32_t cntr_info_1;
12194         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12195         ndr->depth++;
12196         ndr_print_uint32(ndr, "num_info", r->num_info);
12197         ndr_print_ptr(ndr, "info", r->info);
12198         ndr->depth++;
12199         if (r->info) {
12200                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12201                 ndr->depth++;
12202                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12203                         char *idx_1=NULL;
12204                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12205                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12206                                 free(idx_1);
12207                         }
12208                 }
12209                 ndr->depth--;
12210         }
12211         ndr->depth--;
12212         ndr_print_uint32(ndr, "unknown", r->unknown);
12213         ndr->depth--;
12214 }
12215
12216 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12217 {
12218         if (ndr_flags & NDR_SCALARS) {
12219                 int level = ndr_push_get_switch_value(ndr, r);
12220                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12221                 switch (level) {
12222                         case 1: {
12223                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12224                         break; }
12225
12226                         default:
12227                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12228                 }
12229         }
12230         if (ndr_flags & NDR_BUFFERS) {
12231                 int level = ndr_push_get_switch_value(ndr, r);
12232                 switch (level) {
12233                         case 1:
12234                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12235                         break;
12236
12237                         default:
12238                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12239                 }
12240         }
12241         return NDR_ERR_SUCCESS;
12242 }
12243
12244 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12245 {
12246         int level;
12247         int32_t _level;
12248         level = ndr_pull_get_switch_value(ndr, r);
12249         if (ndr_flags & NDR_SCALARS) {
12250                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12251                 if (_level != level) {
12252                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12253                 }
12254                 switch (level) {
12255                         case 1: {
12256                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12257                         break; }
12258
12259                         default:
12260                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12261                 }
12262         }
12263         if (ndr_flags & NDR_BUFFERS) {
12264                 switch (level) {
12265                         case 1:
12266                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12267                         break;
12268
12269                         default:
12270                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12271                 }
12272         }
12273         return NDR_ERR_SUCCESS;
12274 }
12275
12276 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
12277 {
12278         int level;
12279         level = ndr_print_get_switch_value(ndr, r);
12280         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
12281         switch (level) {
12282                 case 1:
12283                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
12284                 break;
12285
12286                 default:
12287                         ndr_print_bad_level(ndr, name, level);
12288         }
12289 }
12290
12291 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
12292 {
12293         uint32_t cntr_site_to_1;
12294         if (ndr_flags & NDR_SCALARS) {
12295                 NDR_CHECK(ndr_push_align(ndr, 4));
12296                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
12297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12298                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
12299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
12300         }
12301         if (ndr_flags & NDR_BUFFERS) {
12302                 if (r->site_from) {
12303                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12304                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12306                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12307                 }
12308                 if (r->site_to) {
12309                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12310                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12311                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
12312                         }
12313                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
12314                                 if (r->site_to[cntr_site_to_1]) {
12315                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12316                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12317                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
12318                                         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));
12319                                 }
12320                         }
12321                 }
12322         }
12323         return NDR_ERR_SUCCESS;
12324 }
12325
12326 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
12327 {
12328         uint32_t _ptr_site_from;
12329         uint32_t size_site_from_1 = 0;
12330         uint32_t length_site_from_1 = 0;
12331         TALLOC_CTX *_mem_save_site_from_0;
12332         uint32_t _ptr_site_to;
12333         uint32_t size_site_to_1 = 0;
12334         uint32_t cntr_site_to_1;
12335         uint32_t size_site_to_3 = 0;
12336         uint32_t length_site_to_3 = 0;
12337         TALLOC_CTX *_mem_save_site_to_0;
12338         TALLOC_CTX *_mem_save_site_to_1;
12339         TALLOC_CTX *_mem_save_site_to_2;
12340         if (ndr_flags & NDR_SCALARS) {
12341                 NDR_CHECK(ndr_pull_align(ndr, 4));
12342                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
12343                 if (_ptr_site_from) {
12344                         NDR_PULL_ALLOC(ndr, r->site_from);
12345                 } else {
12346                         r->site_from = NULL;
12347                 }
12348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12349                 if (r->num_req < 1 || r->num_req > 10000) {
12350                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12351                 }
12352                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
12353                 if (_ptr_site_to) {
12354                         NDR_PULL_ALLOC(ndr, r->site_to);
12355                 } else {
12356                         r->site_to = NULL;
12357                 }
12358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
12359         }
12360         if (ndr_flags & NDR_BUFFERS) {
12361                 if (r->site_from) {
12362                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
12363                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
12364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
12365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
12366                         size_site_from_1 = ndr_get_array_size(ndr, &r->site_from);
12367                         length_site_from_1 = ndr_get_array_length(ndr, &r->site_from);
12368                         if (length_site_from_1 > size_site_from_1) {
12369                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_from_1, length_site_from_1);
12370                         }
12371                         NDR_CHECK(ndr_check_string_terminator(ndr, length_site_from_1, sizeof(uint16_t)));
12372                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, length_site_from_1, sizeof(uint16_t), CH_UTF16));
12373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
12374                 }
12375                 if (r->site_to) {
12376                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
12377                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
12378                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
12379                         size_site_to_1 = ndr_get_array_size(ndr, &r->site_to);
12380                         NDR_PULL_ALLOC_N(ndr, r->site_to, size_site_to_1);
12381                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
12382                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
12383                         for (cntr_site_to_1 = 0; cntr_site_to_1 < size_site_to_1; cntr_site_to_1++) {
12384                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
12385                                 if (_ptr_site_to) {
12386                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
12387                                 } else {
12388                                         r->site_to[cntr_site_to_1] = NULL;
12389                                 }
12390                         }
12391                         for (cntr_site_to_1 = 0; cntr_site_to_1 < size_site_to_1; cntr_site_to_1++) {
12392                                 if (r->site_to[cntr_site_to_1]) {
12393                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
12394                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
12395                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
12396                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
12397                                         size_site_to_3 = ndr_get_array_size(ndr, &r->site_to[cntr_site_to_1]);
12398                                         length_site_to_3 = ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]);
12399                                         if (length_site_to_3 > size_site_to_3) {
12400                                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_to_3, length_site_to_3);
12401                                         }
12402                                         NDR_CHECK(ndr_check_string_terminator(ndr, length_site_to_3, sizeof(uint16_t)));
12403                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_to[cntr_site_to_1], length_site_to_3, sizeof(uint16_t), CH_UTF16));
12404                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
12405                                 }
12406                         }
12407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
12408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
12409                 }
12410                 if (r->site_to) {
12411                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
12412                 }
12413         }
12414         return NDR_ERR_SUCCESS;
12415 }
12416
12417 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
12418 {
12419         uint32_t cntr_site_to_1;
12420         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
12421         ndr->depth++;
12422         ndr_print_ptr(ndr, "site_from", r->site_from);
12423         ndr->depth++;
12424         if (r->site_from) {
12425                 ndr_print_string(ndr, "site_from", r->site_from);
12426         }
12427         ndr->depth--;
12428         ndr_print_uint32(ndr, "num_req", r->num_req);
12429         ndr_print_ptr(ndr, "site_to", r->site_to);
12430         ndr->depth++;
12431         if (r->site_to) {
12432                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
12433                 ndr->depth++;
12434                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
12435                         char *idx_1=NULL;
12436                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
12437                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
12438                                 ndr->depth++;
12439                                 if (r->site_to[cntr_site_to_1]) {
12440                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
12441                                 }
12442                                 ndr->depth--;
12443                                 free(idx_1);
12444                         }
12445                 }
12446                 ndr->depth--;
12447         }
12448         ndr->depth--;
12449         ndr_print_uint32(ndr, "flags", r->flags);
12450         ndr->depth--;
12451 }
12452
12453 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
12454 {
12455         if (ndr_flags & NDR_SCALARS) {
12456                 int level = ndr_push_get_switch_value(ndr, r);
12457                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12458                 switch (level) {
12459                         case 1: {
12460                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
12461                         break; }
12462
12463                         default:
12464                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12465                 }
12466         }
12467         if (ndr_flags & NDR_BUFFERS) {
12468                 int level = ndr_push_get_switch_value(ndr, r);
12469                 switch (level) {
12470                         case 1:
12471                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
12472                         break;
12473
12474                         default:
12475                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12476                 }
12477         }
12478         return NDR_ERR_SUCCESS;
12479 }
12480
12481 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
12482 {
12483         int level;
12484         int32_t _level;
12485         level = ndr_pull_get_switch_value(ndr, r);
12486         if (ndr_flags & NDR_SCALARS) {
12487                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12488                 if (_level != level) {
12489                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12490                 }
12491                 switch (level) {
12492                         case 1: {
12493                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
12494                         break; }
12495
12496                         default:
12497                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12498                 }
12499         }
12500         if (ndr_flags & NDR_BUFFERS) {
12501                 switch (level) {
12502                         case 1:
12503                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
12504                         break;
12505
12506                         default:
12507                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12508                 }
12509         }
12510         return NDR_ERR_SUCCESS;
12511 }
12512
12513 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
12514 {
12515         int level;
12516         level = ndr_print_get_switch_value(ndr, r);
12517         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
12518         switch (level) {
12519                 case 1:
12520                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
12521                 break;
12522
12523                 default:
12524                         ndr_print_bad_level(ndr, name, level);
12525         }
12526 }
12527
12528 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
12529 {
12530         if (flags & NDR_IN) {
12531                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
12532                 if (r->in.bind_guid) {
12533                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
12534                 }
12535                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
12536                 if (r->in.bind_info) {
12537                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
12538                 }
12539         }
12540         if (flags & NDR_OUT) {
12541                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
12542                 if (r->out.bind_info) {
12543                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
12544                 }
12545                 if (r->out.bind_handle == NULL) {
12546                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12547                 }
12548                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12549                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12550         }
12551         return NDR_ERR_SUCCESS;
12552 }
12553
12554 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
12555 {
12556         uint32_t _ptr_bind_guid;
12557         uint32_t _ptr_bind_info;
12558         TALLOC_CTX *_mem_save_bind_guid_0;
12559         TALLOC_CTX *_mem_save_bind_info_0;
12560         TALLOC_CTX *_mem_save_bind_handle_0;
12561         if (flags & NDR_IN) {
12562                 ZERO_STRUCT(r->out);
12563
12564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
12565                 if (_ptr_bind_guid) {
12566                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
12567                 } else {
12568                         r->in.bind_guid = NULL;
12569                 }
12570                 if (r->in.bind_guid) {
12571                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
12572                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
12573                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
12574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
12575                 }
12576                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
12577                 if (_ptr_bind_info) {
12578                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
12579                 } else {
12580                         r->in.bind_info = NULL;
12581                 }
12582                 if (r->in.bind_info) {
12583                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12584                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
12585                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
12586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
12587                 }
12588                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12589                 ZERO_STRUCTP(r->out.bind_handle);
12590         }
12591         if (flags & NDR_OUT) {
12592                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
12593                 if (_ptr_bind_info) {
12594                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
12595                 } else {
12596                         r->out.bind_info = NULL;
12597                 }
12598                 if (r->out.bind_info) {
12599                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12600                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
12601                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
12602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
12603                 }
12604                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12605                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12606                 }
12607                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12608                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12609                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12610                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12611                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12612         }
12613         return NDR_ERR_SUCCESS;
12614 }
12615
12616 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
12617 {
12618         ndr_print_struct(ndr, name, "drsuapi_DsBind");
12619         ndr->depth++;
12620         if (flags & NDR_SET_VALUES) {
12621                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12622         }
12623         if (flags & NDR_IN) {
12624                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
12625                 ndr->depth++;
12626                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
12627                 ndr->depth++;
12628                 if (r->in.bind_guid) {
12629                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
12630                 }
12631                 ndr->depth--;
12632                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
12633                 ndr->depth++;
12634                 if (r->in.bind_info) {
12635                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
12636                 }
12637                 ndr->depth--;
12638                 ndr->depth--;
12639         }
12640         if (flags & NDR_OUT) {
12641                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
12642                 ndr->depth++;
12643                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
12644                 ndr->depth++;
12645                 if (r->out.bind_info) {
12646                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
12647                 }
12648                 ndr->depth--;
12649                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
12650                 ndr->depth++;
12651                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
12652                 ndr->depth--;
12653                 ndr_print_WERROR(ndr, "result", r->out.result);
12654                 ndr->depth--;
12655         }
12656         ndr->depth--;
12657 }
12658
12659 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
12660 {
12661         if (flags & NDR_IN) {
12662                 if (r->in.bind_handle == NULL) {
12663                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12664                 }
12665                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12666         }
12667         if (flags & NDR_OUT) {
12668                 if (r->out.bind_handle == NULL) {
12669                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12670                 }
12671                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12672                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12673         }
12674         return NDR_ERR_SUCCESS;
12675 }
12676
12677 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
12678 {
12679         TALLOC_CTX *_mem_save_bind_handle_0;
12680         if (flags & NDR_IN) {
12681                 ZERO_STRUCT(r->out);
12682
12683                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12684                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
12685                 }
12686                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12687                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12688                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12689                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12690                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12691                 *r->out.bind_handle = *r->in.bind_handle;
12692         }
12693         if (flags & NDR_OUT) {
12694                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12695                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
12696                 }
12697                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12698                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12699                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
12700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12701                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12702         }
12703         return NDR_ERR_SUCCESS;
12704 }
12705
12706 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
12707 {
12708         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
12709         ndr->depth++;
12710         if (flags & NDR_SET_VALUES) {
12711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12712         }
12713         if (flags & NDR_IN) {
12714                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
12715                 ndr->depth++;
12716                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
12717                 ndr->depth++;
12718                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
12719                 ndr->depth--;
12720                 ndr->depth--;
12721         }
12722         if (flags & NDR_OUT) {
12723                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
12724                 ndr->depth++;
12725                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
12726                 ndr->depth++;
12727                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
12728                 ndr->depth--;
12729                 ndr_print_WERROR(ndr, "result", r->out.result);
12730                 ndr->depth--;
12731         }
12732         ndr->depth--;
12733 }
12734
12735 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
12736 {
12737         if (flags & NDR_IN) {
12738                 if (r->in.bind_handle == NULL) {
12739                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12740                 }
12741                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12742                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
12743                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
12744                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
12745         }
12746         if (flags & NDR_OUT) {
12747                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12748         }
12749         return NDR_ERR_SUCCESS;
12750 }
12751
12752 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
12753 {
12754         TALLOC_CTX *_mem_save_bind_handle_0;
12755         if (flags & NDR_IN) {
12756                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12757                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
12758                 }
12759                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12760                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12761                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12762                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12763                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
12764                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
12765                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
12766         }
12767         if (flags & NDR_OUT) {
12768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12769         }
12770         return NDR_ERR_SUCCESS;
12771 }
12772
12773 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
12774 {
12775         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
12776         ndr->depth++;
12777         if (flags & NDR_SET_VALUES) {
12778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12779         }
12780         if (flags & NDR_IN) {
12781                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
12782                 ndr->depth++;
12783                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
12784                 ndr->depth++;
12785                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
12786                 ndr->depth--;
12787                 ndr_print_int32(ndr, "level", r->in.level);
12788                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
12789                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
12790                 ndr->depth--;
12791         }
12792         if (flags & NDR_OUT) {
12793                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
12794                 ndr->depth++;
12795                 ndr_print_WERROR(ndr, "result", r->out.result);
12796                 ndr->depth--;
12797         }
12798         ndr->depth--;
12799 }
12800
12801 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
12802 {
12803         if (flags & NDR_IN) {
12804                 if (r->in.bind_handle == NULL) {
12805                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12806                 }
12807                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12808                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
12809                 if (r->in.req == NULL) {
12810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12811                 }
12812                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
12813                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12814         }
12815         if (flags & NDR_OUT) {
12816                 if (r->out.level_out == NULL) {
12817                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12818                 }
12819                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
12820                 if (r->out.ctr == NULL) {
12821                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12822                 }
12823                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
12824                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
12825                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12826         }
12827         return NDR_ERR_SUCCESS;
12828 }
12829
12830 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
12831 {
12832         TALLOC_CTX *_mem_save_bind_handle_0;
12833         TALLOC_CTX *_mem_save_req_0;
12834         TALLOC_CTX *_mem_save_level_out_0;
12835         TALLOC_CTX *_mem_save_ctr_0;
12836         if (flags & NDR_IN) {
12837                 ZERO_STRUCT(r->out);
12838
12839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12840                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
12841                 }
12842                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12843                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12844                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12846                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
12847                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12848                         NDR_PULL_ALLOC(ndr, r->in.req);
12849                 }
12850                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
12851                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
12852                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
12853                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
12854                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
12855                 NDR_PULL_ALLOC(ndr, r->out.level_out);
12856                 ZERO_STRUCTP(r->out.level_out);
12857                 NDR_PULL_ALLOC(ndr, r->out.ctr);
12858                 ZERO_STRUCTP(r->out.ctr);
12859         }
12860         if (flags & NDR_OUT) {
12861                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12862                         NDR_PULL_ALLOC(ndr, r->out.level_out);
12863                 }
12864                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
12865                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
12866                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
12867                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
12868                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12869                         NDR_PULL_ALLOC(ndr, r->out.ctr);
12870                 }
12871                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12872                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
12873                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
12874                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
12875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
12876                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12877         }
12878         return NDR_ERR_SUCCESS;
12879 }
12880
12881 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
12882 {
12883         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
12884         ndr->depth++;
12885         if (flags & NDR_SET_VALUES) {
12886                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12887         }
12888         if (flags & NDR_IN) {
12889                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
12890                 ndr->depth++;
12891                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
12892                 ndr->depth++;
12893                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
12894                 ndr->depth--;
12895                 ndr_print_int32(ndr, "level", r->in.level);
12896                 ndr_print_ptr(ndr, "req", r->in.req);
12897                 ndr->depth++;
12898                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
12899                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
12900                 ndr->depth--;
12901                 ndr->depth--;
12902         }
12903         if (flags & NDR_OUT) {
12904                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
12905                 ndr->depth++;
12906                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
12907                 ndr->depth++;
12908                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
12909                 ndr->depth--;
12910                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
12911                 ndr->depth++;
12912                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
12913                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
12914                 ndr->depth--;
12915                 ndr_print_WERROR(ndr, "result", r->out.result);
12916                 ndr->depth--;
12917         }
12918         ndr->depth--;
12919 }
12920
12921 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
12922 {
12923         if (flags & NDR_IN) {
12924                 if (r->in.bind_handle == NULL) {
12925                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12926                 }
12927                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12928                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
12929                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
12930                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
12931         }
12932         if (flags & NDR_OUT) {
12933                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12934         }
12935         return NDR_ERR_SUCCESS;
12936 }
12937
12938 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
12939 {
12940         TALLOC_CTX *_mem_save_bind_handle_0;
12941         if (flags & NDR_IN) {
12942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12943                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
12944                 }
12945                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12946                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
12947                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
12948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
12949                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
12950                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
12951                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
12952         }
12953         if (flags & NDR_OUT) {
12954                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12955         }
12956         return NDR_ERR_SUCCESS;
12957 }
12958
12959 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
12960 {
12961         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
12962         ndr->depth++;
12963         if (flags & NDR_SET_VALUES) {
12964                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12965         }
12966         if (flags & NDR_IN) {
12967                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
12968                 ndr->depth++;
12969                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
12970                 ndr->depth++;
12971                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
12972                 ndr->depth--;
12973                 ndr_print_int32(ndr, "level", r->in.level);
12974                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
12975                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
12976                 ndr->depth--;
12977         }
12978         if (flags & NDR_OUT) {
12979                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
12980                 ndr->depth++;
12981                 ndr_print_WERROR(ndr, "result", r->out.result);
12982                 ndr->depth--;
12983         }
12984         ndr->depth--;
12985 }
12986
12987 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_ADD(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_ADD *r)
12988 {
12989         if (flags & NDR_IN) {
12990         }
12991         if (flags & NDR_OUT) {
12992                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12993         }
12994         return NDR_ERR_SUCCESS;
12995 }
12996
12997 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_ADD(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_ADD *r)
12998 {
12999         if (flags & NDR_IN) {
13000         }
13001         if (flags & NDR_OUT) {
13002                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13003         }
13004         return NDR_ERR_SUCCESS;
13005 }
13006
13007 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_ADD(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_ADD *r)
13008 {
13009         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_ADD");
13010         ndr->depth++;
13011         if (flags & NDR_SET_VALUES) {
13012                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13013         }
13014         if (flags & NDR_IN) {
13015                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_ADD");
13016                 ndr->depth++;
13017                 ndr->depth--;
13018         }
13019         if (flags & NDR_OUT) {
13020                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_ADD");
13021                 ndr->depth++;
13022                 ndr_print_WERROR(ndr, "result", r->out.result);
13023                 ndr->depth--;
13024         }
13025         ndr->depth--;
13026 }
13027
13028 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_DEL(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_DEL *r)
13029 {
13030         if (flags & NDR_IN) {
13031         }
13032         if (flags & NDR_OUT) {
13033                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13034         }
13035         return NDR_ERR_SUCCESS;
13036 }
13037
13038 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_DEL(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_DEL *r)
13039 {
13040         if (flags & NDR_IN) {
13041         }
13042         if (flags & NDR_OUT) {
13043                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13044         }
13045         return NDR_ERR_SUCCESS;
13046 }
13047
13048 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_DEL(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_DEL *r)
13049 {
13050         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_DEL");
13051         ndr->depth++;
13052         if (flags & NDR_SET_VALUES) {
13053                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13054         }
13055         if (flags & NDR_IN) {
13056                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_DEL");
13057                 ndr->depth++;
13058                 ndr->depth--;
13059         }
13060         if (flags & NDR_OUT) {
13061                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_DEL");
13062                 ndr->depth++;
13063                 ndr_print_WERROR(ndr, "result", r->out.result);
13064                 ndr->depth--;
13065         }
13066         ndr->depth--;
13067 }
13068
13069 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_MODIFY(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_MODIFY *r)
13070 {
13071         if (flags & NDR_IN) {
13072         }
13073         if (flags & NDR_OUT) {
13074                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13075         }
13076         return NDR_ERR_SUCCESS;
13077 }
13078
13079 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_MODIFY(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_MODIFY *r)
13080 {
13081         if (flags & NDR_IN) {
13082         }
13083         if (flags & NDR_OUT) {
13084                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13085         }
13086         return NDR_ERR_SUCCESS;
13087 }
13088
13089 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_MODIFY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_MODIFY *r)
13090 {
13091         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_MODIFY");
13092         ndr->depth++;
13093         if (flags & NDR_SET_VALUES) {
13094                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13095         }
13096         if (flags & NDR_IN) {
13097                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_MODIFY");
13098                 ndr->depth++;
13099                 ndr->depth--;
13100         }
13101         if (flags & NDR_OUT) {
13102                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_MODIFY");
13103                 ndr->depth++;
13104                 ndr_print_WERROR(ndr, "result", r->out.result);
13105                 ndr->depth--;
13106         }
13107         ndr->depth--;
13108 }
13109
13110 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13111 {
13112         if (flags & NDR_IN) {
13113         }
13114         if (flags & NDR_OUT) {
13115                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13116         }
13117         return NDR_ERR_SUCCESS;
13118 }
13119
13120 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13121 {
13122         if (flags & NDR_IN) {
13123         }
13124         if (flags & NDR_OUT) {
13125                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13126         }
13127         return NDR_ERR_SUCCESS;
13128 }
13129
13130 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13131 {
13132         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13133         ndr->depth++;
13134         if (flags & NDR_SET_VALUES) {
13135                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13136         }
13137         if (flags & NDR_IN) {
13138                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13139                 ndr->depth++;
13140                 ndr->depth--;
13141         }
13142         if (flags & NDR_OUT) {
13143                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13144                 ndr->depth++;
13145                 ndr_print_WERROR(ndr, "result", r->out.result);
13146                 ndr->depth--;
13147         }
13148         ndr->depth--;
13149 }
13150
13151 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13152 {
13153         if (flags & NDR_IN) {
13154                 if (r->in.bind_handle == NULL) {
13155                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13156                 }
13157                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13158                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13159                 if (r->in.req == NULL) {
13160                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13161                 }
13162                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13163                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13164         }
13165         if (flags & NDR_OUT) {
13166                 if (r->out.level_out == NULL) {
13167                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13168                 }
13169                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13170                 if (r->out.ctr == NULL) {
13171                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13172                 }
13173                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13174                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13175                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13176         }
13177         return NDR_ERR_SUCCESS;
13178 }
13179
13180 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13181 {
13182         TALLOC_CTX *_mem_save_bind_handle_0;
13183         TALLOC_CTX *_mem_save_req_0;
13184         TALLOC_CTX *_mem_save_level_out_0;
13185         TALLOC_CTX *_mem_save_ctr_0;
13186         if (flags & NDR_IN) {
13187                 ZERO_STRUCT(r->out);
13188
13189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13190                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13191                 }
13192                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13193                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13194                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13196                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13198                         NDR_PULL_ALLOC(ndr, r->in.req);
13199                 }
13200                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13201                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13202                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13203                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13205                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13206                 ZERO_STRUCTP(r->out.level_out);
13207                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13208                 ZERO_STRUCTP(r->out.ctr);
13209         }
13210         if (flags & NDR_OUT) {
13211                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13212                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13213                 }
13214                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13215                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13216                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13217                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13218                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13219                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13220                 }
13221                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13222                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13223                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13224                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13226                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13227         }
13228         return NDR_ERR_SUCCESS;
13229 }
13230
13231 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
13232 {
13233         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
13234         ndr->depth++;
13235         if (flags & NDR_SET_VALUES) {
13236                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13237         }
13238         if (flags & NDR_IN) {
13239                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
13240                 ndr->depth++;
13241                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13242                 ndr->depth++;
13243                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13244                 ndr->depth--;
13245                 ndr_print_int32(ndr, "level", r->in.level);
13246                 ndr_print_ptr(ndr, "req", r->in.req);
13247                 ndr->depth++;
13248                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13249                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
13250                 ndr->depth--;
13251                 ndr->depth--;
13252         }
13253         if (flags & NDR_OUT) {
13254                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
13255                 ndr->depth++;
13256                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13257                 ndr->depth++;
13258                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13259                 ndr->depth--;
13260                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13261                 ndr->depth++;
13262                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13263                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
13264                 ndr->depth--;
13265                 ndr_print_WERROR(ndr, "result", r->out.result);
13266                 ndr->depth--;
13267         }
13268         ndr->depth--;
13269 }
13270
13271 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13272 {
13273         if (flags & NDR_IN) {
13274         }
13275         if (flags & NDR_OUT) {
13276                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13277         }
13278         return NDR_ERR_SUCCESS;
13279 }
13280
13281 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13282 {
13283         if (flags & NDR_IN) {
13284         }
13285         if (flags & NDR_OUT) {
13286                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13287         }
13288         return NDR_ERR_SUCCESS;
13289 }
13290
13291 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
13292 {
13293         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
13294         ndr->depth++;
13295         if (flags & NDR_SET_VALUES) {
13296                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13297         }
13298         if (flags & NDR_IN) {
13299                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
13300                 ndr->depth++;
13301                 ndr->depth--;
13302         }
13303         if (flags & NDR_OUT) {
13304                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
13305                 ndr->depth++;
13306                 ndr_print_WERROR(ndr, "result", r->out.result);
13307                 ndr->depth--;
13308         }
13309         ndr->depth--;
13310 }
13311
13312 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
13313 {
13314         if (flags & NDR_IN) {
13315                 if (r->in.bind_handle == NULL) {
13316                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13317                 }
13318                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13320                 if (r->in.req == NULL) {
13321                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13322                 }
13323                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13324                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13325         }
13326         if (flags & NDR_OUT) {
13327                 if (r->out.level_out == NULL) {
13328                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13329                 }
13330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
13331                 if (r->out.info == NULL) {
13332                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13333                 }
13334                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
13335                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13336                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13337         }
13338         return NDR_ERR_SUCCESS;
13339 }
13340
13341 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
13342 {
13343         TALLOC_CTX *_mem_save_bind_handle_0;
13344         TALLOC_CTX *_mem_save_req_0;
13345         TALLOC_CTX *_mem_save_level_out_0;
13346         TALLOC_CTX *_mem_save_info_0;
13347         if (flags & NDR_IN) {
13348                 ZERO_STRUCT(r->out);
13349
13350                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13351                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13352                 }
13353                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13354                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13355                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13356                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13358                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13359                         NDR_PULL_ALLOC(ndr, r->in.req);
13360                 }
13361                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13362                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13363                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13364                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13365                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13366                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13367                 ZERO_STRUCTP(r->out.level_out);
13368                 NDR_PULL_ALLOC(ndr, r->out.info);
13369                 ZERO_STRUCTP(r->out.info);
13370         }
13371         if (flags & NDR_OUT) {
13372                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13373                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13374                 }
13375                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13376                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
13378                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13379                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13380                         NDR_PULL_ALLOC(ndr, r->out.info);
13381                 }
13382                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13383                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
13384                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
13385                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
13386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
13387                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13388         }
13389         return NDR_ERR_SUCCESS;
13390 }
13391
13392 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
13393 {
13394         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
13395         ndr->depth++;
13396         if (flags & NDR_SET_VALUES) {
13397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13398         }
13399         if (flags & NDR_IN) {
13400                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
13401                 ndr->depth++;
13402                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13403                 ndr->depth++;
13404                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13405                 ndr->depth--;
13406                 ndr_print_uint32(ndr, "level", r->in.level);
13407                 ndr_print_ptr(ndr, "req", r->in.req);
13408                 ndr->depth++;
13409                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13410                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
13411                 ndr->depth--;
13412                 ndr->depth--;
13413         }
13414         if (flags & NDR_OUT) {
13415                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
13416                 ndr->depth++;
13417                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13418                 ndr->depth++;
13419                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
13420                 ndr->depth--;
13421                 ndr_print_ptr(ndr, "info", r->out.info);
13422                 ndr->depth++;
13423                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
13424                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
13425                 ndr->depth--;
13426                 ndr_print_WERROR(ndr, "result", r->out.result);
13427                 ndr->depth--;
13428         }
13429         ndr->depth--;
13430 }
13431
13432 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
13433 {
13434         if (flags & NDR_IN) {
13435                 if (r->in.bind_handle == NULL) {
13436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13437                 }
13438                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13439                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13440                 if (r->in.req == NULL) {
13441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13442                 }
13443                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13444                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13445         }
13446         if (flags & NDR_OUT) {
13447                 if (r->out.level_out == NULL) {
13448                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13449                 }
13450                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13451                 if (r->out.ctr == NULL) {
13452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13453                 }
13454                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13455                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13456                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13457         }
13458         return NDR_ERR_SUCCESS;
13459 }
13460
13461 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
13462 {
13463         TALLOC_CTX *_mem_save_bind_handle_0;
13464         TALLOC_CTX *_mem_save_req_0;
13465         TALLOC_CTX *_mem_save_level_out_0;
13466         TALLOC_CTX *_mem_save_ctr_0;
13467         if (flags & NDR_IN) {
13468                 ZERO_STRUCT(r->out);
13469
13470                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13471                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13472                 }
13473                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13474                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13475                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13477                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13479                         NDR_PULL_ALLOC(ndr, r->in.req);
13480                 }
13481                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13482                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13483                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13484                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13486                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13487                 ZERO_STRUCTP(r->out.level_out);
13488                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13489                 ZERO_STRUCTP(r->out.ctr);
13490         }
13491         if (flags & NDR_OUT) {
13492                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13493                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13494                 }
13495                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13496                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13497                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13498                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13499                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13500                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13501                 }
13502                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13503                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13504                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13505                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13507                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13508         }
13509         return NDR_ERR_SUCCESS;
13510 }
13511
13512 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
13513 {
13514         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
13515         ndr->depth++;
13516         if (flags & NDR_SET_VALUES) {
13517                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13518         }
13519         if (flags & NDR_IN) {
13520                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
13521                 ndr->depth++;
13522                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13523                 ndr->depth++;
13524                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13525                 ndr->depth--;
13526                 ndr_print_int32(ndr, "level", r->in.level);
13527                 ndr_print_ptr(ndr, "req", r->in.req);
13528                 ndr->depth++;
13529                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13530                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
13531                 ndr->depth--;
13532                 ndr->depth--;
13533         }
13534         if (flags & NDR_OUT) {
13535                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
13536                 ndr->depth++;
13537                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13538                 ndr->depth++;
13539                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13540                 ndr->depth--;
13541                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13542                 ndr->depth++;
13543                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13544                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
13545                 ndr->depth--;
13546                 ndr_print_WERROR(ndr, "result", r->out.result);
13547                 ndr->depth--;
13548         }
13549         ndr->depth--;
13550 }
13551
13552 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
13553 {
13554         if (flags & NDR_IN) {
13555                 if (r->in.bind_handle == NULL) {
13556                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13557                 }
13558                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13559                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13560                 if (r->in.req == NULL) {
13561                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13562                 }
13563                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13564                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13565         }
13566         if (flags & NDR_OUT) {
13567                 if (r->out.level_out == NULL) {
13568                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13569                 }
13570                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13571                 if (r->out.res == NULL) {
13572                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13573                 }
13574                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
13575                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
13576                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13577         }
13578         return NDR_ERR_SUCCESS;
13579 }
13580
13581 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
13582 {
13583         TALLOC_CTX *_mem_save_bind_handle_0;
13584         TALLOC_CTX *_mem_save_req_0;
13585         TALLOC_CTX *_mem_save_level_out_0;
13586         TALLOC_CTX *_mem_save_res_0;
13587         if (flags & NDR_IN) {
13588                 ZERO_STRUCT(r->out);
13589
13590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13591                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13592                 }
13593                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13594                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13595                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13597                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13598                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13599                         NDR_PULL_ALLOC(ndr, r->in.req);
13600                 }
13601                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13602                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13603                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13604                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13606                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13607                 ZERO_STRUCTP(r->out.level_out);
13608                 NDR_PULL_ALLOC(ndr, r->out.res);
13609                 ZERO_STRUCTP(r->out.res);
13610         }
13611         if (flags & NDR_OUT) {
13612                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13613                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13614                 }
13615                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13616                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13617                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13619                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13620                         NDR_PULL_ALLOC(ndr, r->out.res);
13621                 }
13622                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
13623                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
13624                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
13625                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
13626                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
13627                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13628         }
13629         return NDR_ERR_SUCCESS;
13630 }
13631
13632 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
13633 {
13634         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
13635         ndr->depth++;
13636         if (flags & NDR_SET_VALUES) {
13637                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13638         }
13639         if (flags & NDR_IN) {
13640                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
13641                 ndr->depth++;
13642                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13643                 ndr->depth++;
13644                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13645                 ndr->depth--;
13646                 ndr_print_int32(ndr, "level", r->in.level);
13647                 ndr_print_ptr(ndr, "req", r->in.req);
13648                 ndr->depth++;
13649                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13650                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
13651                 ndr->depth--;
13652                 ndr->depth--;
13653         }
13654         if (flags & NDR_OUT) {
13655                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
13656                 ndr->depth++;
13657                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13658                 ndr->depth++;
13659                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13660                 ndr->depth--;
13661                 ndr_print_ptr(ndr, "res", r->out.res);
13662                 ndr->depth++;
13663                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
13664                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
13665                 ndr->depth--;
13666                 ndr_print_WERROR(ndr, "result", r->out.result);
13667                 ndr->depth--;
13668         }
13669         ndr->depth--;
13670 }
13671
13672 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
13673 {
13674         if (flags & NDR_IN) {
13675                 if (r->in.bind_handle == NULL) {
13676                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13677                 }
13678                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13679                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13680                 if (r->in.req == NULL) {
13681                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13682                 }
13683                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13684                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13685         }
13686         if (flags & NDR_OUT) {
13687                 if (r->out.level_out == NULL) {
13688                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13689                 }
13690                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13691                 if (r->out.res == NULL) {
13692                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13693                 }
13694                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
13695                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
13696                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13697         }
13698         return NDR_ERR_SUCCESS;
13699 }
13700
13701 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
13702 {
13703         TALLOC_CTX *_mem_save_bind_handle_0;
13704         TALLOC_CTX *_mem_save_req_0;
13705         TALLOC_CTX *_mem_save_level_out_0;
13706         TALLOC_CTX *_mem_save_res_0;
13707         if (flags & NDR_IN) {
13708                 ZERO_STRUCT(r->out);
13709
13710                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13711                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13712                 }
13713                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13714                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13715                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13717                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13718                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13719                         NDR_PULL_ALLOC(ndr, r->in.req);
13720                 }
13721                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13722                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13723                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13724                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13726                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13727                 ZERO_STRUCTP(r->out.level_out);
13728                 NDR_PULL_ALLOC(ndr, r->out.res);
13729                 ZERO_STRUCTP(r->out.res);
13730         }
13731         if (flags & NDR_OUT) {
13732                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13733                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13734                 }
13735                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13736                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13737                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13738                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13739                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13740                         NDR_PULL_ALLOC(ndr, r->out.res);
13741                 }
13742                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
13743                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
13744                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
13745                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
13746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
13747                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13748         }
13749         return NDR_ERR_SUCCESS;
13750 }
13751
13752 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
13753 {
13754         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
13755         ndr->depth++;
13756         if (flags & NDR_SET_VALUES) {
13757                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13758         }
13759         if (flags & NDR_IN) {
13760                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
13761                 ndr->depth++;
13762                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13763                 ndr->depth++;
13764                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13765                 ndr->depth--;
13766                 ndr_print_int32(ndr, "level", r->in.level);
13767                 ndr_print_ptr(ndr, "req", r->in.req);
13768                 ndr->depth++;
13769                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13770                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
13771                 ndr->depth--;
13772                 ndr->depth--;
13773         }
13774         if (flags & NDR_OUT) {
13775                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
13776                 ndr->depth++;
13777                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13778                 ndr->depth++;
13779                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13780                 ndr->depth--;
13781                 ndr_print_ptr(ndr, "res", r->out.res);
13782                 ndr->depth++;
13783                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
13784                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
13785                 ndr->depth--;
13786                 ndr_print_WERROR(ndr, "result", r->out.result);
13787                 ndr->depth--;
13788         }
13789         ndr->depth--;
13790 }
13791
13792 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
13793 {
13794         if (flags & NDR_IN) {
13795         }
13796         if (flags & NDR_OUT) {
13797                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13798         }
13799         return NDR_ERR_SUCCESS;
13800 }
13801
13802 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
13803 {
13804         if (flags & NDR_IN) {
13805         }
13806         if (flags & NDR_OUT) {
13807                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13808         }
13809         return NDR_ERR_SUCCESS;
13810 }
13811
13812 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
13813 {
13814         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
13815         ndr->depth++;
13816         if (flags & NDR_SET_VALUES) {
13817                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13818         }
13819         if (flags & NDR_IN) {
13820                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
13821                 ndr->depth++;
13822                 ndr->depth--;
13823         }
13824         if (flags & NDR_OUT) {
13825                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
13826                 ndr->depth++;
13827                 ndr_print_WERROR(ndr, "result", r->out.result);
13828                 ndr->depth--;
13829         }
13830         ndr->depth--;
13831 }
13832
13833 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
13834 {
13835         if (flags & NDR_IN) {
13836                 if (r->in.bind_handle == NULL) {
13837                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13838                 }
13839                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13840                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13841                 if (r->in.req == NULL) {
13842                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13843                 }
13844                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13845                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13846         }
13847         if (flags & NDR_OUT) {
13848                 if (r->out.level_out == NULL) {
13849                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13850                 }
13851                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13852                 if (r->out.ctr == NULL) {
13853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13854                 }
13855                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13856                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13857                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13858         }
13859         return NDR_ERR_SUCCESS;
13860 }
13861
13862 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
13863 {
13864         TALLOC_CTX *_mem_save_bind_handle_0;
13865         TALLOC_CTX *_mem_save_req_0;
13866         TALLOC_CTX *_mem_save_level_out_0;
13867         TALLOC_CTX *_mem_save_ctr_0;
13868         if (flags & NDR_IN) {
13869                 ZERO_STRUCT(r->out);
13870
13871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13872                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13873                 }
13874                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13875                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13878                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13879                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13880                         NDR_PULL_ALLOC(ndr, r->in.req);
13881                 }
13882                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13883                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13884                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13885                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13886                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13887                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13888                 ZERO_STRUCTP(r->out.level_out);
13889                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13890                 ZERO_STRUCTP(r->out.ctr);
13891         }
13892         if (flags & NDR_OUT) {
13893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13894                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13895                 }
13896                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13897                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13898                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13900                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13901                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13902                 }
13903                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13904                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13905                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13906                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13907                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13908                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13909         }
13910         return NDR_ERR_SUCCESS;
13911 }
13912
13913 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
13914 {
13915         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
13916         ndr->depth++;
13917         if (flags & NDR_SET_VALUES) {
13918                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13919         }
13920         if (flags & NDR_IN) {
13921                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
13922                 ndr->depth++;
13923                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13924                 ndr->depth++;
13925                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13926                 ndr->depth--;
13927                 ndr_print_int32(ndr, "level", r->in.level);
13928                 ndr_print_ptr(ndr, "req", r->in.req);
13929                 ndr->depth++;
13930                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13931                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
13932                 ndr->depth--;
13933                 ndr->depth--;
13934         }
13935         if (flags & NDR_OUT) {
13936                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
13937                 ndr->depth++;
13938                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13939                 ndr->depth++;
13940                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13941                 ndr->depth--;
13942                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13943                 ndr->depth++;
13944                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13945                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
13946                 ndr->depth--;
13947                 ndr_print_WERROR(ndr, "result", r->out.result);
13948                 ndr->depth--;
13949         }
13950         ndr->depth--;
13951 }
13952
13953 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
13954 {
13955         if (flags & NDR_IN) {
13956                 if (r->in.bind_handle == NULL) {
13957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13958                 }
13959                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13960                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13961                 if (r->in.req == NULL) {
13962                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13963                 }
13964                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13965                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13966         }
13967         if (flags & NDR_OUT) {
13968                 if (r->out.level_out == NULL) {
13969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13970                 }
13971                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13972                 if (r->out.ctr == NULL) {
13973                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13974                 }
13975                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13976                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13977                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13978         }
13979         return NDR_ERR_SUCCESS;
13980 }
13981
13982 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
13983 {
13984         TALLOC_CTX *_mem_save_bind_handle_0;
13985         TALLOC_CTX *_mem_save_req_0;
13986         TALLOC_CTX *_mem_save_level_out_0;
13987         TALLOC_CTX *_mem_save_ctr_0;
13988         if (flags & NDR_IN) {
13989                 ZERO_STRUCT(r->out);
13990
13991                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13992                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13993                 }
13994                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13995                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13996                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13997                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13998                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14000                         NDR_PULL_ALLOC(ndr, r->in.req);
14001                 }
14002                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14003                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14004                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14005                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14006                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14007                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14008                 ZERO_STRUCTP(r->out.level_out);
14009                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14010                 ZERO_STRUCTP(r->out.ctr);
14011         }
14012         if (flags & NDR_OUT) {
14013                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14014                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14015                 }
14016                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14017                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14018                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14021                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14022                 }
14023                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14024                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14025                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14026                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14028                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14029         }
14030         return NDR_ERR_SUCCESS;
14031 }
14032
14033 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14034 {
14035         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14036         ndr->depth++;
14037         if (flags & NDR_SET_VALUES) {
14038                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14039         }
14040         if (flags & NDR_IN) {
14041                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14042                 ndr->depth++;
14043                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14044                 ndr->depth++;
14045                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14046                 ndr->depth--;
14047                 ndr_print_int32(ndr, "level", r->in.level);
14048                 ndr_print_ptr(ndr, "req", r->in.req);
14049                 ndr->depth++;
14050                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14051                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14052                 ndr->depth--;
14053                 ndr->depth--;
14054         }
14055         if (flags & NDR_OUT) {
14056                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14057                 ndr->depth++;
14058                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14059                 ndr->depth++;
14060                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14061                 ndr->depth--;
14062                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14063                 ndr->depth++;
14064                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14065                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14066                 ndr->depth--;
14067                 ndr_print_WERROR(ndr, "result", r->out.result);
14068                 ndr->depth--;
14069         }
14070         ndr->depth--;
14071 }
14072
14073 static enum ndr_err_code ndr_push_DRSUAPI_EXECUTE_KCC(struct ndr_push *ndr, int flags, const struct DRSUAPI_EXECUTE_KCC *r)
14074 {
14075         if (flags & NDR_IN) {
14076         }
14077         if (flags & NDR_OUT) {
14078                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14079         }
14080         return NDR_ERR_SUCCESS;
14081 }
14082
14083 static enum ndr_err_code ndr_pull_DRSUAPI_EXECUTE_KCC(struct ndr_pull *ndr, int flags, struct DRSUAPI_EXECUTE_KCC *r)
14084 {
14085         if (flags & NDR_IN) {
14086         }
14087         if (flags & NDR_OUT) {
14088                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14089         }
14090         return NDR_ERR_SUCCESS;
14091 }
14092
14093 _PUBLIC_ void ndr_print_DRSUAPI_EXECUTE_KCC(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_EXECUTE_KCC *r)
14094 {
14095         ndr_print_struct(ndr, name, "DRSUAPI_EXECUTE_KCC");
14096         ndr->depth++;
14097         if (flags & NDR_SET_VALUES) {
14098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14099         }
14100         if (flags & NDR_IN) {
14101                 ndr_print_struct(ndr, "in", "DRSUAPI_EXECUTE_KCC");
14102                 ndr->depth++;
14103                 ndr->depth--;
14104         }
14105         if (flags & NDR_OUT) {
14106                 ndr_print_struct(ndr, "out", "DRSUAPI_EXECUTE_KCC");
14107                 ndr->depth++;
14108                 ndr_print_WERROR(ndr, "result", r->out.result);
14109                 ndr->depth--;
14110         }
14111         ndr->depth--;
14112 }
14113
14114 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14115 {
14116         if (flags & NDR_IN) {
14117                 if (r->in.bind_handle == NULL) {
14118                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14119                 }
14120                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14121                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14122                 if (r->in.req == NULL) {
14123                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14124                 }
14125                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14126                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14127         }
14128         if (flags & NDR_OUT) {
14129                 if (r->out.info_type == NULL) {
14130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14131                 }
14132                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14133                 if (r->out.info == NULL) {
14134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14135                 }
14136                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
14137                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14138                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14139         }
14140         return NDR_ERR_SUCCESS;
14141 }
14142
14143 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14144 {
14145         TALLOC_CTX *_mem_save_bind_handle_0;
14146         TALLOC_CTX *_mem_save_req_0;
14147         TALLOC_CTX *_mem_save_info_type_0;
14148         TALLOC_CTX *_mem_save_info_0;
14149         if (flags & NDR_IN) {
14150                 ZERO_STRUCT(r->out);
14151
14152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14153                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14154                 }
14155                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14156                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14157                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14158                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14159                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
14160                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14161                         NDR_PULL_ALLOC(ndr, r->in.req);
14162                 }
14163                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14164                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14165                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14166                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14167                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14168                 NDR_PULL_ALLOC(ndr, r->out.info_type);
14169                 ZERO_STRUCTP(r->out.info_type);
14170                 NDR_PULL_ALLOC(ndr, r->out.info);
14171                 ZERO_STRUCTP(r->out.info);
14172         }
14173         if (flags & NDR_OUT) {
14174                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14175                         NDR_PULL_ALLOC(ndr, r->out.info_type);
14176                 }
14177                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
14178                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
14179                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
14180                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
14181                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14182                         NDR_PULL_ALLOC(ndr, r->out.info);
14183                 }
14184                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14185                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14186                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
14187                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14189                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14190         }
14191         return NDR_ERR_SUCCESS;
14192 }
14193
14194 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14195 {
14196         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
14197         ndr->depth++;
14198         if (flags & NDR_SET_VALUES) {
14199                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14200         }
14201         if (flags & NDR_IN) {
14202                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
14203                 ndr->depth++;
14204                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14205                 ndr->depth++;
14206                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14207                 ndr->depth--;
14208                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
14209                 ndr_print_ptr(ndr, "req", r->in.req);
14210                 ndr->depth++;
14211                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14212                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
14213                 ndr->depth--;
14214                 ndr->depth--;
14215         }
14216         if (flags & NDR_OUT) {
14217                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
14218                 ndr->depth++;
14219                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
14220                 ndr->depth++;
14221                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
14222                 ndr->depth--;
14223                 ndr_print_ptr(ndr, "info", r->out.info);
14224                 ndr->depth++;
14225                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
14226                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
14227                 ndr->depth--;
14228                 ndr_print_WERROR(ndr, "result", r->out.result);
14229                 ndr->depth--;
14230         }
14231         ndr->depth--;
14232 }
14233
14234 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
14235 {
14236         if (flags & NDR_IN) {
14237         }
14238         if (flags & NDR_OUT) {
14239                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14240         }
14241         return NDR_ERR_SUCCESS;
14242 }
14243
14244 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
14245 {
14246         if (flags & NDR_IN) {
14247         }
14248         if (flags & NDR_OUT) {
14249                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14250         }
14251         return NDR_ERR_SUCCESS;
14252 }
14253
14254 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
14255 {
14256         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
14257         ndr->depth++;
14258         if (flags & NDR_SET_VALUES) {
14259                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14260         }
14261         if (flags & NDR_IN) {
14262                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
14263                 ndr->depth++;
14264                 ndr->depth--;
14265         }
14266         if (flags & NDR_OUT) {
14267                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
14268                 ndr->depth++;
14269                 ndr_print_WERROR(ndr, "result", r->out.result);
14270                 ndr->depth--;
14271         }
14272         ndr->depth--;
14273 }
14274
14275 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
14276 {
14277         if (flags & NDR_IN) {
14278                 if (r->in.bind_handle == NULL) {
14279                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14280                 }
14281                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14282                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14283                 if (r->in.req == NULL) {
14284                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14285                 }
14286                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14287                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14288         }
14289         if (flags & NDR_OUT) {
14290                 if (r->out.level_out == NULL) {
14291                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14292                 }
14293                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14294                 if (r->out.ctr == NULL) {
14295                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14296                 }
14297                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14298                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14299                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14300         }
14301         return NDR_ERR_SUCCESS;
14302 }
14303
14304 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
14305 {
14306         TALLOC_CTX *_mem_save_bind_handle_0;
14307         TALLOC_CTX *_mem_save_req_0;
14308         TALLOC_CTX *_mem_save_level_out_0;
14309         TALLOC_CTX *_mem_save_ctr_0;
14310         if (flags & NDR_IN) {
14311                 ZERO_STRUCT(r->out);
14312
14313                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14314                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14315                 }
14316                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14317                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14318                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14319                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14320                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14321                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14322                         NDR_PULL_ALLOC(ndr, r->in.req);
14323                 }
14324                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14325                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14326                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14327                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14328                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14329                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14330                 ZERO_STRUCTP(r->out.level_out);
14331                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14332                 ZERO_STRUCTP(r->out.ctr);
14333         }
14334         if (flags & NDR_OUT) {
14335                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14336                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14337                 }
14338                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14339                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14340                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14341                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14343                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14344                 }
14345                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14346                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14347                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14348                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14349                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14350                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14351         }
14352         return NDR_ERR_SUCCESS;
14353 }
14354
14355 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
14356 {
14357         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
14358         ndr->depth++;
14359         if (flags & NDR_SET_VALUES) {
14360                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14361         }
14362         if (flags & NDR_IN) {
14363                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
14364                 ndr->depth++;
14365                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14366                 ndr->depth++;
14367                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14368                 ndr->depth--;
14369                 ndr_print_int32(ndr, "level", r->in.level);
14370                 ndr_print_ptr(ndr, "req", r->in.req);
14371                 ndr->depth++;
14372                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14373                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
14374                 ndr->depth--;
14375                 ndr->depth--;
14376         }
14377         if (flags & NDR_OUT) {
14378                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
14379                 ndr->depth++;
14380                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14381                 ndr->depth++;
14382                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14383                 ndr->depth--;
14384                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14385                 ndr->depth++;
14386                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14387                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
14388                 ndr->depth--;
14389                 ndr_print_WERROR(ndr, "result", r->out.result);
14390                 ndr->depth--;
14391         }
14392         ndr->depth--;
14393 }
14394
14395 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14396 {
14397         if (flags & NDR_IN) {
14398         }
14399         if (flags & NDR_OUT) {
14400                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14401         }
14402         return NDR_ERR_SUCCESS;
14403 }
14404
14405 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14406 {
14407         if (flags & NDR_IN) {
14408         }
14409         if (flags & NDR_OUT) {
14410                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14411         }
14412         return NDR_ERR_SUCCESS;
14413 }
14414
14415 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
14416 {
14417         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
14418         ndr->depth++;
14419         if (flags & NDR_SET_VALUES) {
14420                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14421         }
14422         if (flags & NDR_IN) {
14423                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
14424                 ndr->depth++;
14425                 ndr->depth--;
14426         }
14427         if (flags & NDR_OUT) {
14428                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
14429                 ndr->depth++;
14430                 ndr_print_WERROR(ndr, "result", r->out.result);
14431                 ndr->depth--;
14432         }
14433         ndr->depth--;
14434 }
14435
14436 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
14437 {
14438         if (flags & NDR_IN) {
14439         }
14440         if (flags & NDR_OUT) {
14441                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14442         }
14443         return NDR_ERR_SUCCESS;
14444 }
14445
14446 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
14447 {
14448         if (flags & NDR_IN) {
14449         }
14450         if (flags & NDR_OUT) {
14451                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14452         }
14453         return NDR_ERR_SUCCESS;
14454 }
14455
14456 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
14457 {
14458         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
14459         ndr->depth++;
14460         if (flags & NDR_SET_VALUES) {
14461                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14462         }
14463         if (flags & NDR_IN) {
14464                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
14465                 ndr->depth++;
14466                 ndr->depth--;
14467         }
14468         if (flags & NDR_OUT) {
14469                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
14470                 ndr->depth++;
14471                 ndr_print_WERROR(ndr, "result", r->out.result);
14472                 ndr->depth--;
14473         }
14474         ndr->depth--;
14475 }
14476
14477 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
14478 {
14479         if (flags & NDR_IN) {
14480                 if (r->in.bind_handle == NULL) {
14481                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14482                 }
14483                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14484                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14485                 if (r->in.req == NULL) {
14486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14487                 }
14488                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14489                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14490         }
14491         if (flags & NDR_OUT) {
14492                 if (r->out.level_out == NULL) {
14493                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14494                 }
14495                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14496                 if (r->out.ctr == NULL) {
14497                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14498                 }
14499                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14500                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14501                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14502         }
14503         return NDR_ERR_SUCCESS;
14504 }
14505
14506 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
14507 {
14508         TALLOC_CTX *_mem_save_bind_handle_0;
14509         TALLOC_CTX *_mem_save_req_0;
14510         TALLOC_CTX *_mem_save_level_out_0;
14511         TALLOC_CTX *_mem_save_ctr_0;
14512         if (flags & NDR_IN) {
14513                 ZERO_STRUCT(r->out);
14514
14515                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14516                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14517                 }
14518                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14519                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14520                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14522                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14523                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14524                         NDR_PULL_ALLOC(ndr, r->in.req);
14525                 }
14526                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14527                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14528                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14529                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14530                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14531                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14532                 ZERO_STRUCTP(r->out.level_out);
14533                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14534                 ZERO_STRUCTP(r->out.ctr);
14535         }
14536         if (flags & NDR_OUT) {
14537                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14538                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14539                 }
14540                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14541                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14542                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14543                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14544                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14545                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14546                 }
14547                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14548                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14549                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14550                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14551                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14552                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14553         }
14554         return NDR_ERR_SUCCESS;
14555 }
14556
14557 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
14558 {
14559         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
14560         ndr->depth++;
14561         if (flags & NDR_SET_VALUES) {
14562                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14563         }
14564         if (flags & NDR_IN) {
14565                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
14566                 ndr->depth++;
14567                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14568                 ndr->depth++;
14569                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14570                 ndr->depth--;
14571                 ndr_print_int32(ndr, "level", r->in.level);
14572                 ndr_print_ptr(ndr, "req", r->in.req);
14573                 ndr->depth++;
14574                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14575                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
14576                 ndr->depth--;
14577                 ndr->depth--;
14578         }
14579         if (flags & NDR_OUT) {
14580                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
14581                 ndr->depth++;
14582                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14583                 ndr->depth++;
14584                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14585                 ndr->depth--;
14586                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14587                 ndr->depth++;
14588                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14589                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
14590                 ndr->depth--;
14591                 ndr_print_WERROR(ndr, "result", r->out.result);
14592                 ndr->depth--;
14593         }
14594         ndr->depth--;
14595 }
14596
14597 static const struct ndr_interface_call drsuapi_calls[] = {
14598         {
14599                 "drsuapi_DsBind",
14600                 sizeof(struct drsuapi_DsBind),
14601                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
14602                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
14603                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
14604                 false,
14605         },
14606         {
14607                 "drsuapi_DsUnbind",
14608                 sizeof(struct drsuapi_DsUnbind),
14609                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
14610                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
14611                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
14612                 false,
14613         },
14614         {
14615                 "drsuapi_DsReplicaSync",
14616                 sizeof(struct drsuapi_DsReplicaSync),
14617                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
14618                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
14619                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
14620                 false,
14621         },
14622         {
14623                 "drsuapi_DsGetNCChanges",
14624                 sizeof(struct drsuapi_DsGetNCChanges),
14625                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
14626                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
14627                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
14628                 false,
14629         },
14630         {
14631                 "drsuapi_DsReplicaUpdateRefs",
14632                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
14633                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
14634                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
14635                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
14636                 false,
14637         },
14638         {
14639                 "DRSUAPI_REPLICA_ADD",
14640                 sizeof(struct DRSUAPI_REPLICA_ADD),
14641                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_ADD,
14642                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_ADD,
14643                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_ADD,
14644                 false,
14645         },
14646         {
14647                 "DRSUAPI_REPLICA_DEL",
14648                 sizeof(struct DRSUAPI_REPLICA_DEL),
14649                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_DEL,
14650                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_DEL,
14651                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_DEL,
14652                 false,
14653         },
14654         {
14655                 "DRSUAPI_REPLICA_MODIFY",
14656                 sizeof(struct DRSUAPI_REPLICA_MODIFY),
14657                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_MODIFY,
14658                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_MODIFY,
14659                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_MODIFY,
14660                 false,
14661         },
14662         {
14663                 "DRSUAPI_VERIFY_NAMES",
14664                 sizeof(struct DRSUAPI_VERIFY_NAMES),
14665                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
14666                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
14667                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
14668                 false,
14669         },
14670         {
14671                 "drsuapi_DsGetMemberships",
14672                 sizeof(struct drsuapi_DsGetMemberships),
14673                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
14674                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
14675                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
14676                 false,
14677         },
14678         {
14679                 "DRSUAPI_INTER_DOMAIN_MOVE",
14680                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
14681                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
14682                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
14683                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
14684                 false,
14685         },
14686         {
14687                 "drsuapi_DsGetNT4ChangeLog",
14688                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
14689                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
14690                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
14691                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
14692                 false,
14693         },
14694         {
14695                 "drsuapi_DsCrackNames",
14696                 sizeof(struct drsuapi_DsCrackNames),
14697                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
14698                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
14699                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
14700                 false,
14701         },
14702         {
14703                 "drsuapi_DsWriteAccountSpn",
14704                 sizeof(struct drsuapi_DsWriteAccountSpn),
14705                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
14706                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
14707                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
14708                 false,
14709         },
14710         {
14711                 "drsuapi_DsRemoveDSServer",
14712                 sizeof(struct drsuapi_DsRemoveDSServer),
14713                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
14714                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
14715                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
14716                 false,
14717         },
14718         {
14719                 "DRSUAPI_REMOVE_DS_DOMAIN",
14720                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
14721                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
14722                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
14723                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
14724                 false,
14725         },
14726         {
14727                 "drsuapi_DsGetDomainControllerInfo",
14728                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
14729                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
14730                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
14731                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
14732                 false,
14733         },
14734         {
14735                 "drsuapi_DsAddEntry",
14736                 sizeof(struct drsuapi_DsAddEntry),
14737                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
14738                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
14739                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
14740                 false,
14741         },
14742         {
14743                 "DRSUAPI_EXECUTE_KCC",
14744                 sizeof(struct DRSUAPI_EXECUTE_KCC),
14745                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_EXECUTE_KCC,
14746                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_EXECUTE_KCC,
14747                 (ndr_print_function_t) ndr_print_DRSUAPI_EXECUTE_KCC,
14748                 false,
14749         },
14750         {
14751                 "drsuapi_DsReplicaGetInfo",
14752                 sizeof(struct drsuapi_DsReplicaGetInfo),
14753                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
14754                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
14755                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
14756                 false,
14757         },
14758         {
14759                 "DRSUAPI_ADD_SID_HISTORY",
14760                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
14761                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
14762                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
14763                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
14764                 false,
14765         },
14766         {
14767                 "drsuapi_DsGetMemberships2",
14768                 sizeof(struct drsuapi_DsGetMemberships2),
14769                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
14770                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
14771                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
14772                 false,
14773         },
14774         {
14775                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
14776                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
14777                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
14778                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
14779                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
14780                 false,
14781         },
14782         {
14783                 "DRSUAPI_GET_OBJECT_EXISTENCE",
14784                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
14785                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
14786                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
14787                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
14788                 false,
14789         },
14790         {
14791                 "drsuapi_QuerySitesByCost",
14792                 sizeof(struct drsuapi_QuerySitesByCost),
14793                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
14794                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
14795                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
14796                 false,
14797         },
14798         { NULL, 0, NULL, NULL, NULL, false }
14799 };
14800
14801 static const char * const drsuapi_endpoint_strings[] = {
14802         "ncacn_np:[\\pipe\\lsass]",
14803         "ncacn_np:[\\pipe\\protected_storage]",
14804         "ncacn_ip_tcp:",
14805         "ncalrpc:",
14806 };
14807
14808 static const struct ndr_interface_string_array drsuapi_endpoints = {
14809         .count  = 4,
14810         .names  = drsuapi_endpoint_strings
14811 };
14812
14813 static const char * const drsuapi_authservice_strings[] = {
14814         "ldap",
14815 };
14816
14817 static const struct ndr_interface_string_array drsuapi_authservices = {
14818         .count  = 1,
14819         .names  = drsuapi_authservice_strings
14820 };
14821
14822
14823 const struct ndr_interface_table ndr_table_drsuapi = {
14824         .name           = "drsuapi",
14825         .syntax_id      = {
14826                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
14827                 NDR_DRSUAPI_VERSION
14828         },
14829         .helpstring     = NDR_DRSUAPI_HELPSTRING,
14830         .num_calls      = 25,
14831         .calls          = drsuapi_calls,
14832         .endpoints      = &drsuapi_endpoints,
14833         .authservices   = &drsuapi_authservices
14834 };
14835