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