LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_dssetup.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 352 679 51.8 %
Date: 2021-09-23 10:06:22 Functions: 32 63 50.8 %

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

Generated by: LCOV version 1.13