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_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_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, 4));
  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_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
  75                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  76                         NDR_CHECK(ndr_push_uint32(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_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain, CH_UTF16)));
  81                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  82                         NDR_CHECK(ndr_push_uint32(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_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->forest, CH_UTF16)));
  87                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  88                         NDR_CHECK(ndr_push_uint32(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, 4));
 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_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_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_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_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_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_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_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_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                 switch (level) {
 368                         case DS_ROLE_BASIC_INFORMATION: {
 369                                 NDR_CHECK(ndr_push_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_SCALARS, &r->basic));
 370                         break; }
 371
 372                         case DS_ROLE_UPGRADE_STATUS: {
 373                                 NDR_CHECK(ndr_push_dssetup_DsRoleUpgradeStatus(ndr, NDR_SCALARS, &r->upgrade));
 374                         break; }
 375
 376                         case DS_ROLE_OP_STATUS: {
 377                                 NDR_CHECK(ndr_push_dssetup_DsRoleOpStatus(ndr, NDR_SCALARS, &r->opstatus));
 378                         break; }
 379
 380                         default:
 381                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 382                 }
 383         }
 384         if (ndr_flags & NDR_BUFFERS) {
 385                 int level = ndr_push_get_switch_value(ndr, r);
 386                 switch (level) {
 387                         case DS_ROLE_BASIC_INFORMATION:
 388                                 NDR_CHECK(ndr_push_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_BUFFERS, &r->basic));
 389                         break;
 390
 391                         case DS_ROLE_UPGRADE_STATUS:
 392                         break;
 393
 394                         case DS_ROLE_OP_STATUS:
 395                         break;
 396
 397                         default:
 398                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 399                 }
 400         }
 401         return NDR_ERR_SUCCESS;
 402 }
 403
 404 static enum ndr_err_code ndr_pull_dssetup_DsRoleInfo(struct ndr_pull *ndr, int ndr_flags, union dssetup_DsRoleInfo *r)
 405 {
 406         int level;
 407         uint16_t _level;
 408         level = ndr_pull_get_switch_value(ndr, r);
 409         if (ndr_flags & NDR_SCALARS) {
 410                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 411                 if (_level != level) {
 412                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 413                 }
 414                 switch (level) {
 415                         case DS_ROLE_BASIC_INFORMATION: {
 416                                 NDR_CHECK(ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_SCALARS, &r->basic));
 417                         break; }
 418
 419                         case DS_ROLE_UPGRADE_STATUS: {
 420                                 NDR_CHECK(ndr_pull_dssetup_DsRoleUpgradeStatus(ndr, NDR_SCALARS, &r->upgrade));
 421                         break; }
 422
 423                         case DS_ROLE_OP_STATUS: {
 424                                 NDR_CHECK(ndr_pull_dssetup_DsRoleOpStatus(ndr, NDR_SCALARS, &r->opstatus));
 425                         break; }
 426
 427                         default:
 428                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 429                 }
 430         }
 431         if (ndr_flags & NDR_BUFFERS) {
 432                 switch (level) {
 433                         case DS_ROLE_BASIC_INFORMATION:
 434                                 NDR_CHECK(ndr_pull_dssetup_DsRolePrimaryDomInfoBasic(ndr, NDR_BUFFERS, &r->basic));
 435                         break;
 436
 437                         case DS_ROLE_UPGRADE_STATUS:
 438                         break;
 439
 440                         case DS_ROLE_OP_STATUS:
 441                         break;
 442
 443                         default:
 444                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 445                 }
 446         }
 447         return NDR_ERR_SUCCESS;
 448 }
 449
 450 _PUBLIC_ void ndr_print_dssetup_DsRoleInfo(struct ndr_print *ndr, const char *name, const union dssetup_DsRoleInfo *r)
 451 {
 452         int level;
 453         level = ndr_print_get_switch_value(ndr, r);
 454         ndr_print_union(ndr, name, level, "dssetup_DsRoleInfo");
 455         switch (level) {
 456                 case DS_ROLE_BASIC_INFORMATION:
 457                         ndr_print_dssetup_DsRolePrimaryDomInfoBasic(ndr, "basic", &r->basic);
 458                 break;
 459
 460                 case DS_ROLE_UPGRADE_STATUS:
 461                         ndr_print_dssetup_DsRoleUpgradeStatus(ndr, "upgrade", &r->upgrade);
 462                 break;
 463
 464                 case DS_ROLE_OP_STATUS:
 465                         ndr_print_dssetup_DsRoleOpStatus(ndr, "opstatus", &r->opstatus);
 466                 break;
 467
 468                 default:
 469                         ndr_print_bad_level(ndr, name, level);
 470         }
 471 }
 472
 473 static enum ndr_err_code ndr_push_dssetup_DsRoleGetPrimaryDomainInformation(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 474 {
 475         if (flags & NDR_IN) {
 476                 NDR_CHECK(ndr_push_dssetup_DsRoleInfoLevel(ndr, NDR_SCALARS, r->in.level));
 477         }
 478         if (flags & NDR_OUT) {
 479                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
 480                 if (r->out.info) {
 481                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
 482                         NDR_CHECK(ndr_push_dssetup_DsRoleInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 483                 }
 484                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 485         }
 486         return NDR_ERR_SUCCESS;
 487 }
 488
 489 static enum ndr_err_code ndr_pull_dssetup_DsRoleGetPrimaryDomainInformation(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 490 {
 491         uint32_t _ptr_info;
 492         TALLOC_CTX *_mem_save_info_0;
 493         if (flags & NDR_IN) {
 494                 ZERO_STRUCT(r->out);
 495
 496                 NDR_CHECK(ndr_pull_dssetup_DsRoleInfoLevel(ndr, NDR_SCALARS, &r->in.level));
 497         }
 498         if (flags & NDR_OUT) {
 499                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
 500                 if (_ptr_info) {
 501                         NDR_PULL_ALLOC(ndr, r->out.info);
 502                 } else {
 503                         r->out.info = NULL;
 504                 }
 505                 if (r->out.info) {
 506                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 507                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
 508                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
 509                         NDR_CHECK(ndr_pull_dssetup_DsRoleInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
 510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 511                 }
 512                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 513         }
 514         return NDR_ERR_SUCCESS;
 515 }
 516
 517 _PUBLIC_ void ndr_print_dssetup_DsRoleGetPrimaryDomainInformation(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 518 {
 519         ndr_print_struct(ndr, name, "dssetup_DsRoleGetPrimaryDomainInformation");
 520         ndr->depth++;
 521         if (flags & NDR_SET_VALUES) {
 522                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 523         }
 524         if (flags & NDR_IN) {
 525                 ndr_print_struct(ndr, "in", "dssetup_DsRoleGetPrimaryDomainInformation");
 526                 ndr->depth++;
 527                 ndr_print_dssetup_DsRoleInfoLevel(ndr, "level", r->in.level);
 528                 ndr->depth--;
 529         }
 530         if (flags & NDR_OUT) {
 531                 ndr_print_struct(ndr, "out", "dssetup_DsRoleGetPrimaryDomainInformation");
 532                 ndr->depth++;
 533                 ndr_print_ptr(ndr, "info", r->out.info);
 534                 ndr->depth++;
 535                 if (r->out.info) {
 536                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
 537                         ndr_print_dssetup_DsRoleInfo(ndr, "info", r->out.info);
 538                 }
 539                 ndr->depth--;
 540                 ndr_print_WERROR(ndr, "result", r->out.result);
 541                 ndr->depth--;
 542         }
 543         ndr->depth--;
 544 }
 545
 546 static enum ndr_err_code ndr_push_dssetup_DsRoleDnsNameToFlatName(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDnsNameToFlatName *r)
 547 {
 548         if (flags & NDR_IN) {
 549         }
 550         if (flags & NDR_OUT) {
 551                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 552         }
 553         return NDR_ERR_SUCCESS;
 554 }
 555
 556 static enum ndr_err_code ndr_pull_dssetup_DsRoleDnsNameToFlatName(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDnsNameToFlatName *r)
 557 {
 558         if (flags & NDR_IN) {
 559         }
 560         if (flags & NDR_OUT) {
 561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 562         }
 563         return NDR_ERR_SUCCESS;
 564 }
 565
 566 _PUBLIC_ void ndr_print_dssetup_DsRoleDnsNameToFlatName(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDnsNameToFlatName *r)
 567 {
 568         ndr_print_struct(ndr, name, "dssetup_DsRoleDnsNameToFlatName");
 569         ndr->depth++;
 570         if (flags & NDR_SET_VALUES) {
 571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 572         }
 573         if (flags & NDR_IN) {
 574                 ndr_print_struct(ndr, "in", "dssetup_DsRoleDnsNameToFlatName");
 575                 ndr->depth++;
 576                 ndr->depth--;
 577         }
 578         if (flags & NDR_OUT) {
 579                 ndr_print_struct(ndr, "out", "dssetup_DsRoleDnsNameToFlatName");
 580                 ndr->depth++;
 581                 ndr_print_WERROR(ndr, "result", r->out.result);
 582                 ndr->depth--;
 583         }
 584         ndr->depth--;
 585 }
 586
 587 static enum ndr_err_code ndr_push_dssetup_DsRoleDcAsDc(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDcAsDc *r)
 588 {
 589         if (flags & NDR_IN) {
 590         }
 591         if (flags & NDR_OUT) {
 592                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 593         }
 594         return NDR_ERR_SUCCESS;
 595 }
 596
 597 static enum ndr_err_code ndr_pull_dssetup_DsRoleDcAsDc(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDcAsDc *r)
 598 {
 599         if (flags & NDR_IN) {
 600         }
 601         if (flags & NDR_OUT) {
 602                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 603         }
 604         return NDR_ERR_SUCCESS;
 605 }
 606
 607 _PUBLIC_ void ndr_print_dssetup_DsRoleDcAsDc(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDcAsDc *r)
 608 {
 609         ndr_print_struct(ndr, name, "dssetup_DsRoleDcAsDc");
 610         ndr->depth++;
 611         if (flags & NDR_SET_VALUES) {
 612                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 613         }
 614         if (flags & NDR_IN) {
 615                 ndr_print_struct(ndr, "in", "dssetup_DsRoleDcAsDc");
 616                 ndr->depth++;
 617                 ndr->depth--;
 618         }
 619         if (flags & NDR_OUT) {
 620                 ndr_print_struct(ndr, "out", "dssetup_DsRoleDcAsDc");
 621                 ndr->depth++;
 622                 ndr_print_WERROR(ndr, "result", r->out.result);
 623                 ndr->depth--;
 624         }
 625         ndr->depth--;
 626 }
 627
 628 static enum ndr_err_code ndr_push_dssetup_DsRoleDcAsReplica(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDcAsReplica *r)
 629 {
 630         if (flags & NDR_IN) {
 631         }
 632         if (flags & NDR_OUT) {
 633                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 634         }
 635         return NDR_ERR_SUCCESS;
 636 }
 637
 638 static enum ndr_err_code ndr_pull_dssetup_DsRoleDcAsReplica(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDcAsReplica *r)
 639 {
 640         if (flags & NDR_IN) {
 641         }
 642         if (flags & NDR_OUT) {
 643                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 644         }
 645         return NDR_ERR_SUCCESS;
 646 }
 647
 648 _PUBLIC_ void ndr_print_dssetup_DsRoleDcAsReplica(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDcAsReplica *r)
 649 {
 650         ndr_print_struct(ndr, name, "dssetup_DsRoleDcAsReplica");
 651         ndr->depth++;
 652         if (flags & NDR_SET_VALUES) {
 653                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 654         }
 655         if (flags & NDR_IN) {
 656                 ndr_print_struct(ndr, "in", "dssetup_DsRoleDcAsReplica");
 657                 ndr->depth++;
 658                 ndr->depth--;
 659         }
 660         if (flags & NDR_OUT) {
 661                 ndr_print_struct(ndr, "out", "dssetup_DsRoleDcAsReplica");
 662                 ndr->depth++;
 663                 ndr_print_WERROR(ndr, "result", r->out.result);
 664                 ndr->depth--;
 665         }
 666         ndr->depth--;
 667 }
 668
 669 static enum ndr_err_code ndr_push_dssetup_DsRoleDemoteDc(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleDemoteDc *r)
 670 {
 671         if (flags & NDR_IN) {
 672         }
 673         if (flags & NDR_OUT) {
 674                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 675         }
 676         return NDR_ERR_SUCCESS;
 677 }
 678
 679 static enum ndr_err_code ndr_pull_dssetup_DsRoleDemoteDc(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleDemoteDc *r)
 680 {
 681         if (flags & NDR_IN) {
 682         }
 683         if (flags & NDR_OUT) {
 684                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 685         }
 686         return NDR_ERR_SUCCESS;
 687 }
 688
 689 _PUBLIC_ void ndr_print_dssetup_DsRoleDemoteDc(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleDemoteDc *r)
 690 {
 691         ndr_print_struct(ndr, name, "dssetup_DsRoleDemoteDc");
 692         ndr->depth++;
 693         if (flags & NDR_SET_VALUES) {
 694                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 695         }
 696         if (flags & NDR_IN) {
 697                 ndr_print_struct(ndr, "in", "dssetup_DsRoleDemoteDc");
 698                 ndr->depth++;
 699                 ndr->depth--;
 700         }
 701         if (flags & NDR_OUT) {
 702                 ndr_print_struct(ndr, "out", "dssetup_DsRoleDemoteDc");
 703                 ndr->depth++;
 704                 ndr_print_WERROR(ndr, "result", r->out.result);
 705                 ndr->depth--;
 706         }
 707         ndr->depth--;
 708 }
 709
 710 static enum ndr_err_code ndr_push_dssetup_DsRoleGetDcOperationProgress(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleGetDcOperationProgress *r)
 711 {
 712         if (flags & NDR_IN) {
 713         }
 714         if (flags & NDR_OUT) {
 715                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 716         }
 717         return NDR_ERR_SUCCESS;
 718 }
 719
 720 static enum ndr_err_code ndr_pull_dssetup_DsRoleGetDcOperationProgress(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleGetDcOperationProgress *r)
 721 {
 722         if (flags & NDR_IN) {
 723         }
 724         if (flags & NDR_OUT) {
 725                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 726         }
 727         return NDR_ERR_SUCCESS;
 728 }
 729
 730 _PUBLIC_ void ndr_print_dssetup_DsRoleGetDcOperationProgress(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleGetDcOperationProgress *r)
 731 {
 732         ndr_print_struct(ndr, name, "dssetup_DsRoleGetDcOperationProgress");
 733         ndr->depth++;
 734         if (flags & NDR_SET_VALUES) {
 735                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 736         }
 737         if (flags & NDR_IN) {
 738                 ndr_print_struct(ndr, "in", "dssetup_DsRoleGetDcOperationProgress");
 739                 ndr->depth++;
 740                 ndr->depth--;
 741         }
 742         if (flags & NDR_OUT) {
 743                 ndr_print_struct(ndr, "out", "dssetup_DsRoleGetDcOperationProgress");
 744                 ndr->depth++;
 745                 ndr_print_WERROR(ndr, "result", r->out.result);
 746                 ndr->depth--;
 747         }
 748         ndr->depth--;
 749 }
 750
 751 static enum ndr_err_code ndr_push_dssetup_DsRoleGetDcOperationResults(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleGetDcOperationResults *r)
 752 {
 753         if (flags & NDR_IN) {
 754         }
 755         if (flags & NDR_OUT) {
 756                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 757         }
 758         return NDR_ERR_SUCCESS;
 759 }
 760
 761 static enum ndr_err_code ndr_pull_dssetup_DsRoleGetDcOperationResults(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleGetDcOperationResults *r)
 762 {
 763         if (flags & NDR_IN) {
 764         }
 765         if (flags & NDR_OUT) {
 766                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 767         }
 768         return NDR_ERR_SUCCESS;
 769 }
 770
 771 _PUBLIC_ void ndr_print_dssetup_DsRoleGetDcOperationResults(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleGetDcOperationResults *r)
 772 {
 773         ndr_print_struct(ndr, name, "dssetup_DsRoleGetDcOperationResults");
 774         ndr->depth++;
 775         if (flags & NDR_SET_VALUES) {
 776                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 777         }
 778         if (flags & NDR_IN) {
 779                 ndr_print_struct(ndr, "in", "dssetup_DsRoleGetDcOperationResults");
 780                 ndr->depth++;
 781                 ndr->depth--;
 782         }
 783         if (flags & NDR_OUT) {
 784                 ndr_print_struct(ndr, "out", "dssetup_DsRoleGetDcOperationResults");
 785                 ndr->depth++;
 786                 ndr_print_WERROR(ndr, "result", r->out.result);
 787                 ndr->depth--;
 788         }
 789         ndr->depth--;
 790 }
 791
 792 static enum ndr_err_code ndr_push_dssetup_DsRoleCancel(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleCancel *r)
 793 {
 794         if (flags & NDR_IN) {
 795         }
 796         if (flags & NDR_OUT) {
 797                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 798         }
 799         return NDR_ERR_SUCCESS;
 800 }
 801
 802 static enum ndr_err_code ndr_pull_dssetup_DsRoleCancel(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleCancel *r)
 803 {
 804         if (flags & NDR_IN) {
 805         }
 806         if (flags & NDR_OUT) {
 807                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 808         }
 809         return NDR_ERR_SUCCESS;
 810 }
 811
 812 _PUBLIC_ void ndr_print_dssetup_DsRoleCancel(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleCancel *r)
 813 {
 814         ndr_print_struct(ndr, name, "dssetup_DsRoleCancel");
 815         ndr->depth++;
 816         if (flags & NDR_SET_VALUES) {
 817                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 818         }
 819         if (flags & NDR_IN) {
 820                 ndr_print_struct(ndr, "in", "dssetup_DsRoleCancel");
 821                 ndr->depth++;
 822                 ndr->depth--;
 823         }
 824         if (flags & NDR_OUT) {
 825                 ndr_print_struct(ndr, "out", "dssetup_DsRoleCancel");
 826                 ndr->depth++;
 827                 ndr_print_WERROR(ndr, "result", r->out.result);
 828                 ndr->depth--;
 829         }
 830         ndr->depth--;
 831 }
 832
 833 static enum ndr_err_code ndr_push_dssetup_DsRoleServerSaveStateForUpgrade(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleServerSaveStateForUpgrade *r)
 834 {
 835         if (flags & NDR_IN) {
 836         }
 837         if (flags & NDR_OUT) {
 838                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 839         }
 840         return NDR_ERR_SUCCESS;
 841 }
 842
 843 static enum ndr_err_code ndr_pull_dssetup_DsRoleServerSaveStateForUpgrade(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleServerSaveStateForUpgrade *r)
 844 {
 845         if (flags & NDR_IN) {
 846         }
 847         if (flags & NDR_OUT) {
 848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 849         }
 850         return NDR_ERR_SUCCESS;
 851 }
 852
 853 _PUBLIC_ void ndr_print_dssetup_DsRoleServerSaveStateForUpgrade(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleServerSaveStateForUpgrade *r)
 854 {
 855         ndr_print_struct(ndr, name, "dssetup_DsRoleServerSaveStateForUpgrade");
 856         ndr->depth++;
 857         if (flags & NDR_SET_VALUES) {
 858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 859         }
 860         if (flags & NDR_IN) {
 861                 ndr_print_struct(ndr, "in", "dssetup_DsRoleServerSaveStateForUpgrade");
 862                 ndr->depth++;
 863                 ndr->depth--;
 864         }
 865         if (flags & NDR_OUT) {
 866                 ndr_print_struct(ndr, "out", "dssetup_DsRoleServerSaveStateForUpgrade");
 867                 ndr->depth++;
 868                 ndr_print_WERROR(ndr, "result", r->out.result);
 869                 ndr->depth--;
 870         }
 871         ndr->depth--;
 872 }
 873
 874 static enum ndr_err_code ndr_push_dssetup_DsRoleUpgradeDownlevelServer(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleUpgradeDownlevelServer *r)
 875 {
 876         if (flags & NDR_IN) {
 877         }
 878         if (flags & NDR_OUT) {
 879                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 880         }
 881         return NDR_ERR_SUCCESS;
 882 }
 883
 884 static enum ndr_err_code ndr_pull_dssetup_DsRoleUpgradeDownlevelServer(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleUpgradeDownlevelServer *r)
 885 {
 886         if (flags & NDR_IN) {
 887         }
 888         if (flags & NDR_OUT) {
 889                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 890         }
 891         return NDR_ERR_SUCCESS;
 892 }
 893
 894 _PUBLIC_ void ndr_print_dssetup_DsRoleUpgradeDownlevelServer(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleUpgradeDownlevelServer *r)
 895 {
 896         ndr_print_struct(ndr, name, "dssetup_DsRoleUpgradeDownlevelServer");
 897         ndr->depth++;
 898         if (flags & NDR_SET_VALUES) {
 899                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 900         }
 901         if (flags & NDR_IN) {
 902                 ndr_print_struct(ndr, "in", "dssetup_DsRoleUpgradeDownlevelServer");
 903                 ndr->depth++;
 904                 ndr->depth--;
 905         }
 906         if (flags & NDR_OUT) {
 907                 ndr_print_struct(ndr, "out", "dssetup_DsRoleUpgradeDownlevelServer");
 908                 ndr->depth++;
 909                 ndr_print_WERROR(ndr, "result", r->out.result);
 910                 ndr->depth--;
 911         }
 912         ndr->depth--;
 913 }
 914
 915 static enum ndr_err_code ndr_push_dssetup_DsRoleAbortDownlevelServerUpgrade(struct ndr_push *ndr, int flags, const struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
 916 {
 917         if (flags & NDR_IN) {
 918         }
 919         if (flags & NDR_OUT) {
 920                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 921         }
 922         return NDR_ERR_SUCCESS;
 923 }
 924
 925 static enum ndr_err_code ndr_pull_dssetup_DsRoleAbortDownlevelServerUpgrade(struct ndr_pull *ndr, int flags, struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
 926 {
 927         if (flags & NDR_IN) {
 928         }
 929         if (flags & NDR_OUT) {
 930                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 931         }
 932         return NDR_ERR_SUCCESS;
 933 }
 934
 935 _PUBLIC_ void ndr_print_dssetup_DsRoleAbortDownlevelServerUpgrade(struct ndr_print *ndr, const char *name, int flags, const struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
 936 {
 937         ndr_print_struct(ndr, name, "dssetup_DsRoleAbortDownlevelServerUpgrade");
 938         ndr->depth++;
 939         if (flags & NDR_SET_VALUES) {
 940                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 941         }
 942         if (flags & NDR_IN) {
 943                 ndr_print_struct(ndr, "in", "dssetup_DsRoleAbortDownlevelServerUpgrade");
 944                 ndr->depth++;
 945                 ndr->depth--;
 946         }
 947         if (flags & NDR_OUT) {
 948                 ndr_print_struct(ndr, "out", "dssetup_DsRoleAbortDownlevelServerUpgrade");
 949                 ndr->depth++;
 950                 ndr_print_WERROR(ndr, "result", r->out.result);
 951                 ndr->depth--;
 952         }
 953         ndr->depth--;
 954 }
 955
 956 static const struct ndr_interface_call dssetup_calls[] = {
 957         {
 958                 "dssetup_DsRoleGetPrimaryDomainInformation",
 959                 sizeof(struct dssetup_DsRoleGetPrimaryDomainInformation),
 960                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleGetPrimaryDomainInformation,
 961                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleGetPrimaryDomainInformation,
 962                 (ndr_print_function_t) ndr_print_dssetup_DsRoleGetPrimaryDomainInformation,
 963                 false,
 964         },
 965         {
 966                 "dssetup_DsRoleDnsNameToFlatName",
 967                 sizeof(struct dssetup_DsRoleDnsNameToFlatName),
 968                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDnsNameToFlatName,
 969                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDnsNameToFlatName,
 970                 (ndr_print_function_t) ndr_print_dssetup_DsRoleDnsNameToFlatName,
 971                 false,
 972         },
 973         {
 974                 "dssetup_DsRoleDcAsDc",
 975                 sizeof(struct dssetup_DsRoleDcAsDc),
 976                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDcAsDc,
 977                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDcAsDc,
 978                 (ndr_print_function_t) ndr_print_dssetup_DsRoleDcAsDc,
 979                 false,
 980         },
 981         {
 982                 "dssetup_DsRoleDcAsReplica",
 983                 sizeof(struct dssetup_DsRoleDcAsReplica),
 984                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDcAsReplica,
 985                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDcAsReplica,
 986                 (ndr_print_function_t) ndr_print_dssetup_DsRoleDcAsReplica,
 987                 false,
 988         },
 989         {
 990                 "dssetup_DsRoleDemoteDc",
 991                 sizeof(struct dssetup_DsRoleDemoteDc),
 992                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleDemoteDc,
 993                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleDemoteDc,
 994                 (ndr_print_function_t) ndr_print_dssetup_DsRoleDemoteDc,
 995                 false,
 996         },
 997         {
 998                 "dssetup_DsRoleGetDcOperationProgress",
 999                 sizeof(struct dssetup_DsRoleGetDcOperationProgress),
1000                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleGetDcOperationProgress,
1001                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleGetDcOperationProgress,
1002                 (ndr_print_function_t) ndr_print_dssetup_DsRoleGetDcOperationProgress,
1003                 false,
1004         },
1005         {
1006                 "dssetup_DsRoleGetDcOperationResults",
1007                 sizeof(struct dssetup_DsRoleGetDcOperationResults),
1008                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleGetDcOperationResults,
1009                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleGetDcOperationResults,
1010                 (ndr_print_function_t) ndr_print_dssetup_DsRoleGetDcOperationResults,
1011                 false,
1012         },
1013         {
1014                 "dssetup_DsRoleCancel",
1015                 sizeof(struct dssetup_DsRoleCancel),
1016                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleCancel,
1017                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleCancel,
1018                 (ndr_print_function_t) ndr_print_dssetup_DsRoleCancel,
1019                 false,
1020         },
1021         {
1022                 "dssetup_DsRoleServerSaveStateForUpgrade",
1023                 sizeof(struct dssetup_DsRoleServerSaveStateForUpgrade),
1024                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleServerSaveStateForUpgrade,
1025                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleServerSaveStateForUpgrade,
1026                 (ndr_print_function_t) ndr_print_dssetup_DsRoleServerSaveStateForUpgrade,
1027                 false,
1028         },
1029         {
1030                 "dssetup_DsRoleUpgradeDownlevelServer",
1031                 sizeof(struct dssetup_DsRoleUpgradeDownlevelServer),
1032                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleUpgradeDownlevelServer,
1033                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleUpgradeDownlevelServer,
1034                 (ndr_print_function_t) ndr_print_dssetup_DsRoleUpgradeDownlevelServer,
1035                 false,
1036         },
1037         {
1038                 "dssetup_DsRoleAbortDownlevelServerUpgrade",
1039                 sizeof(struct dssetup_DsRoleAbortDownlevelServerUpgrade),
1040                 (ndr_push_flags_fn_t) ndr_push_dssetup_DsRoleAbortDownlevelServerUpgrade,
1041                 (ndr_pull_flags_fn_t) ndr_pull_dssetup_DsRoleAbortDownlevelServerUpgrade,
1042                 (ndr_print_function_t) ndr_print_dssetup_DsRoleAbortDownlevelServerUpgrade,
1043                 false,
1044         },
1045         { NULL, 0, NULL, NULL, NULL, false }
1046 };
1047
1048 static const char * const dssetup_endpoint_strings[] = {
1049         "ncacn_np:[\\pipe\\lsarpc]",
1050         "ncacn_np:[\\pipe\\lsass]",
1051         "ncacn_ip_tcp:",
1052         "ncalrpc:",
1053 };
1054
1055 static const struct ndr_interface_string_array dssetup_endpoints = {
1056         .count  = 4,
1057         .names  = dssetup_endpoint_strings
1058 };
1059
1060 static const char * const dssetup_authservice_strings[] = {
1061         "host",
1062 };
1063
1064 static const struct ndr_interface_string_array dssetup_authservices = {
1065         .count  = 1,
1066         .names  = dssetup_authservice_strings
1067 };
1068
1069
1070 const struct ndr_interface_table ndr_table_dssetup = {
1071         .name           = "dssetup",
1072         .syntax_id      = {
1073                 {0x3919286a,0xb10c,0x11d0,{0x9b,0xa8},{0x00,0xc0,0x4f,0xd9,0x2e,0xf5}},
1074                 NDR_DSSETUP_VERSION
1075         },
1076         .helpstring     = NDR_DSSETUP_HELPSTRING,
1077         .num_calls      = 11,
1078         .calls          = dssetup_calls,
1079         .endpoints      = &dssetup_endpoints,
1080         .authservices   = &dssetup_authservices
1081 };
1082