librpc/gen_ndr/ndr_dssetup.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_dssetup.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 static enum ndr_err_code ndr_push_dssetup_DsRole(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsRole r)
   8 {
   9         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
  10         return NDR_ERR_SUCCESS;
  11 }
  12
  13 static enum ndr_err_code ndr_pull_dssetup_DsRole(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsRole *r)
  14 {
  15         uint16_t v;
  16         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
  17         *r = v;
  18         return NDR_ERR_SUCCESS;
  19 }
  20
  21 _PUBLIC_ void ndr_print_dssetup_DsRole(struct ndr_print *ndr, const char *name, enum dssetup_DsRole r)
  22 {
  23         const char *val = NULL;
  24
  25         switch (r) {
  26                 case DS_ROLE_STANDALONE_WORKSTATION: val = "DS_ROLE_STANDALONE_WORKSTATION"; break;
  27                 case DS_ROLE_MEMBER_WORKSTATION: val = "DS_ROLE_MEMBER_WORKSTATION"; break;
  28                 case DS_ROLE_STANDALONE_SERVER: val = "DS_ROLE_STANDALONE_SERVER"; break;
  29                 case DS_ROLE_MEMBER_SERVER: val = "DS_ROLE_MEMBER_SERVER"; break;
  30                 case DS_ROLE_BACKUP_DC: val = "DS_ROLE_BACKUP_DC"; break;
  31                 case DS_ROLE_PRIMARY_DC: val = "DS_ROLE_PRIMARY_DC"; break;
  32         }
  33         ndr_print_enum(ndr, name, "ENUM", val, r);
  34 }
  35
  36 static enum ndr_err_code ndr_push_dssetup_DsRoleFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  37 {
  38         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  39         return NDR_ERR_SUCCESS;
  40 }
  41
  42 static enum ndr_err_code ndr_pull_dssetup_DsRoleFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  43 {
  44         uint32_t v;
  45         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  46         *r = v;
  47         return NDR_ERR_SUCCESS;
  48 }
  49
  50 _PUBLIC_ void ndr_print_dssetup_DsRoleFlags(struct ndr_print *ndr, const char *name, uint32_t r)
  51 {
  52         ndr_print_uint32(ndr, name, r);
  53         ndr->depth++;
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_ROLE_PRIMARY_DS_RUNNING", DS_ROLE_PRIMARY_DS_RUNNING, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_ROLE_PRIMARY_DS_MIXED_MODE", DS_ROLE_PRIMARY_DS_MIXED_MODE, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_ROLE_UPGRADE_IN_PROGRESS", DS_ROLE_UPGRADE_IN_PROGRESS, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DS_ROLE_PRIMARY_DOMAIN_GUID_PRESENT", DS_ROLE_PRIMARY_DOMAIN_GUID_PRESENT, r);
  58         ndr->depth--;
  59 }
  60
  61 static enum ndr_err_code ndr_push_dssetup_DsRolePrimaryDomInfoBasic(struct ndr_push *ndr, int ndr_flags, const struct dssetup_DsRolePrimaryDomInfoBasic *r)
  62 {
  63         if (ndr_flags & NDR_SCALARS) {
  64                 NDR_CHECK(ndr_push_align(ndr, 5));
  65                 NDR_CHECK(ndr_push_dssetup_DsRole(ndr, NDR_SCALARS, r->role));
  66                 NDR_CHECK(ndr_push_dssetup_DsRoleFlags(ndr, NDR_SCALARS, r->flags));
  67                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
  68                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain));
  69                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->forest));
  70                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_guid));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->domain) {
  74                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
  75                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  76                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
  77                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  78                 }
  79                 if (r->dns_domain) {
  80                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain, CH_UTF16)));
  81                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  82                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain, CH_UTF16)));
  83                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_domain, ndr_charset_length(r->dns_domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  84                 }
  85                 if (r->forest) {
  86                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->forest, CH_UTF16)));
  87                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  88                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->forest, CH_UTF16)));
  89                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->forest, ndr_charset_length(r->forest, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  90                 }
  91         }
  92         return NDR_ERR_SUCCESS;
  93 }
  94
  95 static enum ndr_err_code ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(struct ndr_pull *ndr, int ndr_flags, struct dssetup_DsRolePrimaryDomInfoBasic *r)
  96 {
  97         uint32_t _ptr_domain;
  98         TALLOC_CTX *_mem_save_domain_0;
  99         uint32_t _ptr_dns_domain;
 100         TALLOC_CTX *_mem_save_dns_domain_0;
 101         uint32_t _ptr_forest;
 102         TALLOC_CTX *_mem_save_forest_0;
 103         if (ndr_flags & NDR_SCALARS) {
 104                 NDR_CHECK(ndr_pull_align(ndr, 5));
 105                 NDR_CHECK(ndr_pull_dssetup_DsRole(ndr, NDR_SCALARS, &r->role));
 106                 NDR_CHECK(ndr_pull_dssetup_DsRoleFlags(ndr, NDR_SCALARS, &r->flags));
 107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
 108                 if (_ptr_domain) {
 109                         NDR_PULL_ALLOC(ndr, r->domain);
 110                 } else {
 111                         r->domain = NULL;
 112                 }
 113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain));
 114                 if (_ptr_dns_domain) {
 115                         NDR_PULL_ALLOC(ndr, r->dns_domain);
 116                 } else {
 117                         r->dns_domain = NULL;
 118                 }
 119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_forest));
 120                 if (_ptr_forest) {
 121                         NDR_PULL_ALLOC(ndr, r->forest);
 122                 } else {
 123                         r->forest = NULL;
 124                 }
 125                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_guid));
 126         }
 127         if (ndr_flags & NDR_BUFFERS) {
 128                 if (r->domain) {
 129                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
 130                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
 131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
 132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
 133                         if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {
 134                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain), ndr_get_array_length(ndr, &r->domain));
 135                         }
 136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));
 137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));
 138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
 139                 }
 140                 if (r->dns_domain) {
 141                         _mem_save_dns_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
 142                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain, 0);
 143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain));
 144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain));
 145                         if (ndr_get_array_length(ndr, &r->dns_domain) > ndr_get_array_size(ndr, &r->dns_domain)) {
 146                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_domain), ndr_get_array_length(ndr, &r->dns_domain));
 147                         }
 148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain), sizeof(uint16_t)));
 149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_domain, ndr_get_array_length(ndr, &r->dns_domain), sizeof(uint16_t), CH_UTF16));
 150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_0, 0);
 151                 }
 152                 if (r->forest) {
 153                         _mem_save_forest_0 = NDR_PULL_GET_MEM_CTX(ndr);
 154                         NDR_PULL_SET_MEM_CTX(ndr, r->forest, 0);
 155                         NDR_CHECK(ndr_pull_array_size(ndr, &r->forest));
 156                         NDR_CHECK(ndr_pull_array_length(ndr, &r->forest));
 157                         if (ndr_get_array_length(ndr, &r->forest) > ndr_get_array_size(ndr, &r->forest)) {
 158                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->forest), ndr_get_array_length(ndr, &r->forest));
 159                         }
 160                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->forest), sizeof(uint16_t)));
 161                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->forest, ndr_get_array_length(ndr, &r->forest), sizeof(uint16_t), CH_UTF16));
 162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_0, 0);
 163                 }
 164         }
 165         return NDR_ERR_SUCCESS;
 166 }
 167
 168 _PUBLIC_ void ndr_print_dssetup_DsRolePrimaryDomInfoBasic(struct ndr_print *ndr, const char *name, const struct dssetup_DsRolePrimaryDomInfoBasic *r)
 169 {
 170         ndr_print_struct(ndr, name, "dssetup_DsRolePrimaryDomInfoBasic");
 171         ndr->depth++;
 172         ndr_print_dssetup_DsRole(ndr, "role", r->role);
 173         ndr_print_dssetup_DsRoleFlags(ndr, "flags", r->flags);
 174         ndr_print_ptr(ndr, "domain", r->domain);
 175         ndr->depth++;
 176         if (r->domain) {
 177                 ndr_print_string(ndr, "domain", r->domain);
 178         }
 179         ndr->depth--;
 180         ndr_print_ptr(ndr, "dns_domain", r->dns_domain);
 181         ndr->depth++;
 182         if (r->dns_domain) {
 183                 ndr_print_string(ndr, "dns_domain", r->dns_domain);
 184         }
 185         ndr->depth--;
 186         ndr_print_ptr(ndr, "forest", r->forest);
 187         ndr->depth++;
 188         if (r->forest) {
 189                 ndr_print_string(ndr, "forest", r->forest);
 190         }
 191         ndr->depth--;
 192         ndr_print_GUID(ndr, "domain_guid", &r->domain_guid);
 193         ndr->depth--;
 194 }
 195
 196 static enum ndr_err_code ndr_push_dssetup_DsUpgrade(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsUpgrade r)
 197 {
 198         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 199         return NDR_ERR_SUCCESS;
 200 }
 201
 202 static enum ndr_err_code ndr_pull_dssetup_DsUpgrade(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsUpgrade *r)
 203 {
 204         uint32_t v;
 205         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 206         *r = v;
 207         return NDR_ERR_SUCCESS;
 208 }
 209
 210 _PUBLIC_ void ndr_print_dssetup_DsUpgrade(struct ndr_print *ndr, const char *name, enum dssetup_DsUpgrade r)
 211 {
 212         const char *val = NULL;
 213
 214         switch (r) {
 215                 case DS_ROLE_NOT_UPGRADING: val = "DS_ROLE_NOT_UPGRADING"; break;
 216                 case DS_ROLE_UPGRADING: val = "DS_ROLE_UPGRADING"; break;
 217         }
 218         ndr_print_enum(ndr, name, "ENUM", val, r);
 219 }
 220
 221 static enum ndr_err_code ndr_push_dssetup_DsPrevious(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsPrevious r)
 222 {
 223         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 224         return NDR_ERR_SUCCESS;
 225 }
 226
 227 static enum ndr_err_code ndr_pull_dssetup_DsPrevious(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsPrevious *r)
 228 {
 229         uint16_t v;
 230         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 231         *r = v;
 232         return NDR_ERR_SUCCESS;
 233 }
 234
 235 _PUBLIC_ void ndr_print_dssetup_DsPrevious(struct ndr_print *ndr, const char *name, enum dssetup_DsPrevious r)
 236 {
 237         const char *val = NULL;
 238
 239         switch (r) {
 240                 case DS_ROLE_PREVIOUS_UNKNOWN: val = "DS_ROLE_PREVIOUS_UNKNOWN"; break;
 241                 case DS_ROLE_PREVIOUS_PRIMARY: val = "DS_ROLE_PREVIOUS_PRIMARY"; break;
 242                 case DS_ROLE_PREVIOUS_BACKUP: val = "DS_ROLE_PREVIOUS_BACKUP"; break;
 243         }
 244         ndr_print_enum(ndr, name, "ENUM", val, r);
 245 }
 246
 247 static enum ndr_err_code ndr_push_dssetup_DsRoleUpgradeStatus(struct ndr_push *ndr, int ndr_flags, const struct dssetup_DsRoleUpgradeStatus *r)
 248 {
 249         if (ndr_flags & NDR_SCALARS) {
 250                 NDR_CHECK(ndr_push_align(ndr, 4));
 251                 NDR_CHECK(ndr_push_dssetup_DsUpgrade(ndr, NDR_SCALARS, r->upgrading));
 252                 NDR_CHECK(ndr_push_dssetup_DsPrevious(ndr, NDR_SCALARS, r->previous_role));
 253         }
 254         if (ndr_flags & NDR_BUFFERS) {
 255         }
 256         return NDR_ERR_SUCCESS;
 257 }
 258
 259 static enum ndr_err_code ndr_pull_dssetup_DsRoleUpgradeStatus(struct ndr_pull *ndr, int ndr_flags, struct dssetup_DsRoleUpgradeStatus *r)
 260 {
 261         if (ndr_flags & NDR_SCALARS) {
 262                 NDR_CHECK(ndr_pull_align(ndr, 4));
 263                 NDR_CHECK(ndr_pull_dssetup_DsUpgrade(ndr, NDR_SCALARS, &r->upgrading));
 264                 NDR_CHECK(ndr_pull_dssetup_DsPrevious(ndr, NDR_SCALARS, &r->previous_role));
 265         }
 266         if (ndr_flags & NDR_BUFFERS) {
 267         }
 268         return NDR_ERR_SUCCESS;
 269 }
 270
 271 _PUBLIC_ void ndr_print_dssetup_DsRoleUpgradeStatus(struct ndr_print *ndr, const char *name, const struct dssetup_DsRoleUpgradeStatus *r)
 272 {
 273         ndr_print_struct(ndr, name, "dssetup_DsRoleUpgradeStatus");
 274         ndr->depth++;
 275         ndr_print_dssetup_DsUpgrade(ndr, "upgrading", r->upgrading);
 276         ndr_print_dssetup_DsPrevious(ndr, "previous_role", r->previous_role);
 277         ndr->depth--;
 278 }
 279
 280 static enum ndr_err_code ndr_push_dssetup_DsRoleOp(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsRoleOp r)
 281 {
 282         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 283         return NDR_ERR_SUCCESS;
 284 }
 285
 286 static enum ndr_err_code ndr_pull_dssetup_DsRoleOp(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsRoleOp *r)
 287 {
 288         uint16_t v;
 289         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 290         *r = v;
 291         return NDR_ERR_SUCCESS;
 292 }
 293
 294 _PUBLIC_ void ndr_print_dssetup_DsRoleOp(struct ndr_print *ndr, const char *name, enum dssetup_DsRoleOp r)
 295 {
 296         const char *val = NULL;
 297
 298         switch (r) {
 299                 case DS_ROLE_OP_IDLE: val = "DS_ROLE_OP_IDLE"; break;
 300                 case DS_ROLE_OP_ACTIVE: val = "DS_ROLE_OP_ACTIVE"; break;
 301                 case DS_ROLE_OP_NEEDS_REBOOT: val = "DS_ROLE_OP_NEEDS_REBOOT"; break;
 302         }
 303         ndr_print_enum(ndr, name, "ENUM", val, r);
 304 }
 305
 306 static enum ndr_err_code ndr_push_dssetup_DsRoleOpStatus(struct ndr_push *ndr, int ndr_flags, const struct dssetup_DsRoleOpStatus *r)
 307 {
 308         if (ndr_flags & NDR_SCALARS) {
 309                 NDR_CHECK(ndr_push_align(ndr, 2));
 310                 NDR_CHECK(ndr_push_dssetup_DsRoleOp(ndr, NDR_SCALARS, r->status));
 311         }
 312         if (ndr_flags & NDR_BUFFERS) {
 313         }
 314         return NDR_ERR_SUCCESS;
 315 }
 316
 317 static enum ndr_err_code ndr_pull_dssetup_DsRoleOpStatus(struct ndr_pull *ndr, int ndr_flags, struct dssetup_DsRoleOpStatus *r)
 318 {
 319         if (ndr_flags & NDR_SCALARS) {
 320                 NDR_CHECK(ndr_pull_align(ndr, 2));
 321                 NDR_CHECK(ndr_pull_dssetup_DsRoleOp(ndr, NDR_SCALARS, &r->status));
 322         }
 323         if (ndr_flags & NDR_BUFFERS) {
 324         }
 325         return NDR_ERR_SUCCESS;
 326 }
 327
 328 _PUBLIC_ void ndr_print_dssetup_DsRoleOpStatus(struct ndr_print *ndr, const char *name, const struct dssetup_DsRoleOpStatus *r)
 329 {
 330         ndr_print_struct(ndr, name, "dssetup_DsRoleOpStatus");
 331         ndr->depth++;
 332         ndr_print_dssetup_DsRoleOp(ndr, "status", r->status);
 333         ndr->depth--;
 334 }
 335
 336 static enum ndr_err_code ndr_push_dssetup_DsRoleInfoLevel(struct ndr_push *ndr, int ndr_flags, enum dssetup_DsRoleInfoLevel r)
 337 {
 338         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 339         return NDR_ERR_SUCCESS;
 340 }
 341
 342 static enum ndr_err_code ndr_pull_dssetup_DsRoleInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum dssetup_DsRoleInfoLevel *r)
 343 {
 344         uint16_t v;
 345         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 346         *r = v;
 347         return NDR_ERR_SUCCESS;
 348 }
 349
 350 _PUBLIC_ void ndr_print_dssetup_DsRoleInfoLevel(struct ndr_print *ndr, const char *name, enum dssetup_DsRoleInfoLevel r)
 351 {
 352         const char *val = NULL;
 353
 354         switch (r) {
 355                 case DS_ROLE_BASIC_INFORMATION: val = "DS_ROLE_BASIC_INFORMATION"; break;
 356                 case DS_ROLE_UPGRADE_STATUS: val = "DS_ROLE_UPGRADE_STATUS"; break;
 357                 case DS_ROLE_OP_STATUS: val = "DS_ROLE_OP_STATUS"; break;
 358         }
 359         ndr_print_enum(ndr, name, "ENUM", val, r);
 360 }
 361
 362 static enum ndr_err_code ndr_push_dssetup_DsRoleInfo(struct ndr_push *ndr, int ndr_flags, const union dssetup_DsRoleInfo *r)
 363 {
 364         if (ndr_flags & NDR_SCALARS) {
 365                 int level = ndr_push_get_switch_value(ndr, r);
 366                 NDR_CHECK(ndr_push_dssetup_DsRoleInfoLevel(ndr, NDR_SCALARS, level));
 367                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 368                 switch (level) {
 369                         case DS_ROLE_BASIC_INFORMATION: {
 370                                 NDR_CHECK(ndr_push_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_SCALARS, &r->basic));
 371                         break; }
 372
 373                         case DS_ROLE_UPGRADE_STATUS: {
 374                                 NDR_CHECK(ndr_push_dssetup_DsRoleUpgradeStatus(ndr, NDR_SCALARS, &r->upgrade));
 375                         break; }
 376
 377                         case DS_ROLE_OP_STATUS: {
 378                                 NDR_CHECK(ndr_push_dssetup_DsRoleOpStatus(ndr, NDR_SCALARS, &r->opstatus));
 379                         break; }
 380
 381                         default:
 382                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 383                 }
 384         }
 385         if (ndr_flags & NDR_BUFFERS) {
 386                 int level = ndr_push_get_switch_value(ndr, r);
 387                 switch (level) {
 388                         case DS_ROLE_BASIC_INFORMATION:
 389                                 NDR_CHECK(ndr_push_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_BUFFERS, &r->basic));
 390                         break;
 391
 392                         case DS_ROLE_UPGRADE_STATUS:
 393                         break;
 394
 395                         case DS_ROLE_OP_STATUS:
 396                         break;
 397
 398                         default:
 399                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 400                 }
 401         }
 402         return NDR_ERR_SUCCESS;
 403 }
 404
 405 static enum ndr_err_code ndr_pull_dssetup_DsRoleInfo(struct ndr_pull *ndr, int ndr_flags, union dssetup_DsRoleInfo *r)
 406 {
 407         int level;
 408         uint16_t _level;
 409         level = ndr_pull_get_switch_value(ndr, r);
 410         if (ndr_flags & NDR_SCALARS) {
 411                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 412                 if (_level != level) {
 413                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 414                 }
 415                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 416                 switch (level) {
 417                         case DS_ROLE_BASIC_INFORMATION: {
 418                                 NDR_CHECK(ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_SCALARS, &r->basic));
 419                         break; }
 420
 421                         case DS_ROLE_UPGRADE_STATUS: {
 422                                 NDR_CHECK(ndr_pull_dssetup_DsRoleUpgradeStatus(ndr, NDR_SCALARS, &r->upgrade));
 423                         break; }
 424
 425                         case DS_ROLE_OP_STATUS: {
 426                                 NDR_CHECK(ndr_pull_dssetup_DsRoleOpStatus(ndr, NDR_SCALARS, &r->opstatus));
 427                         break; }
 428
 429                         default:
 430                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 431                 }
 432         }
 433         if (ndr_flags & NDR_BUFFERS) {
 434                 switch (level) {
 435                         case DS_ROLE_BASIC_INFORMATION:
 436                                 NDR_CHECK(ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_BUFFERS, &r->basic));
 437                         break;
 438
 439                         case DS_ROLE_UPGRADE_STATUS:
 440                         break;
 441
 442                         case DS_ROLE_OP_STATUS:
 443                         break;
 444
 445                         default:
 446                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 447                 }
 448         }
 449         return NDR_ERR_SUCCESS;
 450 }
 451
 452 _PUBLIC_ void ndr_print_dssetup_DsRoleInfo(struct ndr_print *ndr, const char *name, const union dssetup_DsRoleInfo *r)
 453 {
 454         int level;
 455         level = ndr_print_get_switch_value(ndr, r);
 456         ndr_print_union(ndr, name, level, "dssetup_DsRoleInfo");
 457         switch (level) {
 458                 case DS_ROLE_BASIC_INFORMATION:
 459                         ndr_print_dssetup_DsRolePrimaryDomInfoBasic(ndr, "basic", &r->basic);
 460                 break;
 461
 462                 case DS_ROLE_UPGRADE_STATUS:
 463                         ndr_print_dssetup_DsRoleUpgradeStatus(ndr, "upgrade", &r->upgrade);
 464                 break;
 465
 466                 case DS_ROLE_OP_STATUS:
 467                         ndr_print_dssetup_DsRoleOpStatus(ndr, "opstatus", &r->opstatus);
 468                 break;
 469
 470                 default:
 471                         ndr_print_bad_level(ndr, name, level);
 472         }
 473 }
 474
 475 static enum ndr_err_code ndr_push_dssetup_DsRoleGetPrimaryDomainInformation(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 476 {
 477         if (flags & NDR_IN) {
 478                 NDR_CHECK(ndr_push_dssetup_DsRoleInfoLevel(ndr, NDR_SCALARS, r->in.level));
 479         }
 480         if (flags & NDR_OUT) {
 481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
 482                 if (r->out.info) {
 483                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
 484                         NDR_CHECK(ndr_push_dssetup_DsRoleInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 485                 }
 486                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 487         }
 488         return NDR_ERR_SUCCESS;
 489 }
 490
 491 static enum ndr_err_code ndr_pull_dssetup_DsRoleGetPrimaryDomainInformation(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 492 {
 493         uint32_t _ptr_info;
 494         TALLOC_CTX *_mem_save_info_0;
 495         if (flags & NDR_IN) {
 496                 ZERO_STRUCT(r->out);
 497
 498                 NDR_CHECK(ndr_pull_dssetup_DsRoleInfoLevel(ndr, NDR_SCALARS, &r->in.level));
 499         }
 500         if (flags & NDR_OUT) {
 501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 502                 if (_ptr_info) {
 503                         NDR_PULL_ALLOC(ndr, r->out.info);
 504                 } else {
 505                         r->out.info = NULL;
 506                 }
 507                 if (r->out.info) {
 508                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 509                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
 510                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
 511                         NDR_CHECK(ndr_pull_dssetup_DsRoleInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 513                 }
 514                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 515         }
 516         return NDR_ERR_SUCCESS;
 517 }
 518
 519 _PUBLIC_ void ndr_print_dssetup_DsRoleGetPrimaryDomainInformation(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 520 {
 521         ndr_print_struct(ndr, name, "dssetup_DsRoleGetPrimaryDomainInformation");
 522         ndr->depth++;
 523         if (flags & NDR_SET_VALUES) {
 524                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 525         }
 526         if (flags & NDR_IN) {
 527                 ndr_print_struct(ndr, "in", "dssetup_DsRoleGetPrimaryDomainInformation");
 528                 ndr->depth++;
 529                 ndr_print_dssetup_DsRoleInfoLevel(ndr, "level", r->in.level);
 530                 ndr->depth--;
 531         }
 532         if (flags & NDR_OUT) {
 533                 ndr_print_struct(ndr, "out", "dssetup_DsRoleGetPrimaryDomainInformation");
 534                 ndr->depth++;
 535                 ndr_print_ptr(ndr, "info", r->out.info);
 536                 ndr->depth++;
 537                 if (r->out.info) {
 538                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
 539                         ndr_print_dssetup_DsRoleInfo(ndr, "info", r->out.info);
 540                 }
 541                 ndr->depth--;
 542                 ndr_print_WERROR(ndr, "result", r->out.result);
 543                 ndr->depth--;
 544         }
 545         ndr->depth--;
 546 }
 547
 548 static enum ndr_err_code ndr_push_dssetup_DsRoleDnsNameToFlatName(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDnsNameToFlatName *r)
 549 {
 550         if (flags & NDR_IN) {
 551         }
 552         if (flags & NDR_OUT) {
 553                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 554         }
 555         return NDR_ERR_SUCCESS;
 556 }
 557
 558 static enum ndr_err_code ndr_pull_dssetup_DsRoleDnsNameToFlatName(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDnsNameToFlatName *r)
 559 {
 560         if (flags & NDR_IN) {
 561         }
 562         if (flags & NDR_OUT) {
 563                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 564         }
 565         return NDR_ERR_SUCCESS;
 566 }
 567
 568 _PUBLIC_ void ndr_print_dssetup_DsRoleDnsNameToFlatName(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDnsNameToFlatName *r)
 569 {
 570         ndr_print_struct(ndr, name, "dssetup_DsRoleDnsNameToFlatName");
 571         ndr->depth++;
 572         if (flags & NDR_SET_VALUES) {
 573                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 574         }
 575         if (flags & NDR_IN) {
 576                 ndr_print_struct(ndr, "in", "dssetup_DsRoleDnsNameToFlatName");
 577                 ndr->depth++;
 578                 ndr->depth--;
 579         }
 580         if (flags & NDR_OUT) {
 581                 ndr_print_struct(ndr, "out", "dssetup_DsRoleDnsNameToFlatName");
 582                 ndr->depth++;
 583                 ndr_print_WERROR(ndr, "result", r->out.result);
 584                 ndr->depth--;
 585         }
 586         ndr->depth--;
 587 }
 588
 589 static enum ndr_err_code ndr_push_dssetup_DsRoleDcAsDc(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDcAsDc *r)
 590 {
 591         if (flags & NDR_IN) {
 592         }
 593         if (flags & NDR_OUT) {
 594                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 595         }
 596         return NDR_ERR_SUCCESS;
 597 }
 598
 599 static enum ndr_err_code ndr_pull_dssetup_DsRoleDcAsDc(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDcAsDc *r)
 600 {
 601         if (flags & NDR_IN) {
 602         }
 603         if (flags & NDR_OUT) {
 604                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 605         }
 606         return NDR_ERR_SUCCESS;
 607 }
 608
 609 _PUBLIC_ void ndr_print_dssetup_DsRoleDcAsDc(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDcAsDc *r)
 610 {
 611         ndr_print_struct(ndr, name, "dssetup_DsRoleDcAsDc");
 612         ndr->depth++;
 613         if (flags & NDR_SET_VALUES) {
 614                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 615         }
 616         if (flags & NDR_IN) {
 617                 ndr_print_struct(ndr, "in", "dssetup_DsRoleDcAsDc");
 618                 ndr->depth++;
 619                 ndr->depth--;
 620         }
 621         if (flags & NDR_OUT) {
 622                 ndr_print_struct(ndr, "out", "dssetup_DsRoleDcAsDc");
 623                 ndr->depth++;
 624                 ndr_print_WERROR(ndr, "result", r->out.result);
 625                 ndr->depth--;
 626         }
 627         ndr->depth--;
 628 }
 629
 630 static enum ndr_err_code ndr_push_dssetup_DsRoleDcAsReplica(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDcAsReplica *r)
 631 {
 632         if (flags & NDR_IN) {
 633         }
 634         if (flags & NDR_OUT) {
 635                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 636         }
 637         return NDR_ERR_SUCCESS;
 638 }
 639
 640 static enum ndr_err_code ndr_pull_dssetup_DsRoleDcAsReplica(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDcAsReplica *r)
 641 {
 642         if (flags & NDR_IN) {
 643         }
 644         if (flags & NDR_OUT) {
 645                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 646         }
 647         return NDR_ERR_SUCCESS;
 648 }
 649
 650 _PUBLIC_ void ndr_print_dssetup_DsRoleDcAsReplica(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDcAsReplica *r)
 651 {
 652         ndr_print_struct(ndr, name, "dssetup_DsRoleDcAsReplica");
 653         ndr->depth++;
 654         if (flags & NDR_SET_VALUES) {
 655                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 656         }
 657         if (flags & NDR_IN) {
 658                 ndr_print_struct(ndr, "in", "dssetup_DsRoleDcAsReplica");
 659                 ndr->depth++;
 660                 ndr->depth--;
 661         }
 662         if (flags & NDR_OUT) {
 663                 ndr_print_struct(ndr, "out", "dssetup_DsRoleDcAsReplica");
 664                 ndr->depth++;
 665                 ndr_print_WERROR(ndr, "result", r->out.result);
 666                 ndr->depth--;
 667         }
 668         ndr->depth--;
 669 }
 670
 671 static enum ndr_err_code ndr_push_dssetup_DsRoleDemoteDc(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDemoteDc *r)
 672 {
 673         if (flags & NDR_IN) {
 674         }
 675         if (flags & NDR_OUT) {
 676                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 677         }
 678         return NDR_ERR_SUCCESS;
 679 }
 680
 681 static enum ndr_err_code ndr_pull_dssetup_DsRoleDemoteDc(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDemoteDc *r)
 682 {
 683         if (flags & NDR_IN) {
 684         }
 685         if (flags & NDR_OUT) {
 686                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 687         }
 688         return NDR_ERR_SUCCESS;
 689 }
 690
 691 _PUBLIC_ void ndr_print_dssetup_DsRoleDemoteDc(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDemoteDc *r)
 692 {
 693         ndr_print_struct(ndr, name, "dssetup_DsRoleDemoteDc");
 694         ndr->depth++;
 695         if (flags & NDR_SET_VALUES) {
 696                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 697         }
 698         if (flags & NDR_IN) {
 699                 ndr_print_struct(ndr, "in", "dssetup_DsRoleDemoteDc");
 700                 ndr->depth++;
 701                 ndr->depth--;
 702         }
 703         if (flags & NDR_OUT) {
 704                 ndr_print_struct(ndr, "out", "dssetup_DsRoleDemoteDc");
 705                 ndr->depth++;
 706                 ndr_print_WERROR(ndr, "result", r->out.result);
 707                 ndr->depth--;
 708         }
 709         ndr->depth--;
 710 }
 711
 712 static enum ndr_err_code ndr_push_dssetup_DsRoleGetDcOperationProgress(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleGetDcOperationProgress *r)
 713 {
 714         if (flags & NDR_IN) {
 715         }
 716         if (flags & NDR_OUT) {
 717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 718         }
 719         return NDR_ERR_SUCCESS;
 720 }
 721
 722 static enum ndr_err_code ndr_pull_dssetup_DsRoleGetDcOperationProgress(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleGetDcOperationProgress *r)
 723 {
 724         if (flags & NDR_IN) {
 725         }
 726         if (flags & NDR_OUT) {
 727                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 728         }
 729         return NDR_ERR_SUCCESS;
 730 }
 731
 732 _PUBLIC_ void ndr_print_dssetup_DsRoleGetDcOperationProgress(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleGetDcOperationProgress *r)
 733 {
 734         ndr_print_struct(ndr, name, "dssetup_DsRoleGetDcOperationProgress");
 735         ndr->depth++;
 736         if (flags & NDR_SET_VALUES) {
 737                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 738         }
 739         if (flags & NDR_IN) {
 740                 ndr_print_struct(ndr, "in", "dssetup_DsRoleGetDcOperationProgress");
 741                 ndr->depth++;
 742                 ndr->depth--;
 743         }
 744         if (flags & NDR_OUT) {
 745                 ndr_print_struct(ndr, "out", "dssetup_DsRoleGetDcOperationProgress");
 746                 ndr->depth++;
 747                 ndr_print_WERROR(ndr, "result", r->out.result);
 748                 ndr->depth--;
 749         }
 750         ndr->depth--;
 751 }
 752
 753 static enum ndr_err_code ndr_push_dssetup_DsRoleGetDcOperationResults(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleGetDcOperationResults *r)
 754 {
 755         if (flags & NDR_IN) {
 756         }
 757         if (flags & NDR_OUT) {
 758                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 759         }
 760         return NDR_ERR_SUCCESS;
 761 }
 762
 763 static enum ndr_err_code ndr_pull_dssetup_DsRoleGetDcOperationResults(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleGetDcOperationResults *r)
 764 {
 765         if (flags & NDR_IN) {
 766         }
 767         if (flags & NDR_OUT) {
 768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 769         }
 770         return NDR_ERR_SUCCESS;
 771 }
 772
 773 _PUBLIC_ void ndr_print_dssetup_DsRoleGetDcOperationResults(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleGetDcOperationResults *r)
 774 {
 775         ndr_print_struct(ndr, name, "dssetup_DsRoleGetDcOperationResults");
 776         ndr->depth++;
 777         if (flags & NDR_SET_VALUES) {
 778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 779         }
 780         if (flags & NDR_IN) {
 781                 ndr_print_struct(ndr, "in", "dssetup_DsRoleGetDcOperationResults");
 782                 ndr->depth++;
 783                 ndr->depth--;
 784         }
 785         if (flags & NDR_OUT) {
 786                 ndr_print_struct(ndr, "out", "dssetup_DsRoleGetDcOperationResults");
 787                 ndr->depth++;
 788                 ndr_print_WERROR(ndr, "result", r->out.result);
 789                 ndr->depth--;
 790         }
 791         ndr->depth--;
 792 }
 793
 794 static enum ndr_err_code ndr_push_dssetup_DsRoleCancel(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleCancel *r)
 795 {
 796         if (flags & NDR_IN) {
 797         }
 798         if (flags & NDR_OUT) {
 799                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 800         }
 801         return NDR_ERR_SUCCESS;
 802 }
 803
 804 static enum ndr_err_code ndr_pull_dssetup_DsRoleCancel(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleCancel *r)
 805 {
 806         if (flags & NDR_IN) {
 807         }
 808         if (flags & NDR_OUT) {
 809                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 810         }
 811         return NDR_ERR_SUCCESS;
 812 }
 813
 814 _PUBLIC_ void ndr_print_dssetup_DsRoleCancel(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleCancel *r)
 815 {
 816         ndr_print_struct(ndr, name, "dssetup_DsRoleCancel");
 817         ndr->depth++;
 818         if (flags & NDR_SET_VALUES) {
 819                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 820         }
 821         if (flags & NDR_IN) {
 822                 ndr_print_struct(ndr, "in", "dssetup_DsRoleCancel");
 823                 ndr->depth++;
 824                 ndr->depth--;
 825         }
 826         if (flags & NDR_OUT) {
 827                 ndr_print_struct(ndr, "out", "dssetup_DsRoleCancel");
 828                 ndr->depth++;
 829                 ndr_print_WERROR(ndr, "result", r->out.result);
 830                 ndr->depth--;
 831         }
 832         ndr->depth--;
 833 }
 834
 835 static enum ndr_err_code ndr_push_dssetup_DsRoleServerSaveStateForUpgrade(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleServerSaveStateForUpgrade *r)
 836 {
 837         if (flags & NDR_IN) {
 838         }
 839         if (flags & NDR_OUT) {
 840                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 841         }
 842         return NDR_ERR_SUCCESS;
 843 }
 844
 845 static enum ndr_err_code ndr_pull_dssetup_DsRoleServerSaveStateForUpgrade(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleServerSaveStateForUpgrade *r)
 846 {
 847         if (flags & NDR_IN) {
 848         }
 849         if (flags & NDR_OUT) {
 850                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 851         }
 852         return NDR_ERR_SUCCESS;
 853 }
 854
 855 _PUBLIC_ void ndr_print_dssetup_DsRoleServerSaveStateForUpgrade(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleServerSaveStateForUpgrade *r)
 856 {
 857         ndr_print_struct(ndr, name, "dssetup_DsRoleServerSaveStateForUpgrade");
 858         ndr->depth++;
 859         if (flags & NDR_SET_VALUES) {
 860                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 861         }
 862         if (flags & NDR_IN) {
 863                 ndr_print_struct(ndr, "in", "dssetup_DsRoleServerSaveStateForUpgrade");
 864                 ndr->depth++;
 865                 ndr->depth--;
 866         }
 867         if (flags & NDR_OUT) {
 868                 ndr_print_struct(ndr, "out", "dssetup_DsRoleServerSaveStateForUpgrade");
 869                 ndr->depth++;
 870                 ndr_print_WERROR(ndr, "result", r->out.result);
 871                 ndr->depth--;
 872         }
 873         ndr->depth--;
 874 }
 875
 876 static enum ndr_err_code ndr_push_dssetup_DsRoleUpgradeDownlevelServer(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleUpgradeDownlevelServer *r)
 877 {
 878         if (flags & NDR_IN) {
 879         }
 880         if (flags & NDR_OUT) {
 881                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 882         }
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 static enum ndr_err_code ndr_pull_dssetup_DsRoleUpgradeDownlevelServer(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleUpgradeDownlevelServer *r)
 887 {
 888         if (flags & NDR_IN) {
 889         }
 890         if (flags & NDR_OUT) {
 891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 892         }
 893         return NDR_ERR_SUCCESS;
 894 }
 895
 896 _PUBLIC_ void ndr_print_dssetup_DsRoleUpgradeDownlevelServer(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleUpgradeDownlevelServer *r)
 897 {
 898         ndr_print_struct(ndr, name, "dssetup_DsRoleUpgradeDownlevelServer");
 899         ndr->depth++;
 900         if (flags & NDR_SET_VALUES) {
 901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 902         }
 903         if (flags & NDR_IN) {
 904                 ndr_print_struct(ndr, "in", "dssetup_DsRoleUpgradeDownlevelServer");
 905                 ndr->depth++;
 906                 ndr->depth--;
 907         }
 908         if (flags & NDR_OUT) {
 909                 ndr_print_struct(ndr, "out", "dssetup_DsRoleUpgradeDownlevelServer");
 910                 ndr->depth++;
 911                 ndr_print_WERROR(ndr, "result", r->out.result);
 912                 ndr->depth--;
 913         }
 914         ndr->depth--;
 915 }
 916
 917 static enum ndr_err_code ndr_push_dssetup_DsRoleAbortDownlevelServerUpgrade(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
 918 {
 919         if (flags & NDR_IN) {
 920         }
 921         if (flags & NDR_OUT) {
 922                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 923         }
 924         return NDR_ERR_SUCCESS;
 925 }
 926
 927 static enum ndr_err_code ndr_pull_dssetup_DsRoleAbortDownlevelServerUpgrade(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
 928 {
 929         if (flags & NDR_IN) {
 930         }
 931         if (flags & NDR_OUT) {
 932                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 933         }
 934         return NDR_ERR_SUCCESS;
 935 }
 936
 937 _PUBLIC_ void ndr_print_dssetup_DsRoleAbortDownlevelServerUpgrade(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
 938 {
 939         ndr_print_struct(ndr, name, "dssetup_DsRoleAbortDownlevelServerUpgrade");
 940         ndr->depth++;
 941         if (flags & NDR_SET_VALUES) {
 942                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 943         }
 944         if (flags & NDR_IN) {
 945                 ndr_print_struct(ndr, "in", "dssetup_DsRoleAbortDownlevelServerUpgrade");
 946                 ndr->depth++;
 947                 ndr->depth--;
 948         }
 949         if (flags & NDR_OUT) {
 950                 ndr_print_struct(ndr, "out", "dssetup_DsRoleAbortDownlevelServerUpgrade");
 951                 ndr->depth++;
 952                 ndr_print_WERROR(ndr, "result", r->out.result);
 953                 ndr->depth--;
 954         }
 955         ndr->depth--;
 956 }
 957
 958 static const struct ndr_interface_call dssetup_calls[] = {
 959         {
 960                 "dssetup_DsRoleGetPrimaryDomainInformation",
 961                 sizeof(struct dssetup_DsRoleGetPrimaryDomainInformation),
 962                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleGetPrimaryDomainInformation,
 963                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleGetPrimaryDomainInformation,
 964                 (ndr_print_function_t) ndr_print_dssetup_DsRoleGetPrimaryDomainInformation,
 965                 false,
 966         },
 967         {
 968                 "dssetup_DsRoleDnsNameToFlatName",
 969                 sizeof(struct dssetup_DsRoleDnsNameToFlatName),
 970                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDnsNameToFlatName,
 971                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDnsNameToFlatName,
 972                 (ndr_print_function_t) ndr_print_dssetup_DsRoleDnsNameToFlatName,
 973                 false,
 974         },
 975         {
 976                 "dssetup_DsRoleDcAsDc",
 977                 sizeof(struct dssetup_DsRoleDcAsDc),
 978                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDcAsDc,
 979                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDcAsDc,
 980                 (ndr_print_function_t) ndr_print_dssetup_DsRoleDcAsDc,
 981                 false,
 982         },
 983         {
 984                 "dssetup_DsRoleDcAsReplica",
 985                 sizeof(struct dssetup_DsRoleDcAsReplica),
 986                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDcAsReplica,
 987                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDcAsReplica,
 988                 (ndr_print_function_t) ndr_print_dssetup_DsRoleDcAsReplica,
 989                 false,
 990         },
 991         {
 992                 "dssetup_DsRoleDemoteDc",
 993                 sizeof(struct dssetup_DsRoleDemoteDc),
 994                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDemoteDc,
 995                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDemoteDc,
 996                 (ndr_print_function_t) ndr_print_dssetup_DsRoleDemoteDc,
 997                 false,
 998         },
 999         {
1000                 "dssetup_DsRoleGetDcOperationProgress",
1001                 sizeof(struct dssetup_DsRoleGetDcOperationProgress),
1002                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleGetDcOperationProgress,
1003                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleGetDcOperationProgress,
1004                 (ndr_print_function_t) ndr_print_dssetup_DsRoleGetDcOperationProgress,
1005                 false,
1006         },
1007         {
1008                 "dssetup_DsRoleGetDcOperationResults",
1009                 sizeof(struct dssetup_DsRoleGetDcOperationResults),
1010                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleGetDcOperationResults,
1011                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleGetDcOperationResults,
1012                 (ndr_print_function_t) ndr_print_dssetup_DsRoleGetDcOperationResults,
1013                 false,
1014         },
1015         {
1016                 "dssetup_DsRoleCancel",
1017                 sizeof(struct dssetup_DsRoleCancel),
1018                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleCancel,
1019                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleCancel,
1020                 (ndr_print_function_t) ndr_print_dssetup_DsRoleCancel,
1021                 false,
1022         },
1023         {
1024                 "dssetup_DsRoleServerSaveStateForUpgrade",
1025                 sizeof(struct dssetup_DsRoleServerSaveStateForUpgrade),
1026                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleServerSaveStateForUpgrade,
1027                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleServerSaveStateForUpgrade,
1028                 (ndr_print_function_t) ndr_print_dssetup_DsRoleServerSaveStateForUpgrade,
1029                 false,
1030         },
1031         {
1032                 "dssetup_DsRoleUpgradeDownlevelServer",
1033                 sizeof(struct dssetup_DsRoleUpgradeDownlevelServer),
1034                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleUpgradeDownlevelServer,
1035                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleUpgradeDownlevelServer,
1036                 (ndr_print_function_t) ndr_print_dssetup_DsRoleUpgradeDownlevelServer,
1037                 false,
1038         },
1039         {
1040                 "dssetup_DsRoleAbortDownlevelServerUpgrade",
1041                 sizeof(struct dssetup_DsRoleAbortDownlevelServerUpgrade),
1042                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleAbortDownlevelServerUpgrade,
1043                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleAbortDownlevelServerUpgrade,
1044                 (ndr_print_function_t) ndr_print_dssetup_DsRoleAbortDownlevelServerUpgrade,
1045                 false,
1046         },
1047         { NULL, 0, NULL, NULL, NULL, false }
1048 };
1049
1050 static const char * const dssetup_endpoint_strings[] = {
1051         "ncacn_np:[\\pipe\\lsarpc]",
1052         "ncacn_np:[\\pipe\\lsass]",
1053         "ncacn_ip_tcp:",
1054         "ncalrpc:",
1055 };
1056
1057 static const struct ndr_interface_string_array dssetup_endpoints = {
1058         .count  = 4,
1059         .names  = dssetup_endpoint_strings
1060 };
1061
1062 static const char * const dssetup_authservice_strings[] = {
1063         "host",
1064 };
1065
1066 static const struct ndr_interface_string_array dssetup_authservices = {
1067         .count  = 1,
1068         .names  = dssetup_authservice_strings
1069 };
1070
1071
1072 const struct ndr_interface_table ndr_table_dssetup = {
1073         .name           = "dssetup",
1074         .syntax_id      = {
1075                 {0x3919286a,0xb10c,0x11d0,{0x9b,0xa8},{0x00,0xc0,0x4f,0xd9,0x2e,0xf5}},
1076                 NDR_DSSETUP_VERSION
1077         },
1078         .helpstring     = NDR_DSSETUP_HELPSTRING,
1079         .num_calls      = 11,
1080         .calls          = dssetup_calls,
1081         .endpoints      = &dssetup_endpoints,
1082         .authservices   = &dssetup_authservices
1083 };
1084