LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_ODJ.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 949 2302 41.2 %
Date: 2021-09-23 10:06:22 Functions: 60 148 40.5 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_ODJ.h"
       5             : 
       6             : #include "librpc/gen_ndr/ndr_misc.h"
       7             : #include "librpc/gen_ndr/ndr_lsa.h"
       8             : #include "librpc/gen_ndr/ndr_netlogon.h"
       9             : #include "librpc/gen_ndr/ndr_security.h"
      10         876 : static enum ndr_err_code ndr_push_OP_BLOB(struct ndr_push *ndr, int ndr_flags, const struct OP_BLOB *r)
      11             : {
      12         876 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      13         876 :         if (ndr_flags & NDR_SCALARS) {
      14         438 :                 NDR_CHECK(ndr_push_align(ndr, 5));
      15         438 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbBlob));
      16             :                 {
      17         438 :                         uint32_t _flags_save_uint8 = ndr->flags;
      18         438 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
      19         438 :                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->pBlob));
      20         438 :                         ndr->flags = _flags_save_uint8;
      21             :                 }
      22         438 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
      23             :         }
      24         876 :         if (ndr_flags & NDR_BUFFERS) {
      25             :                 {
      26         438 :                         uint32_t _flags_save_uint8 = ndr->flags;
      27         438 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
      28         438 :                         if (r->pBlob) {
      29           0 :                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbBlob));
      30           0 :                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pBlob, r->cbBlob));
      31             :                         }
      32         438 :                         ndr->flags = _flags_save_uint8;
      33             :                 }
      34             :         }
      35         876 :         return NDR_ERR_SUCCESS;
      36             : }
      37             : 
      38          80 : static enum ndr_err_code ndr_pull_OP_BLOB(struct ndr_pull *ndr, int ndr_flags, struct OP_BLOB *r)
      39             : {
      40             :         uint32_t _ptr_pBlob;
      41          80 :         uint32_t size_pBlob_1 = 0;
      42          80 :         TALLOC_CTX *_mem_save_pBlob_0 = NULL;
      43          80 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      44          80 :         if (ndr_flags & NDR_SCALARS) {
      45          40 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
      46          40 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbBlob));
      47             :                 {
      48          40 :                         uint32_t _flags_save_uint8 = ndr->flags;
      49          40 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
      50          40 :                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pBlob));
      51          40 :                         if (_ptr_pBlob) {
      52           0 :                                 NDR_PULL_ALLOC(ndr, r->pBlob);
      53             :                         } else {
      54          40 :                                 r->pBlob = NULL;
      55             :                         }
      56          40 :                         ndr->flags = _flags_save_uint8;
      57             :                 }
      58          40 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
      59             :         }
      60          80 :         if (ndr_flags & NDR_BUFFERS) {
      61             :                 {
      62          40 :                         uint32_t _flags_save_uint8 = ndr->flags;
      63          40 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
      64          40 :                         if (r->pBlob) {
      65           0 :                                 _mem_save_pBlob_0 = NDR_PULL_GET_MEM_CTX(ndr);
      66           0 :                                 NDR_PULL_SET_MEM_CTX(ndr, r->pBlob, 0);
      67           0 :                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->pBlob));
      68           0 :                                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pBlob, &size_pBlob_1));
      69           0 :                                 NDR_PULL_ALLOC_N(ndr, r->pBlob, size_pBlob_1);
      70           0 :                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pBlob, size_pBlob_1));
      71           0 :                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pBlob_0, 0);
      72             :                         }
      73          40 :                         ndr->flags = _flags_save_uint8;
      74             :                 }
      75          40 :                 if (r->pBlob) {
      76           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->pBlob, r->cbBlob));
      77             :                 }
      78             :         }
      79          60 :         return NDR_ERR_SUCCESS;
      80             : }
      81             : 
      82          40 : _PUBLIC_ void ndr_print_OP_BLOB(struct ndr_print *ndr, const char *name, const struct OP_BLOB *r)
      83             : {
      84          40 :         ndr_print_struct(ndr, name, "OP_BLOB");
      85          40 :         if (r == NULL) { ndr_print_null(ndr); return; }
      86          40 :         ndr->depth++;
      87          40 :         ndr_print_uint32(ndr, "cbBlob", r->cbBlob);
      88             :         {
      89          40 :                 uint32_t _flags_save_uint8 = ndr->flags;
      90          40 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
      91          40 :                 ndr_print_ptr(ndr, "pBlob", r->pBlob);
      92          40 :                 ndr->depth++;
      93          40 :                 if (r->pBlob) {
      94           0 :                         ndr_print_array_uint8(ndr, "pBlob", r->pBlob, r->cbBlob);
      95             :                 }
      96          40 :                 ndr->depth--;
      97          40 :                 ndr->flags = _flags_save_uint8;
      98             :         }
      99          40 :         ndr->depth--;
     100             : }
     101             : 
     102        1080 : static enum ndr_err_code ndr_push_ODJ_POLICY_DNS_DOMAIN_INFO(struct ndr_push *ndr, int ndr_flags, const struct ODJ_POLICY_DNS_DOMAIN_INFO *r)
     103             : {
     104        1080 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     105        1080 :         if (ndr_flags & NDR_SCALARS) {
     106         540 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     107         540 :                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->Name));
     108         540 :                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->DnsDomainName));
     109         540 :                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->DnsForestName));
     110         540 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->DomainGuid));
     111         540 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Sid));
     112         540 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     113             :         }
     114        1080 :         if (ndr_flags & NDR_BUFFERS) {
     115         540 :                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->Name));
     116         540 :                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->DnsDomainName));
     117         540 :                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->DnsForestName));
     118         540 :                 if (r->Sid) {
     119         540 :                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->Sid));
     120             :                 }
     121             :         }
     122        1080 :         return NDR_ERR_SUCCESS;
     123             : }
     124             : 
     125          32 : static enum ndr_err_code ndr_pull_ODJ_POLICY_DNS_DOMAIN_INFO(struct ndr_pull *ndr, int ndr_flags, struct ODJ_POLICY_DNS_DOMAIN_INFO *r)
     126             : {
     127             :         uint32_t _ptr_Sid;
     128          32 :         TALLOC_CTX *_mem_save_Sid_0 = NULL;
     129          32 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     130          32 :         if (ndr_flags & NDR_SCALARS) {
     131          16 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     132          16 :                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->Name));
     133          16 :                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->DnsDomainName));
     134          16 :                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->DnsForestName));
     135          16 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->DomainGuid));
     136          16 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Sid));
     137          16 :                 if (_ptr_Sid) {
     138          16 :                         NDR_PULL_ALLOC(ndr, r->Sid);
     139             :                 } else {
     140           0 :                         r->Sid = NULL;
     141             :                 }
     142          16 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     143             :         }
     144          32 :         if (ndr_flags & NDR_BUFFERS) {
     145          16 :                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->Name));
     146          16 :                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->DnsDomainName));
     147          16 :                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->DnsForestName));
     148          16 :                 if (r->Sid) {
     149          16 :                         _mem_save_Sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
     150          16 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Sid, 0);
     151          16 :                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->Sid));
     152          16 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Sid_0, 0);
     153             :                 }
     154             :         }
     155          24 :         return NDR_ERR_SUCCESS;
     156             : }
     157             : 
     158          16 : _PUBLIC_ void ndr_print_ODJ_POLICY_DNS_DOMAIN_INFO(struct ndr_print *ndr, const char *name, const struct ODJ_POLICY_DNS_DOMAIN_INFO *r)
     159             : {
     160          16 :         ndr_print_struct(ndr, name, "ODJ_POLICY_DNS_DOMAIN_INFO");
     161          16 :         if (r == NULL) { ndr_print_null(ndr); return; }
     162          16 :         ndr->depth++;
     163          16 :         ndr_print_lsa_StringLarge(ndr, "Name", &r->Name);
     164          16 :         ndr_print_lsa_StringLarge(ndr, "DnsDomainName", &r->DnsDomainName);
     165          16 :         ndr_print_lsa_StringLarge(ndr, "DnsForestName", &r->DnsForestName);
     166          16 :         ndr_print_GUID(ndr, "DomainGuid", &r->DomainGuid);
     167          16 :         ndr_print_ptr(ndr, "Sid", r->Sid);
     168          16 :         ndr->depth++;
     169          16 :         if (r->Sid) {
     170          16 :                 ndr_print_dom_sid2(ndr, "Sid", r->Sid);
     171             :         }
     172          16 :         ndr->depth--;
     173          16 :         ndr->depth--;
     174             : }
     175             : 
     176         540 : static enum ndr_err_code ndr_push_ODJ_WIN7BLOB(struct ndr_push *ndr, int ndr_flags, const struct ODJ_WIN7BLOB *r)
     177             : {
     178         540 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     179         540 :         if (ndr_flags & NDR_SCALARS) {
     180         540 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     181         540 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpDomain));
     182         540 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpMachineName));
     183             :                 {
     184         540 :                         uint32_t _flags_save_uint16 = ndr->flags;
     185         540 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_IS_SECRET);
     186         540 :                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpMachinePassword));
     187         540 :                         ndr->flags = _flags_save_uint16;
     188             :                 }
     189         540 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0xffffffff));
     190         540 :                 NDR_CHECK(ndr_push_ODJ_POLICY_DNS_DOMAIN_INFO(ndr, NDR_SCALARS, &r->DnsDomainInfo));
     191         540 :                 NDR_CHECK(ndr_push_netr_DsRGetDCNameInfo(ndr, NDR_SCALARS, &r->DcInfo));
     192         540 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Options));
     193         540 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     194             :         }
     195         540 :         if (ndr_flags & NDR_BUFFERS) {
     196         540 :                 if (r->lpDomain) {
     197         540 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpDomain, CH_UTF16)));
     198         540 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     199         540 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpDomain, CH_UTF16)));
     200         540 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpDomain, ndr_charset_length(r->lpDomain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     201             :                 }
     202         540 :                 if (r->lpMachineName) {
     203         540 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpMachineName, CH_UTF16)));
     204         540 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     205         540 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpMachineName, CH_UTF16)));
     206         540 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpMachineName, ndr_charset_length(r->lpMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     207             :                 }
     208             :                 {
     209         540 :                         uint32_t _flags_save_uint16 = ndr->flags;
     210         540 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_IS_SECRET);
     211         540 :                         if (r->lpMachinePassword) {
     212         540 :                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpMachinePassword, CH_UTF16)));
     213         540 :                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     214         540 :                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpMachinePassword, CH_UTF16)));
     215         540 :                                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpMachinePassword, ndr_charset_length(r->lpMachinePassword, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     216             :                         }
     217         540 :                         ndr->flags = _flags_save_uint16;
     218             :                 }
     219         540 :                 NDR_CHECK(ndr_push_ODJ_POLICY_DNS_DOMAIN_INFO(ndr, NDR_BUFFERS, &r->DnsDomainInfo));
     220         540 :                 NDR_CHECK(ndr_push_netr_DsRGetDCNameInfo(ndr, NDR_BUFFERS, &r->DcInfo));
     221             :         }
     222         540 :         return NDR_ERR_SUCCESS;
     223             : }
     224             : 
     225          16 : static enum ndr_err_code ndr_pull_ODJ_WIN7BLOB(struct ndr_pull *ndr, int ndr_flags, struct ODJ_WIN7BLOB *r)
     226             : {
     227             :         uint32_t _ptr_lpDomain;
     228          16 :         uint32_t size_lpDomain_1 = 0;
     229          16 :         uint32_t length_lpDomain_1 = 0;
     230          16 :         TALLOC_CTX *_mem_save_lpDomain_0 = NULL;
     231             :         uint32_t _ptr_lpMachineName;
     232          16 :         uint32_t size_lpMachineName_1 = 0;
     233          16 :         uint32_t length_lpMachineName_1 = 0;
     234          16 :         TALLOC_CTX *_mem_save_lpMachineName_0 = NULL;
     235             :         uint32_t _ptr_lpMachinePassword;
     236          16 :         uint32_t size_lpMachinePassword_1 = 0;
     237          16 :         uint32_t length_lpMachinePassword_1 = 0;
     238          16 :         TALLOC_CTX *_mem_save_lpMachinePassword_0 = NULL;
     239          16 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     240          16 :         if (ndr_flags & NDR_SCALARS) {
     241          16 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     242          16 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpDomain));
     243          16 :                 if (_ptr_lpDomain) {
     244          16 :                         NDR_PULL_ALLOC(ndr, r->lpDomain);
     245             :                 } else {
     246           0 :                         r->lpDomain = NULL;
     247             :                 }
     248          16 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpMachineName));
     249          16 :                 if (_ptr_lpMachineName) {
     250          16 :                         NDR_PULL_ALLOC(ndr, r->lpMachineName);
     251             :                 } else {
     252           0 :                         r->lpMachineName = NULL;
     253             :                 }
     254             :                 {
     255          16 :                         uint32_t _flags_save_uint16 = ndr->flags;
     256          16 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_IS_SECRET);
     257          16 :                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpMachinePassword));
     258          16 :                         if (_ptr_lpMachinePassword) {
     259          16 :                                 NDR_PULL_ALLOC(ndr, r->lpMachinePassword);
     260             :                         } else {
     261           0 :                                 r->lpMachinePassword = NULL;
     262             :                         }
     263          16 :                         ndr->flags = _flags_save_uint16;
     264             :                 }
     265          16 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
     266          16 :                 NDR_CHECK(ndr_pull_ODJ_POLICY_DNS_DOMAIN_INFO(ndr, NDR_SCALARS, &r->DnsDomainInfo));
     267          16 :                 NDR_CHECK(ndr_pull_netr_DsRGetDCNameInfo(ndr, NDR_SCALARS, &r->DcInfo));
     268          16 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Options));
     269          16 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     270             :         }
     271          16 :         if (ndr_flags & NDR_BUFFERS) {
     272          16 :                 if (r->lpDomain) {
     273          16 :                         _mem_save_lpDomain_0 = NDR_PULL_GET_MEM_CTX(ndr);
     274          16 :                         NDR_PULL_SET_MEM_CTX(ndr, r->lpDomain, 0);
     275          16 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lpDomain));
     276          16 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lpDomain));
     277          16 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->lpDomain, &size_lpDomain_1));
     278          16 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->lpDomain, &length_lpDomain_1));
     279          16 :                         if (length_lpDomain_1 > size_lpDomain_1) {
     280           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpDomain_1, length_lpDomain_1);
     281             :                         }
     282          16 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpDomain_1, sizeof(uint16_t)));
     283          16 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpDomain, length_lpDomain_1, sizeof(uint16_t), CH_UTF16));
     284          16 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpDomain_0, 0);
     285             :                 }
     286          16 :                 if (r->lpMachineName) {
     287          16 :                         _mem_save_lpMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
     288          16 :                         NDR_PULL_SET_MEM_CTX(ndr, r->lpMachineName, 0);
     289          16 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lpMachineName));
     290          16 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lpMachineName));
     291          16 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->lpMachineName, &size_lpMachineName_1));
     292          16 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->lpMachineName, &length_lpMachineName_1));
     293          16 :                         if (length_lpMachineName_1 > size_lpMachineName_1) {
     294           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpMachineName_1, length_lpMachineName_1);
     295             :                         }
     296          16 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpMachineName_1, sizeof(uint16_t)));
     297          16 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpMachineName, length_lpMachineName_1, sizeof(uint16_t), CH_UTF16));
     298          16 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpMachineName_0, 0);
     299             :                 }
     300             :                 {
     301          16 :                         uint32_t _flags_save_uint16 = ndr->flags;
     302          16 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_IS_SECRET);
     303          16 :                         if (r->lpMachinePassword) {
     304          16 :                                 _mem_save_lpMachinePassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
     305          16 :                                 NDR_PULL_SET_MEM_CTX(ndr, r->lpMachinePassword, 0);
     306          16 :                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->lpMachinePassword));
     307          16 :                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->lpMachinePassword));
     308          16 :                                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->lpMachinePassword, &size_lpMachinePassword_1));
     309          16 :                                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->lpMachinePassword, &length_lpMachinePassword_1));
     310          16 :                                 if (length_lpMachinePassword_1 > size_lpMachinePassword_1) {
     311           0 :                                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpMachinePassword_1, length_lpMachinePassword_1);
     312             :                                 }
     313          16 :                                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpMachinePassword_1, sizeof(uint16_t)));
     314          16 :                                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpMachinePassword, length_lpMachinePassword_1, sizeof(uint16_t), CH_UTF16));
     315          16 :                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpMachinePassword_0, 0);
     316             :                         }
     317          16 :                         ndr->flags = _flags_save_uint16;
     318             :                 }
     319          16 :                 NDR_CHECK(ndr_pull_ODJ_POLICY_DNS_DOMAIN_INFO(ndr, NDR_BUFFERS, &r->DnsDomainInfo));
     320          16 :                 NDR_CHECK(ndr_pull_netr_DsRGetDCNameInfo(ndr, NDR_BUFFERS, &r->DcInfo));
     321             :         }
     322          12 :         return NDR_ERR_SUCCESS;
     323             : }
     324             : 
     325          16 : _PUBLIC_ void ndr_print_ODJ_WIN7BLOB(struct ndr_print *ndr, const char *name, const struct ODJ_WIN7BLOB *r)
     326             : {
     327          16 :         ndr_print_struct(ndr, name, "ODJ_WIN7BLOB");
     328          16 :         if (r == NULL) { ndr_print_null(ndr); return; }
     329          16 :         ndr->depth++;
     330          16 :         ndr_print_ptr(ndr, "lpDomain", r->lpDomain);
     331          16 :         ndr->depth++;
     332          16 :         if (r->lpDomain) {
     333          16 :                 ndr_print_string(ndr, "lpDomain", r->lpDomain);
     334             :         }
     335          16 :         ndr->depth--;
     336          16 :         ndr_print_ptr(ndr, "lpMachineName", r->lpMachineName);
     337          16 :         ndr->depth++;
     338          16 :         if (r->lpMachineName) {
     339          16 :                 ndr_print_string(ndr, "lpMachineName", r->lpMachineName);
     340             :         }
     341          16 :         ndr->depth--;
     342             :         {
     343          16 :                 uint32_t _flags_save_uint16 = ndr->flags;
     344          16 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_IS_SECRET);
     345          16 :                 ndr_print_ptr(ndr, "lpMachinePassword", r->lpMachinePassword);
     346          16 :                 ndr->depth++;
     347          16 :                 if (r->lpMachinePassword) {
     348          16 :                         ndr_print_string(ndr, "lpMachinePassword", r->lpMachinePassword);
     349             :                 }
     350          16 :                 ndr->depth--;
     351          16 :                 ndr->flags = _flags_save_uint16;
     352             :         }
     353          16 :         ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0xffffffff:r->_pad);
     354          16 :         ndr_print_ODJ_POLICY_DNS_DOMAIN_INFO(ndr, "DnsDomainInfo", &r->DnsDomainInfo);
     355          16 :         ndr_print_netr_DsRGetDCNameInfo(ndr, "DcInfo", &r->DcInfo);
     356          16 :         ndr_print_uint32(ndr, "Options", r->Options);
     357          16 :         ndr->depth--;
     358             : }
     359             : 
     360           0 : static enum ndr_err_code ndr_push_OP_JOINPROV2_PART(struct ndr_push *ndr, int ndr_flags, const struct OP_JOINPROV2_PART *r)
     361             : {
     362           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     363           0 :         if (ndr_flags & NDR_SCALARS) {
     364           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     365           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwFlags));
     366           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpNetbiosName));
     367           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpSiteName));
     368           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpPrimaryDNSDomain));
     369           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwReserved));
     370           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpReserved));
     371           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     372             :         }
     373           0 :         if (ndr_flags & NDR_BUFFERS) {
     374           0 :                 if (r->lpNetbiosName) {
     375           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpNetbiosName, CH_UTF16)));
     376           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     377           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpNetbiosName, CH_UTF16)));
     378           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpNetbiosName, ndr_charset_length(r->lpNetbiosName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     379             :                 }
     380           0 :                 if (r->lpSiteName) {
     381           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpSiteName, CH_UTF16)));
     382           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     383           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpSiteName, CH_UTF16)));
     384           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpSiteName, ndr_charset_length(r->lpSiteName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     385             :                 }
     386           0 :                 if (r->lpPrimaryDNSDomain) {
     387           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpPrimaryDNSDomain, CH_UTF16)));
     388           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     389           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpPrimaryDNSDomain, CH_UTF16)));
     390           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpPrimaryDNSDomain, ndr_charset_length(r->lpPrimaryDNSDomain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     391             :                 }
     392           0 :                 if (r->lpReserved) {
     393           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpReserved, CH_UTF16)));
     394           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     395           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpReserved, CH_UTF16)));
     396           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpReserved, ndr_charset_length(r->lpReserved, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     397             :                 }
     398             :         }
     399           0 :         return NDR_ERR_SUCCESS;
     400             : }
     401             : 
     402           0 : static enum ndr_err_code ndr_pull_OP_JOINPROV2_PART(struct ndr_pull *ndr, int ndr_flags, struct OP_JOINPROV2_PART *r)
     403             : {
     404             :         uint32_t _ptr_lpNetbiosName;
     405           0 :         uint32_t size_lpNetbiosName_1 = 0;
     406           0 :         uint32_t length_lpNetbiosName_1 = 0;
     407           0 :         TALLOC_CTX *_mem_save_lpNetbiosName_0 = NULL;
     408             :         uint32_t _ptr_lpSiteName;
     409           0 :         uint32_t size_lpSiteName_1 = 0;
     410           0 :         uint32_t length_lpSiteName_1 = 0;
     411           0 :         TALLOC_CTX *_mem_save_lpSiteName_0 = NULL;
     412             :         uint32_t _ptr_lpPrimaryDNSDomain;
     413           0 :         uint32_t size_lpPrimaryDNSDomain_1 = 0;
     414           0 :         uint32_t length_lpPrimaryDNSDomain_1 = 0;
     415           0 :         TALLOC_CTX *_mem_save_lpPrimaryDNSDomain_0 = NULL;
     416             :         uint32_t _ptr_lpReserved;
     417           0 :         uint32_t size_lpReserved_1 = 0;
     418           0 :         uint32_t length_lpReserved_1 = 0;
     419           0 :         TALLOC_CTX *_mem_save_lpReserved_0 = NULL;
     420           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     421           0 :         if (ndr_flags & NDR_SCALARS) {
     422           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     423           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwFlags));
     424           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpNetbiosName));
     425           0 :                 if (_ptr_lpNetbiosName) {
     426           0 :                         NDR_PULL_ALLOC(ndr, r->lpNetbiosName);
     427             :                 } else {
     428           0 :                         r->lpNetbiosName = NULL;
     429             :                 }
     430           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpSiteName));
     431           0 :                 if (_ptr_lpSiteName) {
     432           0 :                         NDR_PULL_ALLOC(ndr, r->lpSiteName);
     433             :                 } else {
     434           0 :                         r->lpSiteName = NULL;
     435             :                 }
     436           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpPrimaryDNSDomain));
     437           0 :                 if (_ptr_lpPrimaryDNSDomain) {
     438           0 :                         NDR_PULL_ALLOC(ndr, r->lpPrimaryDNSDomain);
     439             :                 } else {
     440           0 :                         r->lpPrimaryDNSDomain = NULL;
     441             :                 }
     442           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwReserved));
     443           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpReserved));
     444           0 :                 if (_ptr_lpReserved) {
     445           0 :                         NDR_PULL_ALLOC(ndr, r->lpReserved);
     446             :                 } else {
     447           0 :                         r->lpReserved = NULL;
     448             :                 }
     449           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     450             :         }
     451           0 :         if (ndr_flags & NDR_BUFFERS) {
     452           0 :                 if (r->lpNetbiosName) {
     453           0 :                         _mem_save_lpNetbiosName_0 = NDR_PULL_GET_MEM_CTX(ndr);
     454           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->lpNetbiosName, 0);
     455           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lpNetbiosName));
     456           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lpNetbiosName));
     457           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->lpNetbiosName, &size_lpNetbiosName_1));
     458           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->lpNetbiosName, &length_lpNetbiosName_1));
     459           0 :                         if (length_lpNetbiosName_1 > size_lpNetbiosName_1) {
     460           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpNetbiosName_1, length_lpNetbiosName_1);
     461             :                         }
     462           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpNetbiosName_1, sizeof(uint16_t)));
     463           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpNetbiosName, length_lpNetbiosName_1, sizeof(uint16_t), CH_UTF16));
     464           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpNetbiosName_0, 0);
     465             :                 }
     466           0 :                 if (r->lpSiteName) {
     467           0 :                         _mem_save_lpSiteName_0 = NDR_PULL_GET_MEM_CTX(ndr);
     468           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->lpSiteName, 0);
     469           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lpSiteName));
     470           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lpSiteName));
     471           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->lpSiteName, &size_lpSiteName_1));
     472           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->lpSiteName, &length_lpSiteName_1));
     473           0 :                         if (length_lpSiteName_1 > size_lpSiteName_1) {
     474           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpSiteName_1, length_lpSiteName_1);
     475             :                         }
     476           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpSiteName_1, sizeof(uint16_t)));
     477           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpSiteName, length_lpSiteName_1, sizeof(uint16_t), CH_UTF16));
     478           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpSiteName_0, 0);
     479             :                 }
     480           0 :                 if (r->lpPrimaryDNSDomain) {
     481           0 :                         _mem_save_lpPrimaryDNSDomain_0 = NDR_PULL_GET_MEM_CTX(ndr);
     482           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->lpPrimaryDNSDomain, 0);
     483           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lpPrimaryDNSDomain));
     484           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lpPrimaryDNSDomain));
     485           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->lpPrimaryDNSDomain, &size_lpPrimaryDNSDomain_1));
     486           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->lpPrimaryDNSDomain, &length_lpPrimaryDNSDomain_1));
     487           0 :                         if (length_lpPrimaryDNSDomain_1 > size_lpPrimaryDNSDomain_1) {
     488           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpPrimaryDNSDomain_1, length_lpPrimaryDNSDomain_1);
     489             :                         }
     490           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpPrimaryDNSDomain_1, sizeof(uint16_t)));
     491           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpPrimaryDNSDomain, length_lpPrimaryDNSDomain_1, sizeof(uint16_t), CH_UTF16));
     492           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpPrimaryDNSDomain_0, 0);
     493             :                 }
     494           0 :                 if (r->lpReserved) {
     495           0 :                         _mem_save_lpReserved_0 = NDR_PULL_GET_MEM_CTX(ndr);
     496           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->lpReserved, 0);
     497           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lpReserved));
     498           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lpReserved));
     499           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->lpReserved, &size_lpReserved_1));
     500           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->lpReserved, &length_lpReserved_1));
     501           0 :                         if (length_lpReserved_1 > size_lpReserved_1) {
     502           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpReserved_1, length_lpReserved_1);
     503             :                         }
     504           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpReserved_1, sizeof(uint16_t)));
     505           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpReserved, length_lpReserved_1, sizeof(uint16_t), CH_UTF16));
     506           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpReserved_0, 0);
     507             :                 }
     508             :         }
     509           0 :         return NDR_ERR_SUCCESS;
     510             : }
     511             : 
     512           0 : _PUBLIC_ void ndr_print_OP_JOINPROV2_PART(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV2_PART *r)
     513             : {
     514           0 :         ndr_print_struct(ndr, name, "OP_JOINPROV2_PART");
     515           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     516           0 :         ndr->depth++;
     517           0 :         ndr_print_uint32(ndr, "dwFlags", r->dwFlags);
     518           0 :         ndr_print_ptr(ndr, "lpNetbiosName", r->lpNetbiosName);
     519           0 :         ndr->depth++;
     520           0 :         if (r->lpNetbiosName) {
     521           0 :                 ndr_print_string(ndr, "lpNetbiosName", r->lpNetbiosName);
     522             :         }
     523           0 :         ndr->depth--;
     524           0 :         ndr_print_ptr(ndr, "lpSiteName", r->lpSiteName);
     525           0 :         ndr->depth++;
     526           0 :         if (r->lpSiteName) {
     527           0 :                 ndr_print_string(ndr, "lpSiteName", r->lpSiteName);
     528             :         }
     529           0 :         ndr->depth--;
     530           0 :         ndr_print_ptr(ndr, "lpPrimaryDNSDomain", r->lpPrimaryDNSDomain);
     531           0 :         ndr->depth++;
     532           0 :         if (r->lpPrimaryDNSDomain) {
     533           0 :                 ndr_print_string(ndr, "lpPrimaryDNSDomain", r->lpPrimaryDNSDomain);
     534             :         }
     535           0 :         ndr->depth--;
     536           0 :         ndr_print_uint32(ndr, "dwReserved", r->dwReserved);
     537           0 :         ndr_print_ptr(ndr, "lpReserved", r->lpReserved);
     538           0 :         ndr->depth++;
     539           0 :         if (r->lpReserved) {
     540           0 :                 ndr_print_string(ndr, "lpReserved", r->lpReserved);
     541             :         }
     542           0 :         ndr->depth--;
     543           0 :         ndr->depth--;
     544             : }
     545             : 
     546         510 : static enum ndr_err_code ndr_push_OP_JOINPROV3_PART(struct ndr_push *ndr, int ndr_flags, const struct OP_JOINPROV3_PART *r)
     547             : {
     548         510 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     549         510 :         if (ndr_flags & NDR_SCALARS) {
     550         510 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     551         510 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Rid));
     552         510 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpSid));
     553         510 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     554             :         }
     555         510 :         if (ndr_flags & NDR_BUFFERS) {
     556         510 :                 if (r->lpSid) {
     557         510 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpSid, CH_UTF16)));
     558         510 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     559         510 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpSid, CH_UTF16)));
     560         510 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpSid, ndr_charset_length(r->lpSid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     561             :                 }
     562             :         }
     563         510 :         return NDR_ERR_SUCCESS;
     564             : }
     565             : 
     566           8 : static enum ndr_err_code ndr_pull_OP_JOINPROV3_PART(struct ndr_pull *ndr, int ndr_flags, struct OP_JOINPROV3_PART *r)
     567             : {
     568             :         uint32_t _ptr_lpSid;
     569           8 :         uint32_t size_lpSid_1 = 0;
     570           8 :         uint32_t length_lpSid_1 = 0;
     571           8 :         TALLOC_CTX *_mem_save_lpSid_0 = NULL;
     572           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     573           8 :         if (ndr_flags & NDR_SCALARS) {
     574           8 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     575           8 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Rid));
     576           8 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpSid));
     577           8 :                 if (_ptr_lpSid) {
     578           8 :                         NDR_PULL_ALLOC(ndr, r->lpSid);
     579             :                 } else {
     580           0 :                         r->lpSid = NULL;
     581             :                 }
     582           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     583             :         }
     584           8 :         if (ndr_flags & NDR_BUFFERS) {
     585           8 :                 if (r->lpSid) {
     586           8 :                         _mem_save_lpSid_0 = NDR_PULL_GET_MEM_CTX(ndr);
     587           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->lpSid, 0);
     588           8 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lpSid));
     589           8 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lpSid));
     590           8 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->lpSid, &size_lpSid_1));
     591           8 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->lpSid, &length_lpSid_1));
     592           8 :                         if (length_lpSid_1 > size_lpSid_1) {
     593           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpSid_1, length_lpSid_1);
     594             :                         }
     595           8 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpSid_1, sizeof(uint16_t)));
     596           8 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpSid, length_lpSid_1, sizeof(uint16_t), CH_UTF16));
     597           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpSid_0, 0);
     598             :                 }
     599             :         }
     600           6 :         return NDR_ERR_SUCCESS;
     601             : }
     602             : 
     603           8 : _PUBLIC_ void ndr_print_OP_JOINPROV3_PART(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV3_PART *r)
     604             : {
     605           8 :         ndr_print_struct(ndr, name, "OP_JOINPROV3_PART");
     606           8 :         if (r == NULL) { ndr_print_null(ndr); return; }
     607           8 :         ndr->depth++;
     608           8 :         ndr_print_uint32(ndr, "Rid", r->Rid);
     609           8 :         ndr_print_ptr(ndr, "lpSid", r->lpSid);
     610           8 :         ndr->depth++;
     611           8 :         if (r->lpSid) {
     612           8 :                 ndr_print_string(ndr, "lpSid", r->lpSid);
     613             :         }
     614           8 :         ndr->depth--;
     615           8 :         ndr->depth--;
     616             : }
     617             : 
     618           0 : static enum ndr_err_code ndr_push_OP_POLICY_ELEMENT(struct ndr_push *ndr, int ndr_flags, const struct OP_POLICY_ELEMENT *r)
     619             : {
     620           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     621           0 :         if (ndr_flags & NDR_SCALARS) {
     622           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     623           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pKeyPath));
     624           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pValueName));
     625           0 :                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->ulValueType));
     626           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbValueData));
     627             :                 {
     628           0 :                         uint32_t _flags_save_uint8 = ndr->flags;
     629           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
     630           0 :                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->pValueData));
     631           0 :                         ndr->flags = _flags_save_uint8;
     632             :                 }
     633           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     634             :         }
     635           0 :         if (ndr_flags & NDR_BUFFERS) {
     636           0 :                 if (r->pKeyPath) {
     637           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pKeyPath, CH_UTF16)));
     638           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     639           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pKeyPath, CH_UTF16)));
     640           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->pKeyPath, ndr_charset_length(r->pKeyPath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     641             :                 }
     642           0 :                 if (r->pValueName) {
     643           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pValueName, CH_UTF16)));
     644           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     645           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pValueName, CH_UTF16)));
     646           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->pValueName, ndr_charset_length(r->pValueName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     647             :                 }
     648             :                 {
     649           0 :                         uint32_t _flags_save_uint8 = ndr->flags;
     650           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
     651           0 :                         if (r->pValueData) {
     652           0 :                                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbValueData));
     653           0 :                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pValueData, r->cbValueData));
     654             :                         }
     655           0 :                         ndr->flags = _flags_save_uint8;
     656             :                 }
     657             :         }
     658           0 :         return NDR_ERR_SUCCESS;
     659             : }
     660             : 
     661           0 : static enum ndr_err_code ndr_pull_OP_POLICY_ELEMENT(struct ndr_pull *ndr, int ndr_flags, struct OP_POLICY_ELEMENT *r)
     662             : {
     663             :         uint32_t _ptr_pKeyPath;
     664           0 :         uint32_t size_pKeyPath_1 = 0;
     665           0 :         uint32_t length_pKeyPath_1 = 0;
     666           0 :         TALLOC_CTX *_mem_save_pKeyPath_0 = NULL;
     667             :         uint32_t _ptr_pValueName;
     668           0 :         uint32_t size_pValueName_1 = 0;
     669           0 :         uint32_t length_pValueName_1 = 0;
     670           0 :         TALLOC_CTX *_mem_save_pValueName_0 = NULL;
     671             :         uint32_t _ptr_pValueData;
     672           0 :         uint32_t size_pValueData_1 = 0;
     673           0 :         TALLOC_CTX *_mem_save_pValueData_0 = NULL;
     674           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     675           0 :         if (ndr_flags & NDR_SCALARS) {
     676           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     677           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pKeyPath));
     678           0 :                 if (_ptr_pKeyPath) {
     679           0 :                         NDR_PULL_ALLOC(ndr, r->pKeyPath);
     680             :                 } else {
     681           0 :                         r->pKeyPath = NULL;
     682             :                 }
     683           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pValueName));
     684           0 :                 if (_ptr_pValueName) {
     685           0 :                         NDR_PULL_ALLOC(ndr, r->pValueName);
     686             :                 } else {
     687           0 :                         r->pValueName = NULL;
     688             :                 }
     689           0 :                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->ulValueType));
     690           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbValueData));
     691             :                 {
     692           0 :                         uint32_t _flags_save_uint8 = ndr->flags;
     693           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
     694           0 :                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pValueData));
     695           0 :                         if (_ptr_pValueData) {
     696           0 :                                 NDR_PULL_ALLOC(ndr, r->pValueData);
     697             :                         } else {
     698           0 :                                 r->pValueData = NULL;
     699             :                         }
     700           0 :                         ndr->flags = _flags_save_uint8;
     701             :                 }
     702           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     703             :         }
     704           0 :         if (ndr_flags & NDR_BUFFERS) {
     705           0 :                 if (r->pKeyPath) {
     706           0 :                         _mem_save_pKeyPath_0 = NDR_PULL_GET_MEM_CTX(ndr);
     707           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pKeyPath, 0);
     708           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pKeyPath));
     709           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->pKeyPath));
     710           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->pKeyPath, &size_pKeyPath_1));
     711           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->pKeyPath, &length_pKeyPath_1));
     712           0 :                         if (length_pKeyPath_1 > size_pKeyPath_1) {
     713           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pKeyPath_1, length_pKeyPath_1);
     714             :                         }
     715           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pKeyPath_1, sizeof(uint16_t)));
     716           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->pKeyPath, length_pKeyPath_1, sizeof(uint16_t), CH_UTF16));
     717           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pKeyPath_0, 0);
     718             :                 }
     719           0 :                 if (r->pValueName) {
     720           0 :                         _mem_save_pValueName_0 = NDR_PULL_GET_MEM_CTX(ndr);
     721           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pValueName, 0);
     722           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pValueName));
     723           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->pValueName));
     724           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->pValueName, &size_pValueName_1));
     725           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->pValueName, &length_pValueName_1));
     726           0 :                         if (length_pValueName_1 > size_pValueName_1) {
     727           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pValueName_1, length_pValueName_1);
     728             :                         }
     729           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pValueName_1, sizeof(uint16_t)));
     730           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->pValueName, length_pValueName_1, sizeof(uint16_t), CH_UTF16));
     731           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pValueName_0, 0);
     732             :                 }
     733             :                 {
     734           0 :                         uint32_t _flags_save_uint8 = ndr->flags;
     735           0 :                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
     736           0 :                         if (r->pValueData) {
     737           0 :                                 _mem_save_pValueData_0 = NDR_PULL_GET_MEM_CTX(ndr);
     738           0 :                                 NDR_PULL_SET_MEM_CTX(ndr, r->pValueData, 0);
     739           0 :                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->pValueData));
     740           0 :                                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pValueData, &size_pValueData_1));
     741           0 :                                 NDR_PULL_ALLOC_N(ndr, r->pValueData, size_pValueData_1);
     742           0 :                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pValueData, size_pValueData_1));
     743           0 :                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pValueData_0, 0);
     744             :                         }
     745           0 :                         ndr->flags = _flags_save_uint8;
     746             :                 }
     747           0 :                 if (r->pValueData) {
     748           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->pValueData, r->cbValueData));
     749             :                 }
     750             :         }
     751           0 :         return NDR_ERR_SUCCESS;
     752             : }
     753             : 
     754           0 : _PUBLIC_ void ndr_print_OP_POLICY_ELEMENT(struct ndr_print *ndr, const char *name, const struct OP_POLICY_ELEMENT *r)
     755             : {
     756           0 :         ndr_print_struct(ndr, name, "OP_POLICY_ELEMENT");
     757           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     758           0 :         ndr->depth++;
     759           0 :         ndr_print_ptr(ndr, "pKeyPath", r->pKeyPath);
     760           0 :         ndr->depth++;
     761           0 :         if (r->pKeyPath) {
     762           0 :                 ndr_print_string(ndr, "pKeyPath", r->pKeyPath);
     763             :         }
     764           0 :         ndr->depth--;
     765           0 :         ndr_print_ptr(ndr, "pValueName", r->pValueName);
     766           0 :         ndr->depth++;
     767           0 :         if (r->pValueName) {
     768           0 :                 ndr_print_string(ndr, "pValueName", r->pValueName);
     769             :         }
     770           0 :         ndr->depth--;
     771           0 :         ndr_print_winreg_Type(ndr, "ulValueType", r->ulValueType);
     772           0 :         ndr_print_uint32(ndr, "cbValueData", r->cbValueData);
     773             :         {
     774           0 :                 uint32_t _flags_save_uint8 = ndr->flags;
     775           0 :                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
     776           0 :                 ndr_print_ptr(ndr, "pValueData", r->pValueData);
     777           0 :                 ndr->depth++;
     778           0 :                 if (r->pValueData) {
     779           0 :                         ndr_print_array_uint8(ndr, "pValueData", r->pValueData, r->cbValueData);
     780             :                 }
     781           0 :                 ndr->depth--;
     782           0 :                 ndr->flags = _flags_save_uint8;
     783             :         }
     784           0 :         ndr->depth--;
     785             : }
     786             : 
     787           0 : static enum ndr_err_code ndr_push_OP_POLICY_ELEMENT_LIST(struct ndr_push *ndr, int ndr_flags, const struct OP_POLICY_ELEMENT_LIST *r)
     788             : {
     789             :         uint32_t cntr_pElements_1;
     790           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     791           0 :         if (ndr_flags & NDR_SCALARS) {
     792           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     793           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pSource));
     794           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulRootKeyId));
     795           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cElements));
     796           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pElements));
     797           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     798             :         }
     799           0 :         if (ndr_flags & NDR_BUFFERS) {
     800           0 :                 if (r->pSource) {
     801           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pSource, CH_UTF16)));
     802           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     803           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pSource, CH_UTF16)));
     804           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->pSource, ndr_charset_length(r->pSource, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     805             :                 }
     806           0 :                 if (r->pElements) {
     807           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cElements));
     808           0 :                         for (cntr_pElements_1 = 0; cntr_pElements_1 < (r->cElements); cntr_pElements_1++) {
     809           0 :                                 NDR_CHECK(ndr_push_OP_POLICY_ELEMENT(ndr, NDR_SCALARS, &r->pElements[cntr_pElements_1]));
     810             :                         }
     811           0 :                         for (cntr_pElements_1 = 0; cntr_pElements_1 < (r->cElements); cntr_pElements_1++) {
     812           0 :                                 NDR_CHECK(ndr_push_OP_POLICY_ELEMENT(ndr, NDR_BUFFERS, &r->pElements[cntr_pElements_1]));
     813             :                         }
     814             :                 }
     815             :         }
     816           0 :         return NDR_ERR_SUCCESS;
     817             : }
     818             : 
     819           0 : static enum ndr_err_code ndr_pull_OP_POLICY_ELEMENT_LIST(struct ndr_pull *ndr, int ndr_flags, struct OP_POLICY_ELEMENT_LIST *r)
     820             : {
     821             :         uint32_t _ptr_pSource;
     822           0 :         uint32_t size_pSource_1 = 0;
     823           0 :         uint32_t length_pSource_1 = 0;
     824           0 :         TALLOC_CTX *_mem_save_pSource_0 = NULL;
     825             :         uint32_t _ptr_pElements;
     826           0 :         uint32_t size_pElements_1 = 0;
     827             :         uint32_t cntr_pElements_1;
     828           0 :         TALLOC_CTX *_mem_save_pElements_0 = NULL;
     829           0 :         TALLOC_CTX *_mem_save_pElements_1 = NULL;
     830           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     831           0 :         if (ndr_flags & NDR_SCALARS) {
     832           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     833           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pSource));
     834           0 :                 if (_ptr_pSource) {
     835           0 :                         NDR_PULL_ALLOC(ndr, r->pSource);
     836             :                 } else {
     837           0 :                         r->pSource = NULL;
     838             :                 }
     839           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulRootKeyId));
     840           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cElements));
     841           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pElements));
     842           0 :                 if (_ptr_pElements) {
     843           0 :                         NDR_PULL_ALLOC(ndr, r->pElements);
     844             :                 } else {
     845           0 :                         r->pElements = NULL;
     846             :                 }
     847           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     848             :         }
     849           0 :         if (ndr_flags & NDR_BUFFERS) {
     850           0 :                 if (r->pSource) {
     851           0 :                         _mem_save_pSource_0 = NDR_PULL_GET_MEM_CTX(ndr);
     852           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pSource, 0);
     853           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pSource));
     854           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->pSource));
     855           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->pSource, &size_pSource_1));
     856           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->pSource, &length_pSource_1));
     857           0 :                         if (length_pSource_1 > size_pSource_1) {
     858           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pSource_1, length_pSource_1);
     859             :                         }
     860           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pSource_1, sizeof(uint16_t)));
     861           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->pSource, length_pSource_1, sizeof(uint16_t), CH_UTF16));
     862           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pSource_0, 0);
     863             :                 }
     864           0 :                 if (r->pElements) {
     865           0 :                         _mem_save_pElements_0 = NDR_PULL_GET_MEM_CTX(ndr);
     866           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pElements, 0);
     867           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pElements));
     868           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pElements, &size_pElements_1));
     869           0 :                         NDR_PULL_ALLOC_N(ndr, r->pElements, size_pElements_1);
     870           0 :                         _mem_save_pElements_1 = NDR_PULL_GET_MEM_CTX(ndr);
     871           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pElements, 0);
     872           0 :                         for (cntr_pElements_1 = 0; cntr_pElements_1 < (size_pElements_1); cntr_pElements_1++) {
     873           0 :                                 NDR_CHECK(ndr_pull_OP_POLICY_ELEMENT(ndr, NDR_SCALARS, &r->pElements[cntr_pElements_1]));
     874             :                         }
     875           0 :                         for (cntr_pElements_1 = 0; cntr_pElements_1 < (size_pElements_1); cntr_pElements_1++) {
     876           0 :                                 NDR_CHECK(ndr_pull_OP_POLICY_ELEMENT(ndr, NDR_BUFFERS, &r->pElements[cntr_pElements_1]));
     877             :                         }
     878           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pElements_1, 0);
     879           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pElements_0, 0);
     880             :                 }
     881           0 :                 if (r->pElements) {
     882           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pElements, r->cElements));
     883             :                 }
     884           0 :                 for (cntr_pElements_1 = 0; cntr_pElements_1 < (size_pElements_1); cntr_pElements_1++) {
     885             :                 }
     886             :         }
     887           0 :         return NDR_ERR_SUCCESS;
     888             : }
     889             : 
     890           0 : _PUBLIC_ void ndr_print_OP_POLICY_ELEMENT_LIST(struct ndr_print *ndr, const char *name, const struct OP_POLICY_ELEMENT_LIST *r)
     891             : {
     892             :         uint32_t cntr_pElements_1;
     893           0 :         ndr_print_struct(ndr, name, "OP_POLICY_ELEMENT_LIST");
     894           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     895           0 :         ndr->depth++;
     896           0 :         ndr_print_ptr(ndr, "pSource", r->pSource);
     897           0 :         ndr->depth++;
     898           0 :         if (r->pSource) {
     899           0 :                 ndr_print_string(ndr, "pSource", r->pSource);
     900             :         }
     901           0 :         ndr->depth--;
     902           0 :         ndr_print_uint32(ndr, "ulRootKeyId", r->ulRootKeyId);
     903           0 :         ndr_print_uint32(ndr, "cElements", r->cElements);
     904           0 :         ndr_print_ptr(ndr, "pElements", r->pElements);
     905           0 :         ndr->depth++;
     906           0 :         if (r->pElements) {
     907           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "pElements", (int)r->cElements);
     908           0 :                 ndr->depth++;
     909           0 :                 for (cntr_pElements_1 = 0; cntr_pElements_1 < (r->cElements); cntr_pElements_1++) {
     910           0 :                         ndr_print_OP_POLICY_ELEMENT(ndr, "pElements", &r->pElements[cntr_pElements_1]);
     911             :                 }
     912           0 :                 ndr->depth--;
     913             :         }
     914           0 :         ndr->depth--;
     915           0 :         ndr->depth--;
     916             : }
     917             : 
     918           0 : static enum ndr_err_code ndr_push_OP_POLICY_PART(struct ndr_push *ndr, int ndr_flags, const struct OP_POLICY_PART *r)
     919             : {
     920             :         uint32_t cntr_pElementLists_1;
     921           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     922           0 :         if (ndr_flags & NDR_SCALARS) {
     923           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     924           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cElementLists));
     925           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pElementLists));
     926           0 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
     927           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     928             :         }
     929           0 :         if (ndr_flags & NDR_BUFFERS) {
     930           0 :                 if (r->pElementLists) {
     931           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cElementLists));
     932           0 :                         for (cntr_pElementLists_1 = 0; cntr_pElementLists_1 < (r->cElementLists); cntr_pElementLists_1++) {
     933           0 :                                 NDR_CHECK(ndr_push_OP_POLICY_ELEMENT_LIST(ndr, NDR_SCALARS, &r->pElementLists[cntr_pElementLists_1]));
     934             :                         }
     935           0 :                         for (cntr_pElementLists_1 = 0; cntr_pElementLists_1 < (r->cElementLists); cntr_pElementLists_1++) {
     936           0 :                                 NDR_CHECK(ndr_push_OP_POLICY_ELEMENT_LIST(ndr, NDR_BUFFERS, &r->pElementLists[cntr_pElementLists_1]));
     937             :                         }
     938             :                 }
     939           0 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
     940             :         }
     941           0 :         return NDR_ERR_SUCCESS;
     942             : }
     943             : 
     944           0 : static enum ndr_err_code ndr_pull_OP_POLICY_PART(struct ndr_pull *ndr, int ndr_flags, struct OP_POLICY_PART *r)
     945             : {
     946             :         uint32_t _ptr_pElementLists;
     947           0 :         uint32_t size_pElementLists_1 = 0;
     948             :         uint32_t cntr_pElementLists_1;
     949           0 :         TALLOC_CTX *_mem_save_pElementLists_0 = NULL;
     950           0 :         TALLOC_CTX *_mem_save_pElementLists_1 = NULL;
     951           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     952           0 :         if (ndr_flags & NDR_SCALARS) {
     953           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     954           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cElementLists));
     955           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pElementLists));
     956           0 :                 if (_ptr_pElementLists) {
     957           0 :                         NDR_PULL_ALLOC(ndr, r->pElementLists);
     958             :                 } else {
     959           0 :                         r->pElementLists = NULL;
     960             :                 }
     961           0 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
     962           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     963             :         }
     964           0 :         if (ndr_flags & NDR_BUFFERS) {
     965           0 :                 if (r->pElementLists) {
     966           0 :                         _mem_save_pElementLists_0 = NDR_PULL_GET_MEM_CTX(ndr);
     967           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pElementLists, 0);
     968           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pElementLists));
     969           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pElementLists, &size_pElementLists_1));
     970           0 :                         NDR_PULL_ALLOC_N(ndr, r->pElementLists, size_pElementLists_1);
     971           0 :                         _mem_save_pElementLists_1 = NDR_PULL_GET_MEM_CTX(ndr);
     972           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pElementLists, 0);
     973           0 :                         for (cntr_pElementLists_1 = 0; cntr_pElementLists_1 < (size_pElementLists_1); cntr_pElementLists_1++) {
     974           0 :                                 NDR_CHECK(ndr_pull_OP_POLICY_ELEMENT_LIST(ndr, NDR_SCALARS, &r->pElementLists[cntr_pElementLists_1]));
     975             :                         }
     976           0 :                         for (cntr_pElementLists_1 = 0; cntr_pElementLists_1 < (size_pElementLists_1); cntr_pElementLists_1++) {
     977           0 :                                 NDR_CHECK(ndr_pull_OP_POLICY_ELEMENT_LIST(ndr, NDR_BUFFERS, &r->pElementLists[cntr_pElementLists_1]));
     978             :                         }
     979           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pElementLists_1, 0);
     980           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pElementLists_0, 0);
     981             :                 }
     982           0 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
     983           0 :                 if (r->pElementLists) {
     984           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pElementLists, r->cElementLists));
     985             :                 }
     986           0 :                 for (cntr_pElementLists_1 = 0; cntr_pElementLists_1 < (size_pElementLists_1); cntr_pElementLists_1++) {
     987             :                 }
     988             :         }
     989           0 :         return NDR_ERR_SUCCESS;
     990             : }
     991             : 
     992           0 : _PUBLIC_ void ndr_print_OP_POLICY_PART(struct ndr_print *ndr, const char *name, const struct OP_POLICY_PART *r)
     993             : {
     994             :         uint32_t cntr_pElementLists_1;
     995           0 :         ndr_print_struct(ndr, name, "OP_POLICY_PART");
     996           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     997           0 :         ndr->depth++;
     998           0 :         ndr_print_uint32(ndr, "cElementLists", r->cElementLists);
     999           0 :         ndr_print_ptr(ndr, "pElementLists", r->pElementLists);
    1000           0 :         ndr->depth++;
    1001           0 :         if (r->pElementLists) {
    1002           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "pElementLists", (int)r->cElementLists);
    1003           0 :                 ndr->depth++;
    1004           0 :                 for (cntr_pElementLists_1 = 0; cntr_pElementLists_1 < (r->cElementLists); cntr_pElementLists_1++) {
    1005           0 :                         ndr_print_OP_POLICY_ELEMENT_LIST(ndr, "pElementLists", &r->pElementLists[cntr_pElementLists_1]);
    1006             :                 }
    1007           0 :                 ndr->depth--;
    1008             :         }
    1009           0 :         ndr->depth--;
    1010           0 :         ndr_print_OP_BLOB(ndr, "Extension", &r->Extension);
    1011           0 :         ndr->depth--;
    1012             : }
    1013             : 
    1014           0 : static enum ndr_err_code ndr_push_OP_CERT_PFX_STORE(struct ndr_push *ndr, int ndr_flags, const struct OP_CERT_PFX_STORE *r)
    1015             : {
    1016           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1017           0 :         if (ndr_flags & NDR_SCALARS) {
    1018           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1019           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pTemplateName));
    1020           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulPrivateKeyExportPolicy));
    1021           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pPolicyServerUrl));
    1022           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulPolicyServerUrlFlags));
    1023           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pPolicyServerId));
    1024           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbPfx));
    1025           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pPfx));
    1026           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1027             :         }
    1028           0 :         if (ndr_flags & NDR_BUFFERS) {
    1029           0 :                 if (r->pTemplateName) {
    1030           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pTemplateName, CH_UTF16)));
    1031           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1032           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pTemplateName, CH_UTF16)));
    1033           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->pTemplateName, ndr_charset_length(r->pTemplateName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1034             :                 }
    1035           0 :                 if (r->pPolicyServerUrl) {
    1036           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pPolicyServerUrl, CH_UTF16)));
    1037           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1038           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pPolicyServerUrl, CH_UTF16)));
    1039           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->pPolicyServerUrl, ndr_charset_length(r->pPolicyServerUrl, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1040             :                 }
    1041           0 :                 if (r->pPolicyServerId) {
    1042           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pPolicyServerId, CH_UTF16)));
    1043           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1044           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pPolicyServerId, CH_UTF16)));
    1045           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->pPolicyServerId, ndr_charset_length(r->pPolicyServerId, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1046             :                 }
    1047           0 :                 if (r->pPfx) {
    1048           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbPfx));
    1049           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pPfx, r->cbPfx));
    1050             :                 }
    1051             :         }
    1052           0 :         return NDR_ERR_SUCCESS;
    1053             : }
    1054             : 
    1055           0 : static enum ndr_err_code ndr_pull_OP_CERT_PFX_STORE(struct ndr_pull *ndr, int ndr_flags, struct OP_CERT_PFX_STORE *r)
    1056             : {
    1057             :         uint32_t _ptr_pTemplateName;
    1058           0 :         uint32_t size_pTemplateName_1 = 0;
    1059           0 :         uint32_t length_pTemplateName_1 = 0;
    1060           0 :         TALLOC_CTX *_mem_save_pTemplateName_0 = NULL;
    1061             :         uint32_t _ptr_pPolicyServerUrl;
    1062           0 :         uint32_t size_pPolicyServerUrl_1 = 0;
    1063           0 :         uint32_t length_pPolicyServerUrl_1 = 0;
    1064           0 :         TALLOC_CTX *_mem_save_pPolicyServerUrl_0 = NULL;
    1065             :         uint32_t _ptr_pPolicyServerId;
    1066           0 :         uint32_t size_pPolicyServerId_1 = 0;
    1067           0 :         uint32_t length_pPolicyServerId_1 = 0;
    1068           0 :         TALLOC_CTX *_mem_save_pPolicyServerId_0 = NULL;
    1069             :         uint32_t _ptr_pPfx;
    1070           0 :         uint32_t size_pPfx_1 = 0;
    1071           0 :         TALLOC_CTX *_mem_save_pPfx_0 = NULL;
    1072           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1073           0 :         if (ndr_flags & NDR_SCALARS) {
    1074           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1075           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pTemplateName));
    1076           0 :                 if (_ptr_pTemplateName) {
    1077           0 :                         NDR_PULL_ALLOC(ndr, r->pTemplateName);
    1078             :                 } else {
    1079           0 :                         r->pTemplateName = NULL;
    1080             :                 }
    1081           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulPrivateKeyExportPolicy));
    1082           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pPolicyServerUrl));
    1083           0 :                 if (_ptr_pPolicyServerUrl) {
    1084           0 :                         NDR_PULL_ALLOC(ndr, r->pPolicyServerUrl);
    1085             :                 } else {
    1086           0 :                         r->pPolicyServerUrl = NULL;
    1087             :                 }
    1088           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulPolicyServerUrlFlags));
    1089           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pPolicyServerId));
    1090           0 :                 if (_ptr_pPolicyServerId) {
    1091           0 :                         NDR_PULL_ALLOC(ndr, r->pPolicyServerId);
    1092             :                 } else {
    1093           0 :                         r->pPolicyServerId = NULL;
    1094             :                 }
    1095           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbPfx));
    1096           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pPfx));
    1097           0 :                 if (_ptr_pPfx) {
    1098           0 :                         NDR_PULL_ALLOC(ndr, r->pPfx);
    1099             :                 } else {
    1100           0 :                         r->pPfx = NULL;
    1101             :                 }
    1102           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1103             :         }
    1104           0 :         if (ndr_flags & NDR_BUFFERS) {
    1105           0 :                 if (r->pTemplateName) {
    1106           0 :                         _mem_save_pTemplateName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1107           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pTemplateName, 0);
    1108           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pTemplateName));
    1109           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->pTemplateName));
    1110           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->pTemplateName, &size_pTemplateName_1));
    1111           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->pTemplateName, &length_pTemplateName_1));
    1112           0 :                         if (length_pTemplateName_1 > size_pTemplateName_1) {
    1113           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pTemplateName_1, length_pTemplateName_1);
    1114             :                         }
    1115           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pTemplateName_1, sizeof(uint16_t)));
    1116           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->pTemplateName, length_pTemplateName_1, sizeof(uint16_t), CH_UTF16));
    1117           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pTemplateName_0, 0);
    1118             :                 }
    1119           0 :                 if (r->pPolicyServerUrl) {
    1120           0 :                         _mem_save_pPolicyServerUrl_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1121           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pPolicyServerUrl, 0);
    1122           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pPolicyServerUrl));
    1123           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->pPolicyServerUrl));
    1124           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->pPolicyServerUrl, &size_pPolicyServerUrl_1));
    1125           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->pPolicyServerUrl, &length_pPolicyServerUrl_1));
    1126           0 :                         if (length_pPolicyServerUrl_1 > size_pPolicyServerUrl_1) {
    1127           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pPolicyServerUrl_1, length_pPolicyServerUrl_1);
    1128             :                         }
    1129           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pPolicyServerUrl_1, sizeof(uint16_t)));
    1130           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->pPolicyServerUrl, length_pPolicyServerUrl_1, sizeof(uint16_t), CH_UTF16));
    1131           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pPolicyServerUrl_0, 0);
    1132             :                 }
    1133           0 :                 if (r->pPolicyServerId) {
    1134           0 :                         _mem_save_pPolicyServerId_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1135           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pPolicyServerId, 0);
    1136           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pPolicyServerId));
    1137           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->pPolicyServerId));
    1138           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->pPolicyServerId, &size_pPolicyServerId_1));
    1139           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->pPolicyServerId, &length_pPolicyServerId_1));
    1140           0 :                         if (length_pPolicyServerId_1 > size_pPolicyServerId_1) {
    1141           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pPolicyServerId_1, length_pPolicyServerId_1);
    1142             :                         }
    1143           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pPolicyServerId_1, sizeof(uint16_t)));
    1144           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->pPolicyServerId, length_pPolicyServerId_1, sizeof(uint16_t), CH_UTF16));
    1145           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pPolicyServerId_0, 0);
    1146             :                 }
    1147           0 :                 if (r->pPfx) {
    1148           0 :                         _mem_save_pPfx_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1149           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pPfx, 0);
    1150           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pPfx));
    1151           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pPfx, &size_pPfx_1));
    1152           0 :                         NDR_PULL_ALLOC_N(ndr, r->pPfx, size_pPfx_1);
    1153           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pPfx, size_pPfx_1));
    1154           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pPfx_0, 0);
    1155             :                 }
    1156           0 :                 if (r->pPfx) {
    1157           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->pPfx, r->cbPfx));
    1158             :                 }
    1159             :         }
    1160           0 :         return NDR_ERR_SUCCESS;
    1161             : }
    1162             : 
    1163           0 : _PUBLIC_ void ndr_print_OP_CERT_PFX_STORE(struct ndr_print *ndr, const char *name, const struct OP_CERT_PFX_STORE *r)
    1164             : {
    1165           0 :         ndr_print_struct(ndr, name, "OP_CERT_PFX_STORE");
    1166           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1167           0 :         ndr->depth++;
    1168           0 :         ndr_print_ptr(ndr, "pTemplateName", r->pTemplateName);
    1169           0 :         ndr->depth++;
    1170           0 :         if (r->pTemplateName) {
    1171           0 :                 ndr_print_string(ndr, "pTemplateName", r->pTemplateName);
    1172             :         }
    1173           0 :         ndr->depth--;
    1174           0 :         ndr_print_uint32(ndr, "ulPrivateKeyExportPolicy", r->ulPrivateKeyExportPolicy);
    1175           0 :         ndr_print_ptr(ndr, "pPolicyServerUrl", r->pPolicyServerUrl);
    1176           0 :         ndr->depth++;
    1177           0 :         if (r->pPolicyServerUrl) {
    1178           0 :                 ndr_print_string(ndr, "pPolicyServerUrl", r->pPolicyServerUrl);
    1179             :         }
    1180           0 :         ndr->depth--;
    1181           0 :         ndr_print_uint32(ndr, "ulPolicyServerUrlFlags", r->ulPolicyServerUrlFlags);
    1182           0 :         ndr_print_ptr(ndr, "pPolicyServerId", r->pPolicyServerId);
    1183           0 :         ndr->depth++;
    1184           0 :         if (r->pPolicyServerId) {
    1185           0 :                 ndr_print_string(ndr, "pPolicyServerId", r->pPolicyServerId);
    1186             :         }
    1187           0 :         ndr->depth--;
    1188           0 :         ndr_print_uint32(ndr, "cbPfx", r->cbPfx);
    1189           0 :         ndr_print_ptr(ndr, "pPfx", r->pPfx);
    1190           0 :         ndr->depth++;
    1191           0 :         if (r->pPfx) {
    1192           0 :                 ndr_print_array_uint8(ndr, "pPfx", r->pPfx, r->cbPfx);
    1193             :         }
    1194           0 :         ndr->depth--;
    1195           0 :         ndr->depth--;
    1196             : }
    1197             : 
    1198           0 : static enum ndr_err_code ndr_push_OP_CERT_SST_STORE(struct ndr_push *ndr, int ndr_flags, const struct OP_CERT_SST_STORE *r)
    1199             : {
    1200           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1201           0 :         if (ndr_flags & NDR_SCALARS) {
    1202           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1203           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->StoreLocation));
    1204           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pStoreName));
    1205           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbSst));
    1206           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pSst));
    1207           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1208             :         }
    1209           0 :         if (ndr_flags & NDR_BUFFERS) {
    1210           0 :                 if (r->pStoreName) {
    1211           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pStoreName, CH_UTF16)));
    1212           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1213           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pStoreName, CH_UTF16)));
    1214           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->pStoreName, ndr_charset_length(r->pStoreName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1215             :                 }
    1216           0 :                 if (r->pSst) {
    1217           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbSst));
    1218           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pSst, r->cbSst));
    1219             :                 }
    1220             :         }
    1221           0 :         return NDR_ERR_SUCCESS;
    1222             : }
    1223             : 
    1224           0 : static enum ndr_err_code ndr_pull_OP_CERT_SST_STORE(struct ndr_pull *ndr, int ndr_flags, struct OP_CERT_SST_STORE *r)
    1225             : {
    1226             :         uint32_t _ptr_pStoreName;
    1227           0 :         uint32_t size_pStoreName_1 = 0;
    1228           0 :         uint32_t length_pStoreName_1 = 0;
    1229           0 :         TALLOC_CTX *_mem_save_pStoreName_0 = NULL;
    1230             :         uint32_t _ptr_pSst;
    1231           0 :         uint32_t size_pSst_1 = 0;
    1232           0 :         TALLOC_CTX *_mem_save_pSst_0 = NULL;
    1233           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1234           0 :         if (ndr_flags & NDR_SCALARS) {
    1235           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1236           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->StoreLocation));
    1237           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pStoreName));
    1238           0 :                 if (_ptr_pStoreName) {
    1239           0 :                         NDR_PULL_ALLOC(ndr, r->pStoreName);
    1240             :                 } else {
    1241           0 :                         r->pStoreName = NULL;
    1242             :                 }
    1243           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbSst));
    1244           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pSst));
    1245           0 :                 if (_ptr_pSst) {
    1246           0 :                         NDR_PULL_ALLOC(ndr, r->pSst);
    1247             :                 } else {
    1248           0 :                         r->pSst = NULL;
    1249             :                 }
    1250           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1251             :         }
    1252           0 :         if (ndr_flags & NDR_BUFFERS) {
    1253           0 :                 if (r->pStoreName) {
    1254           0 :                         _mem_save_pStoreName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1255           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pStoreName, 0);
    1256           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pStoreName));
    1257           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->pStoreName));
    1258           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->pStoreName, &size_pStoreName_1));
    1259           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->pStoreName, &length_pStoreName_1));
    1260           0 :                         if (length_pStoreName_1 > size_pStoreName_1) {
    1261           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pStoreName_1, length_pStoreName_1);
    1262             :                         }
    1263           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pStoreName_1, sizeof(uint16_t)));
    1264           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->pStoreName, length_pStoreName_1, sizeof(uint16_t), CH_UTF16));
    1265           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pStoreName_0, 0);
    1266             :                 }
    1267           0 :                 if (r->pSst) {
    1268           0 :                         _mem_save_pSst_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1269           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pSst, 0);
    1270           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pSst));
    1271           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pSst, &size_pSst_1));
    1272           0 :                         NDR_PULL_ALLOC_N(ndr, r->pSst, size_pSst_1);
    1273           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pSst, size_pSst_1));
    1274           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pSst_0, 0);
    1275             :                 }
    1276           0 :                 if (r->pSst) {
    1277           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->pSst, r->cbSst));
    1278             :                 }
    1279             :         }
    1280           0 :         return NDR_ERR_SUCCESS;
    1281             : }
    1282             : 
    1283           0 : _PUBLIC_ void ndr_print_OP_CERT_SST_STORE(struct ndr_print *ndr, const char *name, const struct OP_CERT_SST_STORE *r)
    1284             : {
    1285           0 :         ndr_print_struct(ndr, name, "OP_CERT_SST_STORE");
    1286           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1287           0 :         ndr->depth++;
    1288           0 :         ndr_print_uint32(ndr, "StoreLocation", r->StoreLocation);
    1289           0 :         ndr_print_ptr(ndr, "pStoreName", r->pStoreName);
    1290           0 :         ndr->depth++;
    1291           0 :         if (r->pStoreName) {
    1292           0 :                 ndr_print_string(ndr, "pStoreName", r->pStoreName);
    1293             :         }
    1294           0 :         ndr->depth--;
    1295           0 :         ndr_print_uint32(ndr, "cbSst", r->cbSst);
    1296           0 :         ndr_print_ptr(ndr, "pSst", r->pSst);
    1297           0 :         ndr->depth++;
    1298           0 :         if (r->pSst) {
    1299           0 :                 ndr_print_array_uint8(ndr, "pSst", r->pSst, r->cbSst);
    1300             :         }
    1301           0 :         ndr->depth--;
    1302           0 :         ndr->depth--;
    1303             : }
    1304             : 
    1305           0 : static enum ndr_err_code ndr_push_OP_CERT_PART(struct ndr_push *ndr, int ndr_flags, const struct OP_CERT_PART *r)
    1306             : {
    1307             :         uint32_t cntr_pPfxStores_1;
    1308             :         uint32_t cntr_pSstStores_1;
    1309           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1310           0 :         if (ndr_flags & NDR_SCALARS) {
    1311           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1312           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cPfxStores));
    1313           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pPfxStores));
    1314           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cSstStores));
    1315           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pSstStores));
    1316           0 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
    1317           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1318             :         }
    1319           0 :         if (ndr_flags & NDR_BUFFERS) {
    1320           0 :                 if (r->pPfxStores) {
    1321           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cPfxStores));
    1322           0 :                         for (cntr_pPfxStores_1 = 0; cntr_pPfxStores_1 < (r->cPfxStores); cntr_pPfxStores_1++) {
    1323           0 :                                 NDR_CHECK(ndr_push_OP_CERT_PFX_STORE(ndr, NDR_SCALARS, &r->pPfxStores[cntr_pPfxStores_1]));
    1324             :                         }
    1325           0 :                         for (cntr_pPfxStores_1 = 0; cntr_pPfxStores_1 < (r->cPfxStores); cntr_pPfxStores_1++) {
    1326           0 :                                 NDR_CHECK(ndr_push_OP_CERT_PFX_STORE(ndr, NDR_BUFFERS, &r->pPfxStores[cntr_pPfxStores_1]));
    1327             :                         }
    1328             :                 }
    1329           0 :                 if (r->pSstStores) {
    1330           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cSstStores));
    1331           0 :                         for (cntr_pSstStores_1 = 0; cntr_pSstStores_1 < (r->cSstStores); cntr_pSstStores_1++) {
    1332           0 :                                 NDR_CHECK(ndr_push_OP_CERT_SST_STORE(ndr, NDR_SCALARS, &r->pSstStores[cntr_pSstStores_1]));
    1333             :                         }
    1334           0 :                         for (cntr_pSstStores_1 = 0; cntr_pSstStores_1 < (r->cSstStores); cntr_pSstStores_1++) {
    1335           0 :                                 NDR_CHECK(ndr_push_OP_CERT_SST_STORE(ndr, NDR_BUFFERS, &r->pSstStores[cntr_pSstStores_1]));
    1336             :                         }
    1337             :                 }
    1338           0 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
    1339             :         }
    1340           0 :         return NDR_ERR_SUCCESS;
    1341             : }
    1342             : 
    1343           0 : static enum ndr_err_code ndr_pull_OP_CERT_PART(struct ndr_pull *ndr, int ndr_flags, struct OP_CERT_PART *r)
    1344             : {
    1345             :         uint32_t _ptr_pPfxStores;
    1346           0 :         uint32_t size_pPfxStores_1 = 0;
    1347             :         uint32_t cntr_pPfxStores_1;
    1348           0 :         TALLOC_CTX *_mem_save_pPfxStores_0 = NULL;
    1349           0 :         TALLOC_CTX *_mem_save_pPfxStores_1 = NULL;
    1350             :         uint32_t _ptr_pSstStores;
    1351           0 :         uint32_t size_pSstStores_1 = 0;
    1352             :         uint32_t cntr_pSstStores_1;
    1353           0 :         TALLOC_CTX *_mem_save_pSstStores_0 = NULL;
    1354           0 :         TALLOC_CTX *_mem_save_pSstStores_1 = NULL;
    1355           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1356           0 :         if (ndr_flags & NDR_SCALARS) {
    1357           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1358           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cPfxStores));
    1359           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pPfxStores));
    1360           0 :                 if (_ptr_pPfxStores) {
    1361           0 :                         NDR_PULL_ALLOC(ndr, r->pPfxStores);
    1362             :                 } else {
    1363           0 :                         r->pPfxStores = NULL;
    1364             :                 }
    1365           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cSstStores));
    1366           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pSstStores));
    1367           0 :                 if (_ptr_pSstStores) {
    1368           0 :                         NDR_PULL_ALLOC(ndr, r->pSstStores);
    1369             :                 } else {
    1370           0 :                         r->pSstStores = NULL;
    1371             :                 }
    1372           0 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
    1373           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1374             :         }
    1375           0 :         if (ndr_flags & NDR_BUFFERS) {
    1376           0 :                 if (r->pPfxStores) {
    1377           0 :                         _mem_save_pPfxStores_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1378           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pPfxStores, 0);
    1379           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pPfxStores));
    1380           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pPfxStores, &size_pPfxStores_1));
    1381           0 :                         NDR_PULL_ALLOC_N(ndr, r->pPfxStores, size_pPfxStores_1);
    1382           0 :                         _mem_save_pPfxStores_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1383           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pPfxStores, 0);
    1384           0 :                         for (cntr_pPfxStores_1 = 0; cntr_pPfxStores_1 < (size_pPfxStores_1); cntr_pPfxStores_1++) {
    1385           0 :                                 NDR_CHECK(ndr_pull_OP_CERT_PFX_STORE(ndr, NDR_SCALARS, &r->pPfxStores[cntr_pPfxStores_1]));
    1386             :                         }
    1387           0 :                         for (cntr_pPfxStores_1 = 0; cntr_pPfxStores_1 < (size_pPfxStores_1); cntr_pPfxStores_1++) {
    1388           0 :                                 NDR_CHECK(ndr_pull_OP_CERT_PFX_STORE(ndr, NDR_BUFFERS, &r->pPfxStores[cntr_pPfxStores_1]));
    1389             :                         }
    1390           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pPfxStores_1, 0);
    1391           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pPfxStores_0, 0);
    1392             :                 }
    1393           0 :                 if (r->pSstStores) {
    1394           0 :                         _mem_save_pSstStores_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1395           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pSstStores, 0);
    1396           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pSstStores));
    1397           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pSstStores, &size_pSstStores_1));
    1398           0 :                         NDR_PULL_ALLOC_N(ndr, r->pSstStores, size_pSstStores_1);
    1399           0 :                         _mem_save_pSstStores_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1400           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pSstStores, 0);
    1401           0 :                         for (cntr_pSstStores_1 = 0; cntr_pSstStores_1 < (size_pSstStores_1); cntr_pSstStores_1++) {
    1402           0 :                                 NDR_CHECK(ndr_pull_OP_CERT_SST_STORE(ndr, NDR_SCALARS, &r->pSstStores[cntr_pSstStores_1]));
    1403             :                         }
    1404           0 :                         for (cntr_pSstStores_1 = 0; cntr_pSstStores_1 < (size_pSstStores_1); cntr_pSstStores_1++) {
    1405           0 :                                 NDR_CHECK(ndr_pull_OP_CERT_SST_STORE(ndr, NDR_BUFFERS, &r->pSstStores[cntr_pSstStores_1]));
    1406             :                         }
    1407           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pSstStores_1, 0);
    1408           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pSstStores_0, 0);
    1409             :                 }
    1410           0 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
    1411           0 :                 if (r->pPfxStores) {
    1412           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pPfxStores, r->cPfxStores));
    1413             :                 }
    1414           0 :                 for (cntr_pPfxStores_1 = 0; cntr_pPfxStores_1 < (size_pPfxStores_1); cntr_pPfxStores_1++) {
    1415             :                 }
    1416           0 :                 if (r->pSstStores) {
    1417           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pSstStores, r->cSstStores));
    1418             :                 }
    1419           0 :                 for (cntr_pSstStores_1 = 0; cntr_pSstStores_1 < (size_pSstStores_1); cntr_pSstStores_1++) {
    1420             :                 }
    1421             :         }
    1422           0 :         return NDR_ERR_SUCCESS;
    1423             : }
    1424             : 
    1425           0 : _PUBLIC_ void ndr_print_OP_CERT_PART(struct ndr_print *ndr, const char *name, const struct OP_CERT_PART *r)
    1426             : {
    1427             :         uint32_t cntr_pPfxStores_1;
    1428             :         uint32_t cntr_pSstStores_1;
    1429           0 :         ndr_print_struct(ndr, name, "OP_CERT_PART");
    1430           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1431           0 :         ndr->depth++;
    1432           0 :         ndr_print_uint32(ndr, "cPfxStores", r->cPfxStores);
    1433           0 :         ndr_print_ptr(ndr, "pPfxStores", r->pPfxStores);
    1434           0 :         ndr->depth++;
    1435           0 :         if (r->pPfxStores) {
    1436           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "pPfxStores", (int)r->cPfxStores);
    1437           0 :                 ndr->depth++;
    1438           0 :                 for (cntr_pPfxStores_1 = 0; cntr_pPfxStores_1 < (r->cPfxStores); cntr_pPfxStores_1++) {
    1439           0 :                         ndr_print_OP_CERT_PFX_STORE(ndr, "pPfxStores", &r->pPfxStores[cntr_pPfxStores_1]);
    1440             :                 }
    1441           0 :                 ndr->depth--;
    1442             :         }
    1443           0 :         ndr->depth--;
    1444           0 :         ndr_print_uint32(ndr, "cSstStores", r->cSstStores);
    1445           0 :         ndr_print_ptr(ndr, "pSstStores", r->pSstStores);
    1446           0 :         ndr->depth++;
    1447           0 :         if (r->pSstStores) {
    1448           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "pSstStores", (int)r->cSstStores);
    1449           0 :                 ndr->depth++;
    1450           0 :                 for (cntr_pSstStores_1 = 0; cntr_pSstStores_1 < (r->cSstStores); cntr_pSstStores_1++) {
    1451           0 :                         ndr_print_OP_CERT_SST_STORE(ndr, "pSstStores", &r->pSstStores[cntr_pSstStores_1]);
    1452             :                 }
    1453           0 :                 ndr->depth--;
    1454             :         }
    1455           0 :         ndr->depth--;
    1456           0 :         ndr_print_OP_BLOB(ndr, "Extension", &r->Extension);
    1457           0 :         ndr->depth--;
    1458             : }
    1459             : 
    1460           0 : _PUBLIC_ enum ndr_err_code ndr_push_ODJ_WIN7BLOB_ctr(struct ndr_push *ndr, int ndr_flags, const struct ODJ_WIN7BLOB_ctr *r)
    1461             : {
    1462           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1463           0 :         if (ndr_flags & NDR_SCALARS) {
    1464           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1465           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
    1466           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1467             :         }
    1468           0 :         if (ndr_flags & NDR_BUFFERS) {
    1469           0 :                 if (r->p) {
    1470           0 :                         NDR_CHECK(ndr_push_ODJ_WIN7BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1471             :                 }
    1472             :         }
    1473           0 :         return NDR_ERR_SUCCESS;
    1474             : }
    1475             : 
    1476           0 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJ_WIN7BLOB_ctr(struct ndr_pull *ndr, int ndr_flags, struct ODJ_WIN7BLOB_ctr *r)
    1477             : {
    1478             :         uint32_t _ptr_p;
    1479           0 :         TALLOC_CTX *_mem_save_p_0 = NULL;
    1480           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1481           0 :         if (ndr_flags & NDR_SCALARS) {
    1482           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1483           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
    1484           0 :                 if (_ptr_p) {
    1485           0 :                         NDR_PULL_ALLOC(ndr, r->p);
    1486             :                 } else {
    1487           0 :                         r->p = NULL;
    1488             :                 }
    1489           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1490             :         }
    1491           0 :         if (ndr_flags & NDR_BUFFERS) {
    1492           0 :                 if (r->p) {
    1493           0 :                         _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1494           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
    1495           0 :                         NDR_CHECK(ndr_pull_ODJ_WIN7BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1496           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
    1497             :                 }
    1498             :         }
    1499           0 :         return NDR_ERR_SUCCESS;
    1500             : }
    1501             : 
    1502           0 : static void ndr_print_flags_ODJ_WIN7BLOB_ctr(struct ndr_print *ndr, const char *name, int unused, const struct ODJ_WIN7BLOB_ctr *r)
    1503             : {
    1504           0 :         ndr_print_ODJ_WIN7BLOB_ctr(ndr, name, r);
    1505           0 : }
    1506             : 
    1507           0 : _PUBLIC_ void ndr_print_ODJ_WIN7BLOB_ctr(struct ndr_print *ndr, const char *name, const struct ODJ_WIN7BLOB_ctr *r)
    1508             : {
    1509           0 :         ndr_print_struct(ndr, name, "ODJ_WIN7BLOB_ctr");
    1510           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1511           0 :         ndr->depth++;
    1512           0 :         ndr_print_ptr(ndr, "p", r->p);
    1513           0 :         ndr->depth++;
    1514           0 :         if (r->p) {
    1515           0 :                 ndr_print_ODJ_WIN7BLOB(ndr, "p", r->p);
    1516             :         }
    1517           0 :         ndr->depth--;
    1518           0 :         ndr->depth--;
    1519             : }
    1520             : 
    1521           0 : _PUBLIC_ enum ndr_err_code ndr_push_ODJ_WIN7BLOB_serialized_ptr(struct ndr_push *ndr, int ndr_flags, const struct ODJ_WIN7BLOB_serialized_ptr *r)
    1522             : {
    1523           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1524           0 :         if (ndr_flags & NDR_SCALARS) {
    1525           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1526             :                 {
    1527             :                         struct ndr_push *_ndr_s;
    1528           0 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    1529           0 :                         NDR_CHECK(ndr_push_ODJ_WIN7BLOB_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    1530           0 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    1531             :                 }
    1532           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1533             :         }
    1534           0 :         if (ndr_flags & NDR_BUFFERS) {
    1535             :         }
    1536           0 :         return NDR_ERR_SUCCESS;
    1537             : }
    1538             : 
    1539           0 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJ_WIN7BLOB_serialized_ptr(struct ndr_pull *ndr, int ndr_flags, struct ODJ_WIN7BLOB_serialized_ptr *r)
    1540             : {
    1541           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1542           0 :         if (ndr_flags & NDR_SCALARS) {
    1543           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    1544             :                 {
    1545             :                         struct ndr_pull *_ndr_s;
    1546           0 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    1547           0 :                         NDR_CHECK(ndr_pull_ODJ_WIN7BLOB_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    1548           0 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    1549             :                 }
    1550           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    1551             :         }
    1552           0 :         if (ndr_flags & NDR_BUFFERS) {
    1553             :         }
    1554           0 :         return NDR_ERR_SUCCESS;
    1555             : }
    1556             : 
    1557           0 : static void ndr_print_flags_ODJ_WIN7BLOB_serialized_ptr(struct ndr_print *ndr, const char *name, int unused, const struct ODJ_WIN7BLOB_serialized_ptr *r)
    1558             : {
    1559           0 :         ndr_print_ODJ_WIN7BLOB_serialized_ptr(ndr, name, r);
    1560           0 : }
    1561             : 
    1562           0 : _PUBLIC_ void ndr_print_ODJ_WIN7BLOB_serialized_ptr(struct ndr_print *ndr, const char *name, const struct ODJ_WIN7BLOB_serialized_ptr *r)
    1563             : {
    1564           0 :         ndr_print_struct(ndr, name, "ODJ_WIN7BLOB_serialized_ptr");
    1565           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1566           0 :         ndr->depth++;
    1567           0 :         ndr_print_ODJ_WIN7BLOB_ctr(ndr, "s", &r->s);
    1568           0 :         ndr->depth--;
    1569             : }
    1570             : 
    1571           0 : _PUBLIC_ size_t ndr_size_ODJ_WIN7BLOB_serialized_ptr(const struct ODJ_WIN7BLOB_serialized_ptr *r, int flags)
    1572             : {
    1573           0 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ODJ_WIN7BLOB_serialized_ptr);
    1574             : }
    1575             : 
    1576           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_JOINPROV2_PART_ctr(struct ndr_push *ndr, int ndr_flags, const struct OP_JOINPROV2_PART_ctr *r)
    1577             : {
    1578           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1579           0 :         if (ndr_flags & NDR_SCALARS) {
    1580           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1581           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
    1582           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1583             :         }
    1584           0 :         if (ndr_flags & NDR_BUFFERS) {
    1585           0 :                 if (r->p) {
    1586           0 :                         NDR_CHECK(ndr_push_OP_JOINPROV2_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1587             :                 }
    1588             :         }
    1589           0 :         return NDR_ERR_SUCCESS;
    1590             : }
    1591             : 
    1592           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_JOINPROV2_PART_ctr(struct ndr_pull *ndr, int ndr_flags, struct OP_JOINPROV2_PART_ctr *r)
    1593             : {
    1594             :         uint32_t _ptr_p;
    1595           0 :         TALLOC_CTX *_mem_save_p_0 = NULL;
    1596           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1597           0 :         if (ndr_flags & NDR_SCALARS) {
    1598           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1599           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
    1600           0 :                 if (_ptr_p) {
    1601           0 :                         NDR_PULL_ALLOC(ndr, r->p);
    1602             :                 } else {
    1603           0 :                         r->p = NULL;
    1604             :                 }
    1605           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1606             :         }
    1607           0 :         if (ndr_flags & NDR_BUFFERS) {
    1608           0 :                 if (r->p) {
    1609           0 :                         _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1610           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
    1611           0 :                         NDR_CHECK(ndr_pull_OP_JOINPROV2_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1612           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
    1613             :                 }
    1614             :         }
    1615           0 :         return NDR_ERR_SUCCESS;
    1616             : }
    1617             : 
    1618           0 : static void ndr_print_flags_OP_JOINPROV2_PART_ctr(struct ndr_print *ndr, const char *name, int unused, const struct OP_JOINPROV2_PART_ctr *r)
    1619             : {
    1620           0 :         ndr_print_OP_JOINPROV2_PART_ctr(ndr, name, r);
    1621           0 : }
    1622             : 
    1623           0 : _PUBLIC_ void ndr_print_OP_JOINPROV2_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV2_PART_ctr *r)
    1624             : {
    1625           0 :         ndr_print_struct(ndr, name, "OP_JOINPROV2_PART_ctr");
    1626           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1627           0 :         ndr->depth++;
    1628           0 :         ndr_print_ptr(ndr, "p", r->p);
    1629           0 :         ndr->depth++;
    1630           0 :         if (r->p) {
    1631           0 :                 ndr_print_OP_JOINPROV2_PART(ndr, "p", r->p);
    1632             :         }
    1633           0 :         ndr->depth--;
    1634           0 :         ndr->depth--;
    1635             : }
    1636             : 
    1637           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_JOINPROV2_PART_serialized_ptr(struct ndr_push *ndr, int ndr_flags, const struct OP_JOINPROV2_PART_serialized_ptr *r)
    1638             : {
    1639           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1640           0 :         if (ndr_flags & NDR_SCALARS) {
    1641           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1642             :                 {
    1643             :                         struct ndr_push *_ndr_s;
    1644           0 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    1645           0 :                         NDR_CHECK(ndr_push_OP_JOINPROV2_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    1646           0 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    1647             :                 }
    1648           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1649             :         }
    1650           0 :         if (ndr_flags & NDR_BUFFERS) {
    1651             :         }
    1652           0 :         return NDR_ERR_SUCCESS;
    1653             : }
    1654             : 
    1655           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_JOINPROV2_PART_serialized_ptr(struct ndr_pull *ndr, int ndr_flags, struct OP_JOINPROV2_PART_serialized_ptr *r)
    1656             : {
    1657           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1658           0 :         if (ndr_flags & NDR_SCALARS) {
    1659           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    1660             :                 {
    1661             :                         struct ndr_pull *_ndr_s;
    1662           0 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    1663           0 :                         NDR_CHECK(ndr_pull_OP_JOINPROV2_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    1664           0 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    1665             :                 }
    1666           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    1667             :         }
    1668           0 :         if (ndr_flags & NDR_BUFFERS) {
    1669             :         }
    1670           0 :         return NDR_ERR_SUCCESS;
    1671             : }
    1672             : 
    1673           0 : static void ndr_print_flags_OP_JOINPROV2_PART_serialized_ptr(struct ndr_print *ndr, const char *name, int unused, const struct OP_JOINPROV2_PART_serialized_ptr *r)
    1674             : {
    1675           0 :         ndr_print_OP_JOINPROV2_PART_serialized_ptr(ndr, name, r);
    1676           0 : }
    1677             : 
    1678           0 : _PUBLIC_ void ndr_print_OP_JOINPROV2_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV2_PART_serialized_ptr *r)
    1679             : {
    1680           0 :         ndr_print_struct(ndr, name, "OP_JOINPROV2_PART_serialized_ptr");
    1681           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1682           0 :         ndr->depth++;
    1683           0 :         ndr_print_OP_JOINPROV2_PART_ctr(ndr, "s", &r->s);
    1684           0 :         ndr->depth--;
    1685             : }
    1686             : 
    1687           0 : _PUBLIC_ size_t ndr_size_OP_JOINPROV2_PART_serialized_ptr(const struct OP_JOINPROV2_PART_serialized_ptr *r, int flags)
    1688             : {
    1689           0 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_JOINPROV2_PART_serialized_ptr);
    1690             : }
    1691             : 
    1692         510 : _PUBLIC_ enum ndr_err_code ndr_push_OP_JOINPROV3_PART_ctr(struct ndr_push *ndr, int ndr_flags, const struct OP_JOINPROV3_PART_ctr *r)
    1693             : {
    1694         510 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1695         510 :         if (ndr_flags & NDR_SCALARS) {
    1696         510 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1697         510 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
    1698         510 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1699             :         }
    1700         510 :         if (ndr_flags & NDR_BUFFERS) {
    1701         510 :                 if (r->p) {
    1702         510 :                         NDR_CHECK(ndr_push_OP_JOINPROV3_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1703             :                 }
    1704             :         }
    1705         510 :         return NDR_ERR_SUCCESS;
    1706             : }
    1707             : 
    1708           8 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_JOINPROV3_PART_ctr(struct ndr_pull *ndr, int ndr_flags, struct OP_JOINPROV3_PART_ctr *r)
    1709             : {
    1710             :         uint32_t _ptr_p;
    1711           8 :         TALLOC_CTX *_mem_save_p_0 = NULL;
    1712           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1713           8 :         if (ndr_flags & NDR_SCALARS) {
    1714           8 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1715           8 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
    1716           8 :                 if (_ptr_p) {
    1717           8 :                         NDR_PULL_ALLOC(ndr, r->p);
    1718             :                 } else {
    1719           0 :                         r->p = NULL;
    1720             :                 }
    1721           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1722             :         }
    1723           8 :         if (ndr_flags & NDR_BUFFERS) {
    1724           8 :                 if (r->p) {
    1725           8 :                         _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1726           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
    1727           8 :                         NDR_CHECK(ndr_pull_OP_JOINPROV3_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1728           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
    1729             :                 }
    1730             :         }
    1731           6 :         return NDR_ERR_SUCCESS;
    1732             : }
    1733             : 
    1734           0 : static void ndr_print_flags_OP_JOINPROV3_PART_ctr(struct ndr_print *ndr, const char *name, int unused, const struct OP_JOINPROV3_PART_ctr *r)
    1735             : {
    1736           0 :         ndr_print_OP_JOINPROV3_PART_ctr(ndr, name, r);
    1737           0 : }
    1738             : 
    1739           8 : _PUBLIC_ void ndr_print_OP_JOINPROV3_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV3_PART_ctr *r)
    1740             : {
    1741           8 :         ndr_print_struct(ndr, name, "OP_JOINPROV3_PART_ctr");
    1742           8 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1743           8 :         ndr->depth++;
    1744           8 :         ndr_print_ptr(ndr, "p", r->p);
    1745           8 :         ndr->depth++;
    1746           8 :         if (r->p) {
    1747           8 :                 ndr_print_OP_JOINPROV3_PART(ndr, "p", r->p);
    1748             :         }
    1749           8 :         ndr->depth--;
    1750           8 :         ndr->depth--;
    1751             : }
    1752             : 
    1753           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_JOINPROV3_PART_serialized_ptr(struct ndr_push *ndr, int ndr_flags, const struct OP_JOINPROV3_PART_serialized_ptr *r)
    1754             : {
    1755           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1756           0 :         if (ndr_flags & NDR_SCALARS) {
    1757           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1758             :                 {
    1759             :                         struct ndr_push *_ndr_s;
    1760           0 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    1761           0 :                         NDR_CHECK(ndr_push_OP_JOINPROV3_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    1762           0 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    1763             :                 }
    1764           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1765             :         }
    1766           0 :         if (ndr_flags & NDR_BUFFERS) {
    1767             :         }
    1768           0 :         return NDR_ERR_SUCCESS;
    1769             : }
    1770             : 
    1771           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_JOINPROV3_PART_serialized_ptr(struct ndr_pull *ndr, int ndr_flags, struct OP_JOINPROV3_PART_serialized_ptr *r)
    1772             : {
    1773           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1774           0 :         if (ndr_flags & NDR_SCALARS) {
    1775           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    1776             :                 {
    1777             :                         struct ndr_pull *_ndr_s;
    1778           0 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    1779           0 :                         NDR_CHECK(ndr_pull_OP_JOINPROV3_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    1780           0 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    1781             :                 }
    1782           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    1783             :         }
    1784           0 :         if (ndr_flags & NDR_BUFFERS) {
    1785             :         }
    1786           0 :         return NDR_ERR_SUCCESS;
    1787             : }
    1788             : 
    1789           0 : static void ndr_print_flags_OP_JOINPROV3_PART_serialized_ptr(struct ndr_print *ndr, const char *name, int unused, const struct OP_JOINPROV3_PART_serialized_ptr *r)
    1790             : {
    1791           0 :         ndr_print_OP_JOINPROV3_PART_serialized_ptr(ndr, name, r);
    1792           0 : }
    1793             : 
    1794           0 : _PUBLIC_ void ndr_print_OP_JOINPROV3_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV3_PART_serialized_ptr *r)
    1795             : {
    1796           0 :         ndr_print_struct(ndr, name, "OP_JOINPROV3_PART_serialized_ptr");
    1797           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1798           0 :         ndr->depth++;
    1799           0 :         ndr_print_OP_JOINPROV3_PART_ctr(ndr, "s", &r->s);
    1800           0 :         ndr->depth--;
    1801             : }
    1802             : 
    1803           0 : _PUBLIC_ size_t ndr_size_OP_JOINPROV3_PART_serialized_ptr(const struct OP_JOINPROV3_PART_serialized_ptr *r, int flags)
    1804             : {
    1805           0 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_JOINPROV3_PART_serialized_ptr);
    1806             : }
    1807             : 
    1808           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_POLICY_PART_ctr(struct ndr_push *ndr, int ndr_flags, const struct OP_POLICY_PART_ctr *r)
    1809             : {
    1810           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1811           0 :         if (ndr_flags & NDR_SCALARS) {
    1812           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1813           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
    1814           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1815             :         }
    1816           0 :         if (ndr_flags & NDR_BUFFERS) {
    1817           0 :                 if (r->p) {
    1818           0 :                         NDR_CHECK(ndr_push_OP_POLICY_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1819             :                 }
    1820             :         }
    1821           0 :         return NDR_ERR_SUCCESS;
    1822             : }
    1823             : 
    1824           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_POLICY_PART_ctr(struct ndr_pull *ndr, int ndr_flags, struct OP_POLICY_PART_ctr *r)
    1825             : {
    1826             :         uint32_t _ptr_p;
    1827           0 :         TALLOC_CTX *_mem_save_p_0 = NULL;
    1828           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1829           0 :         if (ndr_flags & NDR_SCALARS) {
    1830           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1831           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
    1832           0 :                 if (_ptr_p) {
    1833           0 :                         NDR_PULL_ALLOC(ndr, r->p);
    1834             :                 } else {
    1835           0 :                         r->p = NULL;
    1836             :                 }
    1837           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1838             :         }
    1839           0 :         if (ndr_flags & NDR_BUFFERS) {
    1840           0 :                 if (r->p) {
    1841           0 :                         _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1842           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
    1843           0 :                         NDR_CHECK(ndr_pull_OP_POLICY_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1844           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
    1845             :                 }
    1846             :         }
    1847           0 :         return NDR_ERR_SUCCESS;
    1848             : }
    1849             : 
    1850           0 : static void ndr_print_flags_OP_POLICY_PART_ctr(struct ndr_print *ndr, const char *name, int unused, const struct OP_POLICY_PART_ctr *r)
    1851             : {
    1852           0 :         ndr_print_OP_POLICY_PART_ctr(ndr, name, r);
    1853           0 : }
    1854             : 
    1855           0 : _PUBLIC_ void ndr_print_OP_POLICY_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_POLICY_PART_ctr *r)
    1856             : {
    1857           0 :         ndr_print_struct(ndr, name, "OP_POLICY_PART_ctr");
    1858           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1859           0 :         ndr->depth++;
    1860           0 :         ndr_print_ptr(ndr, "p", r->p);
    1861           0 :         ndr->depth++;
    1862           0 :         if (r->p) {
    1863           0 :                 ndr_print_OP_POLICY_PART(ndr, "p", r->p);
    1864             :         }
    1865           0 :         ndr->depth--;
    1866           0 :         ndr->depth--;
    1867             : }
    1868             : 
    1869           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_POLICY_PART_serialized_ptr(struct ndr_push *ndr, int ndr_flags, const struct OP_POLICY_PART_serialized_ptr *r)
    1870             : {
    1871           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1872           0 :         if (ndr_flags & NDR_SCALARS) {
    1873           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1874             :                 {
    1875             :                         struct ndr_push *_ndr_s;
    1876           0 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    1877           0 :                         NDR_CHECK(ndr_push_OP_POLICY_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    1878           0 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    1879             :                 }
    1880           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1881             :         }
    1882           0 :         if (ndr_flags & NDR_BUFFERS) {
    1883             :         }
    1884           0 :         return NDR_ERR_SUCCESS;
    1885             : }
    1886             : 
    1887           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_POLICY_PART_serialized_ptr(struct ndr_pull *ndr, int ndr_flags, struct OP_POLICY_PART_serialized_ptr *r)
    1888             : {
    1889           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1890           0 :         if (ndr_flags & NDR_SCALARS) {
    1891           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    1892             :                 {
    1893             :                         struct ndr_pull *_ndr_s;
    1894           0 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    1895           0 :                         NDR_CHECK(ndr_pull_OP_POLICY_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    1896           0 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    1897             :                 }
    1898           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    1899             :         }
    1900           0 :         if (ndr_flags & NDR_BUFFERS) {
    1901             :         }
    1902           0 :         return NDR_ERR_SUCCESS;
    1903             : }
    1904             : 
    1905           0 : static void ndr_print_flags_OP_POLICY_PART_serialized_ptr(struct ndr_print *ndr, const char *name, int unused, const struct OP_POLICY_PART_serialized_ptr *r)
    1906             : {
    1907           0 :         ndr_print_OP_POLICY_PART_serialized_ptr(ndr, name, r);
    1908           0 : }
    1909             : 
    1910           0 : _PUBLIC_ void ndr_print_OP_POLICY_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_POLICY_PART_serialized_ptr *r)
    1911             : {
    1912           0 :         ndr_print_struct(ndr, name, "OP_POLICY_PART_serialized_ptr");
    1913           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1914           0 :         ndr->depth++;
    1915           0 :         ndr_print_OP_POLICY_PART_ctr(ndr, "s", &r->s);
    1916           0 :         ndr->depth--;
    1917             : }
    1918             : 
    1919           0 : _PUBLIC_ size_t ndr_size_OP_POLICY_PART_serialized_ptr(const struct OP_POLICY_PART_serialized_ptr *r, int flags)
    1920             : {
    1921           0 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_POLICY_PART_serialized_ptr);
    1922             : }
    1923             : 
    1924           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_CERT_PART_ctr(struct ndr_push *ndr, int ndr_flags, const struct OP_CERT_PART_ctr *r)
    1925             : {
    1926           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1927           0 :         if (ndr_flags & NDR_SCALARS) {
    1928           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1929           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
    1930           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1931             :         }
    1932           0 :         if (ndr_flags & NDR_BUFFERS) {
    1933           0 :                 if (r->p) {
    1934           0 :                         NDR_CHECK(ndr_push_OP_CERT_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1935             :                 }
    1936             :         }
    1937           0 :         return NDR_ERR_SUCCESS;
    1938             : }
    1939             : 
    1940           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_CERT_PART_ctr(struct ndr_pull *ndr, int ndr_flags, struct OP_CERT_PART_ctr *r)
    1941             : {
    1942             :         uint32_t _ptr_p;
    1943           0 :         TALLOC_CTX *_mem_save_p_0 = NULL;
    1944           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1945           0 :         if (ndr_flags & NDR_SCALARS) {
    1946           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1947           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
    1948           0 :                 if (_ptr_p) {
    1949           0 :                         NDR_PULL_ALLOC(ndr, r->p);
    1950             :                 } else {
    1951           0 :                         r->p = NULL;
    1952             :                 }
    1953           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1954             :         }
    1955           0 :         if (ndr_flags & NDR_BUFFERS) {
    1956           0 :                 if (r->p) {
    1957           0 :                         _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1958           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
    1959           0 :                         NDR_CHECK(ndr_pull_OP_CERT_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    1960           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
    1961             :                 }
    1962             :         }
    1963           0 :         return NDR_ERR_SUCCESS;
    1964             : }
    1965             : 
    1966           0 : static void ndr_print_flags_OP_CERT_PART_ctr(struct ndr_print *ndr, const char *name, int unused, const struct OP_CERT_PART_ctr *r)
    1967             : {
    1968           0 :         ndr_print_OP_CERT_PART_ctr(ndr, name, r);
    1969           0 : }
    1970             : 
    1971           0 : _PUBLIC_ void ndr_print_OP_CERT_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_CERT_PART_ctr *r)
    1972             : {
    1973           0 :         ndr_print_struct(ndr, name, "OP_CERT_PART_ctr");
    1974           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1975           0 :         ndr->depth++;
    1976           0 :         ndr_print_ptr(ndr, "p", r->p);
    1977           0 :         ndr->depth++;
    1978           0 :         if (r->p) {
    1979           0 :                 ndr_print_OP_CERT_PART(ndr, "p", r->p);
    1980             :         }
    1981           0 :         ndr->depth--;
    1982           0 :         ndr->depth--;
    1983             : }
    1984             : 
    1985           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_CERT_PART_serialized_ptr(struct ndr_push *ndr, int ndr_flags, const struct OP_CERT_PART_serialized_ptr *r)
    1986             : {
    1987           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1988           0 :         if (ndr_flags & NDR_SCALARS) {
    1989           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    1990             :                 {
    1991             :                         struct ndr_push *_ndr_s;
    1992           0 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    1993           0 :                         NDR_CHECK(ndr_push_OP_CERT_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    1994           0 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    1995             :                 }
    1996           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    1997             :         }
    1998           0 :         if (ndr_flags & NDR_BUFFERS) {
    1999             :         }
    2000           0 :         return NDR_ERR_SUCCESS;
    2001             : }
    2002             : 
    2003           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_CERT_PART_serialized_ptr(struct ndr_pull *ndr, int ndr_flags, struct OP_CERT_PART_serialized_ptr *r)
    2004             : {
    2005           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2006           0 :         if (ndr_flags & NDR_SCALARS) {
    2007           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    2008             :                 {
    2009             :                         struct ndr_pull *_ndr_s;
    2010           0 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    2011           0 :                         NDR_CHECK(ndr_pull_OP_CERT_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    2012           0 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    2013             :                 }
    2014           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    2015             :         }
    2016           0 :         if (ndr_flags & NDR_BUFFERS) {
    2017             :         }
    2018           0 :         return NDR_ERR_SUCCESS;
    2019             : }
    2020             : 
    2021           0 : static void ndr_print_flags_OP_CERT_PART_serialized_ptr(struct ndr_print *ndr, const char *name, int unused, const struct OP_CERT_PART_serialized_ptr *r)
    2022             : {
    2023           0 :         ndr_print_OP_CERT_PART_serialized_ptr(ndr, name, r);
    2024           0 : }
    2025             : 
    2026           0 : _PUBLIC_ void ndr_print_OP_CERT_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_CERT_PART_serialized_ptr *r)
    2027             : {
    2028           0 :         ndr_print_struct(ndr, name, "OP_CERT_PART_serialized_ptr");
    2029           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2030           0 :         ndr->depth++;
    2031           0 :         ndr_print_OP_CERT_PART_ctr(ndr, "s", &r->s);
    2032           0 :         ndr->depth--;
    2033             : }
    2034             : 
    2035           0 : _PUBLIC_ size_t ndr_size_OP_CERT_PART_serialized_ptr(const struct OP_CERT_PART_serialized_ptr *r, int flags)
    2036             : {
    2037           0 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_CERT_PART_serialized_ptr);
    2038             : }
    2039             : 
    2040        1020 : _PUBLIC_ enum ndr_err_code ndr_push_OP_PACKAGE_PART_u(struct ndr_push *ndr, int ndr_flags, const union OP_PACKAGE_PART_u *r)
    2041             : {
    2042             :         uint32_t level;
    2043        1020 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2044        1020 :         if (ndr_flags & NDR_SCALARS) {
    2045             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    2046        1020 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    2047        1020 :                 NDR_CHECK(ndr_push_union_align(ndr, 1));
    2048        1020 :                 switch (level) {
    2049         510 :                         case 1: {
    2050         255 :                                 {
    2051             :                                         struct ndr_push *_ndr_win7blob;
    2052         510 :                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_win7blob, 0xFFFFFC01, -1));
    2053         510 :                                         NDR_CHECK(ndr_push_ODJ_WIN7BLOB(_ndr_win7blob, NDR_SCALARS|NDR_BUFFERS, &r->win7blob));
    2054         510 :                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_win7blob, 0xFFFFFC01, -1));
    2055             :                                 }
    2056         510 :                         break; }
    2057             : 
    2058           0 :                         case 2: {
    2059           0 :                                 {
    2060             :                                         struct ndr_push *_ndr_join_prov2;
    2061           0 :                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_join_prov2, 0xFFFFFC01, -1));
    2062           0 :                                         NDR_CHECK(ndr_push_OP_JOINPROV2_PART_ctr(_ndr_join_prov2, NDR_SCALARS|NDR_BUFFERS, &r->join_prov2));
    2063           0 :                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_join_prov2, 0xFFFFFC01, -1));
    2064             :                                 }
    2065           0 :                         break; }
    2066             : 
    2067         510 :                         case 3: {
    2068         255 :                                 {
    2069             :                                         struct ndr_push *_ndr_join_prov3;
    2070         510 :                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_join_prov3, 0xFFFFFC01, -1));
    2071         510 :                                         NDR_CHECK(ndr_push_OP_JOINPROV3_PART_ctr(_ndr_join_prov3, NDR_SCALARS|NDR_BUFFERS, &r->join_prov3));
    2072         510 :                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_join_prov3, 0xFFFFFC01, -1));
    2073             :                                 }
    2074         510 :                         break; }
    2075             : 
    2076           0 :                         case 4: {
    2077           0 :                                 {
    2078             :                                         struct ndr_push *_ndr_cert_part;
    2079           0 :                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_cert_part, 0xFFFFFC01, -1));
    2080           0 :                                         NDR_CHECK(ndr_push_OP_CERT_PART_ctr(_ndr_cert_part, NDR_SCALARS|NDR_BUFFERS, &r->cert_part));
    2081           0 :                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_cert_part, 0xFFFFFC01, -1));
    2082             :                                 }
    2083           0 :                         break; }
    2084             : 
    2085           0 :                         case 5: {
    2086           0 :                                 {
    2087             :                                         struct ndr_push *_ndr_policy_part;
    2088           0 :                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_policy_part, 0xFFFFFC01, -1));
    2089           0 :                                         NDR_CHECK(ndr_push_OP_POLICY_PART_ctr(_ndr_policy_part, NDR_SCALARS|NDR_BUFFERS, &r->policy_part));
    2090           0 :                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_policy_part, 0xFFFFFC01, -1));
    2091             :                                 }
    2092           0 :                         break; }
    2093             : 
    2094           0 :                         default: {
    2095           0 :                         break; }
    2096             : 
    2097             :                 }
    2098           0 :         }
    2099        1020 :         if (ndr_flags & NDR_BUFFERS) {
    2100        1020 :                 if (!(ndr_flags & NDR_SCALARS)) {
    2101             :                         /* We didn't get it above, and the token is not needed after this. */
    2102           0 :                         NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    2103             :                 }
    2104        1020 :                 switch (level) {
    2105         510 :                         case 1:
    2106         510 :                         break;
    2107             : 
    2108           0 :                         case 2:
    2109           0 :                         break;
    2110             : 
    2111         510 :                         case 3:
    2112         510 :                         break;
    2113             : 
    2114           0 :                         case 4:
    2115           0 :                         break;
    2116             : 
    2117           0 :                         case 5:
    2118           0 :                         break;
    2119             : 
    2120           0 :                         default:
    2121           0 :                         break;
    2122             : 
    2123             :                 }
    2124           0 :         }
    2125        1020 :         return NDR_ERR_SUCCESS;
    2126             : }
    2127             : 
    2128          16 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_PART_u(struct ndr_pull *ndr, int ndr_flags, union OP_PACKAGE_PART_u *r)
    2129             : {
    2130             :         uint32_t level;
    2131          16 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2132          16 :         if (ndr_flags & NDR_SCALARS) {
    2133             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    2134          16 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    2135          16 :                 NDR_CHECK(ndr_pull_union_align(ndr, 1));
    2136          16 :                 switch (level) {
    2137           8 :                         case 1: {
    2138           5 :                                 {
    2139             :                                         struct ndr_pull *_ndr_win7blob;
    2140           8 :                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_win7blob, 0xFFFFFC01, -1));
    2141           8 :                                         NDR_CHECK(ndr_pull_ODJ_WIN7BLOB(_ndr_win7blob, NDR_SCALARS|NDR_BUFFERS, &r->win7blob));
    2142           8 :                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_win7blob, 0xFFFFFC01, -1));
    2143             :                                 }
    2144           8 :                         break; }
    2145             : 
    2146           0 :                         case 2: {
    2147           0 :                                 {
    2148             :                                         struct ndr_pull *_ndr_join_prov2;
    2149           0 :                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_join_prov2, 0xFFFFFC01, -1));
    2150           0 :                                         NDR_CHECK(ndr_pull_OP_JOINPROV2_PART_ctr(_ndr_join_prov2, NDR_SCALARS|NDR_BUFFERS, &r->join_prov2));
    2151           0 :                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_join_prov2, 0xFFFFFC01, -1));
    2152             :                                 }
    2153           0 :                         break; }
    2154             : 
    2155           8 :                         case 3: {
    2156           5 :                                 {
    2157             :                                         struct ndr_pull *_ndr_join_prov3;
    2158           8 :                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_join_prov3, 0xFFFFFC01, -1));
    2159           8 :                                         NDR_CHECK(ndr_pull_OP_JOINPROV3_PART_ctr(_ndr_join_prov3, NDR_SCALARS|NDR_BUFFERS, &r->join_prov3));
    2160           8 :                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_join_prov3, 0xFFFFFC01, -1));
    2161             :                                 }
    2162           8 :                         break; }
    2163             : 
    2164           0 :                         case 4: {
    2165           0 :                                 {
    2166             :                                         struct ndr_pull *_ndr_cert_part;
    2167           0 :                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_cert_part, 0xFFFFFC01, -1));
    2168           0 :                                         NDR_CHECK(ndr_pull_OP_CERT_PART_ctr(_ndr_cert_part, NDR_SCALARS|NDR_BUFFERS, &r->cert_part));
    2169           0 :                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_cert_part, 0xFFFFFC01, -1));
    2170             :                                 }
    2171           0 :                         break; }
    2172             : 
    2173           0 :                         case 5: {
    2174           0 :                                 {
    2175             :                                         struct ndr_pull *_ndr_policy_part;
    2176           0 :                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_policy_part, 0xFFFFFC01, -1));
    2177           0 :                                         NDR_CHECK(ndr_pull_OP_POLICY_PART_ctr(_ndr_policy_part, NDR_SCALARS|NDR_BUFFERS, &r->policy_part));
    2178           0 :                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_policy_part, 0xFFFFFC01, -1));
    2179             :                                 }
    2180           0 :                         break; }
    2181             : 
    2182           0 :                         default: {
    2183           0 :                         break; }
    2184             : 
    2185             :                 }
    2186           0 :         }
    2187          16 :         if (ndr_flags & NDR_BUFFERS) {
    2188          16 :                 if (!(ndr_flags & NDR_SCALARS)) {
    2189             :                         /* We didn't get it above, and the token is not needed after this. */
    2190           0 :                         NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    2191             :                 }
    2192          12 :                 switch (level) {
    2193           6 :                         case 1:
    2194           6 :                         break;
    2195             : 
    2196           0 :                         case 2:
    2197           0 :                         break;
    2198             : 
    2199           6 :                         case 3:
    2200           6 :                         break;
    2201             : 
    2202           0 :                         case 4:
    2203           0 :                         break;
    2204             : 
    2205           0 :                         case 5:
    2206           0 :                         break;
    2207             : 
    2208           0 :                         default:
    2209           0 :                         break;
    2210             : 
    2211             :                 }
    2212           0 :         }
    2213          12 :         return NDR_ERR_SUCCESS;
    2214             : }
    2215             : 
    2216          16 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_u(struct ndr_print *ndr, const char *name, const union OP_PACKAGE_PART_u *r)
    2217             : {
    2218             :         uint32_t level;
    2219          16 :         level = ndr_print_steal_switch_value(ndr, r);
    2220          16 :         ndr_print_union(ndr, name, level, "OP_PACKAGE_PART_u");
    2221          16 :         switch (level) {
    2222           8 :                 case 1:
    2223           8 :                         ndr_print_ODJ_WIN7BLOB(ndr, "win7blob", &r->win7blob);
    2224           8 :                 break;
    2225             : 
    2226           0 :                 case 2:
    2227           0 :                         ndr_print_OP_JOINPROV2_PART_ctr(ndr, "join_prov2", &r->join_prov2);
    2228           0 :                 break;
    2229             : 
    2230           8 :                 case 3:
    2231           8 :                         ndr_print_OP_JOINPROV3_PART_ctr(ndr, "join_prov3", &r->join_prov3);
    2232           8 :                 break;
    2233             : 
    2234           0 :                 case 4:
    2235           0 :                         ndr_print_OP_CERT_PART_ctr(ndr, "cert_part", &r->cert_part);
    2236           0 :                 break;
    2237             : 
    2238           0 :                 case 5:
    2239           0 :                         ndr_print_OP_POLICY_PART_ctr(ndr, "policy_part", &r->policy_part);
    2240           0 :                 break;
    2241             : 
    2242           0 :                 default:
    2243           0 :                 break;
    2244             : 
    2245             :         }
    2246          16 : }
    2247             : 
    2248         768 : _PUBLIC_ size_t ndr_size_OP_PACKAGE_PART_u(const union OP_PACKAGE_PART_u *r, uint32_t level, int flags)
    2249             : {
    2250         768 :         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_OP_PACKAGE_PART_u);
    2251             : }
    2252             : 
    2253           0 : _PUBLIC_ enum ndr_err_code ndr_push_ODJ_PackageFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
    2254             : {
    2255           0 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
    2256           0 :         return NDR_ERR_SUCCESS;
    2257             : }
    2258             : 
    2259           0 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJ_PackageFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
    2260             : {
    2261             :         uint32_t v;
    2262           0 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
    2263           0 :         *r = v;
    2264           0 :         return NDR_ERR_SUCCESS;
    2265             : }
    2266             : 
    2267           0 : _PUBLIC_ void ndr_print_ODJ_PackageFlags(struct ndr_print *ndr, const char *name, uint32_t r)
    2268             : {
    2269           0 :         ndr_print_uint32(ndr, name, r);
    2270           0 :         ndr->depth++;
    2271           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "OPSPI_PACKAGE_PART_ESSENTIAL", OPSPI_PACKAGE_PART_ESSENTIAL, r);
    2272           0 :         ndr->depth--;
    2273           0 : }
    2274             : 
    2275         504 : static enum ndr_err_code ndr_push_OP_PACKAGE_PART(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE_PART *r)
    2276             : {
    2277         504 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2278         504 :         if (ndr_flags & NDR_SCALARS) {
    2279         252 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2280         252 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->PartType));
    2281         252 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulFlags));
    2282         252 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_OP_PACKAGE_PART_u(r->Part, odj_switch_level_from_guid(&r->PartType), 0)));
    2283         252 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Part));
    2284         252 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
    2285         252 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2286             :         }
    2287         504 :         if (ndr_flags & NDR_BUFFERS) {
    2288         252 :                 if (r->Part) {
    2289             :                         {
    2290             :                                 struct ndr_push *_ndr_Part;
    2291         252 :                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_Part, 4, ndr_size_OP_PACKAGE_PART_u(r->Part, odj_switch_level_from_guid(&r->PartType), 0)));
    2292         252 :                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_Part, r->Part, odj_switch_level_from_guid(&r->PartType)));
    2293         252 :                                 NDR_CHECK(ndr_push_OP_PACKAGE_PART_u(_ndr_Part, NDR_SCALARS|NDR_BUFFERS, r->Part));
    2294         252 :                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_Part, 4, ndr_size_OP_PACKAGE_PART_u(r->Part, odj_switch_level_from_guid(&r->PartType), 0)));
    2295             :                         }
    2296             :                 }
    2297         252 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
    2298             :         }
    2299         504 :         return NDR_ERR_SUCCESS;
    2300             : }
    2301             : 
    2302          32 : static enum ndr_err_code ndr_pull_OP_PACKAGE_PART(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE_PART *r)
    2303             : {
    2304             :         uint32_t _ptr_Part;
    2305          32 :         TALLOC_CTX *_mem_save_Part_0 = NULL;
    2306          32 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2307          32 :         if (ndr_flags & NDR_SCALARS) {
    2308          16 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2309          16 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->PartType));
    2310          16 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulFlags));
    2311          16 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->part_len));
    2312          16 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Part));
    2313          16 :                 if (_ptr_Part) {
    2314          16 :                         NDR_PULL_ALLOC(ndr, r->Part);
    2315             :                 } else {
    2316           0 :                         r->Part = NULL;
    2317             :                 }
    2318          16 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
    2319          16 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2320             :         }
    2321          32 :         if (ndr_flags & NDR_BUFFERS) {
    2322          16 :                 if (r->Part) {
    2323          16 :                         _mem_save_Part_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2324          16 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Part, 0);
    2325             :                         {
    2326             :                                 struct ndr_pull *_ndr_Part;
    2327          16 :                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_Part, 4, r->part_len));
    2328          16 :                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_Part, r->Part, odj_switch_level_from_guid(&r->PartType)));
    2329          16 :                                 NDR_CHECK(ndr_pull_OP_PACKAGE_PART_u(_ndr_Part, NDR_SCALARS|NDR_BUFFERS, r->Part));
    2330          16 :                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_Part, 4, r->part_len));
    2331             :                         }
    2332          16 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Part_0, 0);
    2333             :                 }
    2334          16 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
    2335             :         }
    2336          24 :         return NDR_ERR_SUCCESS;
    2337             : }
    2338             : 
    2339          16 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART *r)
    2340             : {
    2341          16 :         ndr_print_struct(ndr, name, "OP_PACKAGE_PART");
    2342          16 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2343          16 :         ndr->depth++;
    2344          16 :         ndr_print_GUID(ndr, "PartType", &r->PartType);
    2345          16 :         ndr_print_uint32(ndr, "ulFlags", r->ulFlags);
    2346          16 :         ndr_print_uint32(ndr, "part_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_OP_PACKAGE_PART_u(r->Part, odj_switch_level_from_guid(&r->PartType), 0):r->part_len);
    2347          16 :         ndr_print_ptr(ndr, "Part", r->Part);
    2348          16 :         ndr->depth++;
    2349          16 :         if (r->Part) {
    2350          16 :                 ndr_print_set_switch_value(ndr, r->Part, odj_switch_level_from_guid(&r->PartType));
    2351          16 :                 ndr_print_OP_PACKAGE_PART_u(ndr, "Part", r->Part);
    2352             :         }
    2353          16 :         ndr->depth--;
    2354          16 :         ndr_print_OP_BLOB(ndr, "Extension", &r->Extension);
    2355          16 :         ndr->depth--;
    2356             : }
    2357             : 
    2358           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_PACKAGE_PART_ctr(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE_PART_ctr *r)
    2359             : {
    2360           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2361           0 :         if (ndr_flags & NDR_SCALARS) {
    2362           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2363           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
    2364           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2365             :         }
    2366           0 :         if (ndr_flags & NDR_BUFFERS) {
    2367           0 :                 if (r->p) {
    2368           0 :                         NDR_CHECK(ndr_push_OP_PACKAGE_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    2369             :                 }
    2370             :         }
    2371           0 :         return NDR_ERR_SUCCESS;
    2372             : }
    2373             : 
    2374           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_PART_ctr(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE_PART_ctr *r)
    2375             : {
    2376             :         uint32_t _ptr_p;
    2377           0 :         TALLOC_CTX *_mem_save_p_0 = NULL;
    2378           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2379           0 :         if (ndr_flags & NDR_SCALARS) {
    2380           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2381           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
    2382           0 :                 if (_ptr_p) {
    2383           0 :                         NDR_PULL_ALLOC(ndr, r->p);
    2384             :                 } else {
    2385           0 :                         r->p = NULL;
    2386             :                 }
    2387           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2388             :         }
    2389           0 :         if (ndr_flags & NDR_BUFFERS) {
    2390           0 :                 if (r->p) {
    2391           0 :                         _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2392           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
    2393           0 :                         NDR_CHECK(ndr_pull_OP_PACKAGE_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    2394           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
    2395             :                 }
    2396             :         }
    2397           0 :         return NDR_ERR_SUCCESS;
    2398             : }
    2399             : 
    2400           0 : static void ndr_print_flags_OP_PACKAGE_PART_ctr(struct ndr_print *ndr, const char *name, int unused, const struct OP_PACKAGE_PART_ctr *r)
    2401             : {
    2402           0 :         ndr_print_OP_PACKAGE_PART_ctr(ndr, name, r);
    2403           0 : }
    2404             : 
    2405           0 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART_ctr *r)
    2406             : {
    2407           0 :         ndr_print_struct(ndr, name, "OP_PACKAGE_PART_ctr");
    2408           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2409           0 :         ndr->depth++;
    2410           0 :         ndr_print_ptr(ndr, "p", r->p);
    2411           0 :         ndr->depth++;
    2412           0 :         if (r->p) {
    2413           0 :                 ndr_print_OP_PACKAGE_PART(ndr, "p", r->p);
    2414             :         }
    2415           0 :         ndr->depth--;
    2416           0 :         ndr->depth--;
    2417             : }
    2418             : 
    2419           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_PACKAGE_PART_serialized_ptr(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE_PART_serialized_ptr *r)
    2420             : {
    2421           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2422           0 :         if (ndr_flags & NDR_SCALARS) {
    2423           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    2424             :                 {
    2425             :                         struct ndr_push *_ndr_s;
    2426           0 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    2427           0 :                         NDR_CHECK(ndr_push_OP_PACKAGE_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    2428           0 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    2429             :                 }
    2430           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    2431             :         }
    2432           0 :         if (ndr_flags & NDR_BUFFERS) {
    2433             :         }
    2434           0 :         return NDR_ERR_SUCCESS;
    2435             : }
    2436             : 
    2437           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_PART_serialized_ptr(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE_PART_serialized_ptr *r)
    2438             : {
    2439           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2440           0 :         if (ndr_flags & NDR_SCALARS) {
    2441           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    2442             :                 {
    2443             :                         struct ndr_pull *_ndr_s;
    2444           0 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    2445           0 :                         NDR_CHECK(ndr_pull_OP_PACKAGE_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    2446           0 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    2447             :                 }
    2448           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    2449             :         }
    2450           0 :         if (ndr_flags & NDR_BUFFERS) {
    2451             :         }
    2452           0 :         return NDR_ERR_SUCCESS;
    2453             : }
    2454             : 
    2455           0 : static void ndr_print_flags_OP_PACKAGE_PART_serialized_ptr(struct ndr_print *ndr, const char *name, int unused, const struct OP_PACKAGE_PART_serialized_ptr *r)
    2456             : {
    2457           0 :         ndr_print_OP_PACKAGE_PART_serialized_ptr(ndr, name, r);
    2458           0 : }
    2459             : 
    2460           0 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART_serialized_ptr *r)
    2461             : {
    2462           0 :         ndr_print_struct(ndr, name, "OP_PACKAGE_PART_serialized_ptr");
    2463           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2464           0 :         ndr->depth++;
    2465           0 :         ndr_print_OP_PACKAGE_PART_ctr(ndr, "s", &r->s);
    2466           0 :         ndr->depth--;
    2467             : }
    2468             : 
    2469           0 : _PUBLIC_ size_t ndr_size_OP_PACKAGE_PART_serialized_ptr(const struct OP_PACKAGE_PART_serialized_ptr *r, int flags)
    2470             : {
    2471           0 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_PACKAGE_PART_serialized_ptr);
    2472             : }
    2473             : 
    2474         126 : static enum ndr_err_code ndr_push_OP_PACKAGE_PART_COLLECTION(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE_PART_COLLECTION *r)
    2475             : {
    2476             :         uint32_t cntr_pParts_1;
    2477         126 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2478         126 :         if (ndr_flags & NDR_SCALARS) {
    2479         126 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2480         126 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cParts));
    2481         126 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pParts));
    2482         126 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
    2483         126 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2484             :         }
    2485         126 :         if (ndr_flags & NDR_BUFFERS) {
    2486         126 :                 if (r->pParts) {
    2487         126 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cParts));
    2488         378 :                         for (cntr_pParts_1 = 0; cntr_pParts_1 < (r->cParts); cntr_pParts_1++) {
    2489         252 :                                 NDR_CHECK(ndr_push_OP_PACKAGE_PART(ndr, NDR_SCALARS, &r->pParts[cntr_pParts_1]));
    2490             :                         }
    2491         378 :                         for (cntr_pParts_1 = 0; cntr_pParts_1 < (r->cParts); cntr_pParts_1++) {
    2492         252 :                                 NDR_CHECK(ndr_push_OP_PACKAGE_PART(ndr, NDR_BUFFERS, &r->pParts[cntr_pParts_1]));
    2493             :                         }
    2494             :                 }
    2495         126 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
    2496             :         }
    2497         126 :         return NDR_ERR_SUCCESS;
    2498             : }
    2499             : 
    2500           8 : static enum ndr_err_code ndr_pull_OP_PACKAGE_PART_COLLECTION(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE_PART_COLLECTION *r)
    2501             : {
    2502             :         uint32_t _ptr_pParts;
    2503           8 :         uint32_t size_pParts_1 = 0;
    2504             :         uint32_t cntr_pParts_1;
    2505           8 :         TALLOC_CTX *_mem_save_pParts_0 = NULL;
    2506           8 :         TALLOC_CTX *_mem_save_pParts_1 = NULL;
    2507           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2508           8 :         if (ndr_flags & NDR_SCALARS) {
    2509           8 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2510           8 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cParts));
    2511           8 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pParts));
    2512           8 :                 if (_ptr_pParts) {
    2513           8 :                         NDR_PULL_ALLOC(ndr, r->pParts);
    2514             :                 } else {
    2515           0 :                         r->pParts = NULL;
    2516             :                 }
    2517           8 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
    2518           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2519             :         }
    2520           8 :         if (ndr_flags & NDR_BUFFERS) {
    2521           8 :                 if (r->pParts) {
    2522           8 :                         _mem_save_pParts_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2523           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pParts, 0);
    2524           8 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pParts));
    2525           8 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pParts, &size_pParts_1));
    2526           8 :                         NDR_PULL_ALLOC_N(ndr, r->pParts, size_pParts_1);
    2527           8 :                         _mem_save_pParts_1 = NDR_PULL_GET_MEM_CTX(ndr);
    2528           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pParts, 0);
    2529          24 :                         for (cntr_pParts_1 = 0; cntr_pParts_1 < (size_pParts_1); cntr_pParts_1++) {
    2530          16 :                                 NDR_CHECK(ndr_pull_OP_PACKAGE_PART(ndr, NDR_SCALARS, &r->pParts[cntr_pParts_1]));
    2531             :                         }
    2532          22 :                         for (cntr_pParts_1 = 0; cntr_pParts_1 < (size_pParts_1); cntr_pParts_1++) {
    2533          16 :                                 NDR_CHECK(ndr_pull_OP_PACKAGE_PART(ndr, NDR_BUFFERS, &r->pParts[cntr_pParts_1]));
    2534             :                         }
    2535           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pParts_1, 0);
    2536           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pParts_0, 0);
    2537             :                 }
    2538           8 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
    2539           8 :                 if (r->pParts) {
    2540           8 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pParts, r->cParts));
    2541             :                 }
    2542          14 :                 for (cntr_pParts_1 = 0; cntr_pParts_1 < (size_pParts_1); cntr_pParts_1++) {
    2543             :                 }
    2544             :         }
    2545           6 :         return NDR_ERR_SUCCESS;
    2546             : }
    2547             : 
    2548           8 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_COLLECTION(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART_COLLECTION *r)
    2549             : {
    2550             :         uint32_t cntr_pParts_1;
    2551           8 :         ndr_print_struct(ndr, name, "OP_PACKAGE_PART_COLLECTION");
    2552           8 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2553           8 :         ndr->depth++;
    2554           8 :         ndr_print_uint32(ndr, "cParts", r->cParts);
    2555           8 :         ndr_print_ptr(ndr, "pParts", r->pParts);
    2556           8 :         ndr->depth++;
    2557           8 :         if (r->pParts) {
    2558           8 :                 ndr->print(ndr, "%s: ARRAY(%d)", "pParts", (int)r->cParts);
    2559           8 :                 ndr->depth++;
    2560          24 :                 for (cntr_pParts_1 = 0; cntr_pParts_1 < (r->cParts); cntr_pParts_1++) {
    2561          16 :                         ndr_print_OP_PACKAGE_PART(ndr, "pParts", &r->pParts[cntr_pParts_1]);
    2562             :                 }
    2563           8 :                 ndr->depth--;
    2564             :         }
    2565           8 :         ndr->depth--;
    2566           8 :         ndr_print_OP_BLOB(ndr, "Extension", &r->Extension);
    2567           8 :         ndr->depth--;
    2568             : }
    2569             : 
    2570         126 : _PUBLIC_ enum ndr_err_code ndr_push_OP_PACKAGE_PART_COLLECTION_ctr(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE_PART_COLLECTION_ctr *r)
    2571             : {
    2572         126 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2573         126 :         if (ndr_flags & NDR_SCALARS) {
    2574         126 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2575         126 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
    2576         126 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2577             :         }
    2578         126 :         if (ndr_flags & NDR_BUFFERS) {
    2579         126 :                 if (r->p) {
    2580         126 :                         NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    2581             :                 }
    2582             :         }
    2583         126 :         return NDR_ERR_SUCCESS;
    2584             : }
    2585             : 
    2586           8 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_PART_COLLECTION_ctr(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE_PART_COLLECTION_ctr *r)
    2587             : {
    2588             :         uint32_t _ptr_p;
    2589           8 :         TALLOC_CTX *_mem_save_p_0 = NULL;
    2590           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2591           8 :         if (ndr_flags & NDR_SCALARS) {
    2592           8 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2593           8 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
    2594           8 :                 if (_ptr_p) {
    2595           8 :                         NDR_PULL_ALLOC(ndr, r->p);
    2596             :                 } else {
    2597           0 :                         r->p = NULL;
    2598             :                 }
    2599           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2600             :         }
    2601           8 :         if (ndr_flags & NDR_BUFFERS) {
    2602           8 :                 if (r->p) {
    2603           8 :                         _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2604           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
    2605           8 :                         NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    2606           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
    2607             :                 }
    2608             :         }
    2609           6 :         return NDR_ERR_SUCCESS;
    2610             : }
    2611             : 
    2612           0 : static void ndr_print_flags_OP_PACKAGE_PART_COLLECTION_ctr(struct ndr_print *ndr, const char *name, int unused, const struct OP_PACKAGE_PART_COLLECTION_ctr *r)
    2613             : {
    2614           0 :         ndr_print_OP_PACKAGE_PART_COLLECTION_ctr(ndr, name, r);
    2615           0 : }
    2616             : 
    2617           8 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_COLLECTION_ctr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART_COLLECTION_ctr *r)
    2618             : {
    2619           8 :         ndr_print_struct(ndr, name, "OP_PACKAGE_PART_COLLECTION_ctr");
    2620           8 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2621           8 :         ndr->depth++;
    2622           8 :         ndr_print_ptr(ndr, "p", r->p);
    2623           8 :         ndr->depth++;
    2624           8 :         if (r->p) {
    2625           8 :                 ndr_print_OP_PACKAGE_PART_COLLECTION(ndr, "p", r->p);
    2626             :         }
    2627           8 :         ndr->depth--;
    2628           8 :         ndr->depth--;
    2629             : }
    2630             : 
    2631         126 : _PUBLIC_ enum ndr_err_code ndr_push_OP_PACKAGE_PART_COLLECTION_serialized_ptr(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE_PART_COLLECTION_serialized_ptr *r)
    2632             : {
    2633         126 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2634         126 :         if (ndr_flags & NDR_SCALARS) {
    2635         126 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    2636             :                 {
    2637             :                         struct ndr_push *_ndr_s;
    2638         126 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    2639         126 :                         NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    2640         126 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    2641             :                 }
    2642         126 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    2643             :         }
    2644         126 :         if (ndr_flags & NDR_BUFFERS) {
    2645             :         }
    2646         126 :         return NDR_ERR_SUCCESS;
    2647             : }
    2648             : 
    2649           8 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_PART_COLLECTION_serialized_ptr(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE_PART_COLLECTION_serialized_ptr *r)
    2650             : {
    2651           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2652           8 :         if (ndr_flags & NDR_SCALARS) {
    2653           8 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    2654             :                 {
    2655             :                         struct ndr_pull *_ndr_s;
    2656           8 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    2657           8 :                         NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    2658           8 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    2659             :                 }
    2660           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    2661             :         }
    2662           6 :         if (ndr_flags & NDR_BUFFERS) {
    2663             :         }
    2664           8 :         return NDR_ERR_SUCCESS;
    2665             : }
    2666             : 
    2667           0 : static void ndr_print_flags_OP_PACKAGE_PART_COLLECTION_serialized_ptr(struct ndr_print *ndr, const char *name, int unused, const struct OP_PACKAGE_PART_COLLECTION_serialized_ptr *r)
    2668             : {
    2669           0 :         ndr_print_OP_PACKAGE_PART_COLLECTION_serialized_ptr(ndr, name, r);
    2670           0 : }
    2671             : 
    2672           8 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_COLLECTION_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART_COLLECTION_serialized_ptr *r)
    2673             : {
    2674           8 :         ndr_print_struct(ndr, name, "OP_PACKAGE_PART_COLLECTION_serialized_ptr");
    2675           8 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2676           8 :         ndr->depth++;
    2677           8 :         ndr_print_OP_PACKAGE_PART_COLLECTION_ctr(ndr, "s", &r->s);
    2678           8 :         ndr->depth--;
    2679             : }
    2680             : 
    2681          96 : _PUBLIC_ size_t ndr_size_OP_PACKAGE_PART_COLLECTION_serialized_ptr(const struct OP_PACKAGE_PART_COLLECTION_serialized_ptr *r, int flags)
    2682             : {
    2683          96 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_PACKAGE_PART_COLLECTION_serialized_ptr);
    2684             : }
    2685             : 
    2686          60 : static enum ndr_err_code ndr_push_OP_PACKAGE_PART_COLLECTION_blob(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE_PART_COLLECTION_blob *r)
    2687             : {
    2688          60 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2689          60 :         if (ndr_flags & NDR_SCALARS) {
    2690          30 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2691          30 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_OP_PACKAGE_PART_COLLECTION_serialized_ptr(r->w, 0)));
    2692          30 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->w));
    2693          30 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2694             :         }
    2695          60 :         if (ndr_flags & NDR_BUFFERS) {
    2696          30 :                 if (r->w) {
    2697             :                         {
    2698             :                                 struct ndr_push *_ndr_w;
    2699          30 :                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_w, 4, ndr_size_OP_PACKAGE_PART_COLLECTION_serialized_ptr(r->w, 0)));
    2700          30 :                                 NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION_serialized_ptr(_ndr_w, NDR_SCALARS|NDR_BUFFERS, r->w));
    2701          30 :                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_w, 4, ndr_size_OP_PACKAGE_PART_COLLECTION_serialized_ptr(r->w, 0)));
    2702             :                         }
    2703             :                 }
    2704             :         }
    2705          60 :         return NDR_ERR_SUCCESS;
    2706             : }
    2707             : 
    2708          16 : static enum ndr_err_code ndr_pull_OP_PACKAGE_PART_COLLECTION_blob(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE_PART_COLLECTION_blob *r)
    2709             : {
    2710             :         uint32_t _ptr_w;
    2711          16 :         TALLOC_CTX *_mem_save_w_0 = NULL;
    2712          16 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2713          16 :         if (ndr_flags & NDR_SCALARS) {
    2714           8 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2715           8 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbBlob));
    2716           8 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_w));
    2717           8 :                 if (_ptr_w) {
    2718           8 :                         NDR_PULL_ALLOC(ndr, r->w);
    2719             :                 } else {
    2720           0 :                         r->w = NULL;
    2721             :                 }
    2722           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2723             :         }
    2724          16 :         if (ndr_flags & NDR_BUFFERS) {
    2725           8 :                 if (r->w) {
    2726           8 :                         _mem_save_w_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2727           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->w, 0);
    2728             :                         {
    2729             :                                 struct ndr_pull *_ndr_w;
    2730           8 :                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_w, 4, r->cbBlob));
    2731           8 :                                 NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION_serialized_ptr(_ndr_w, NDR_SCALARS|NDR_BUFFERS, r->w));
    2732           8 :                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_w, 4, r->cbBlob));
    2733             :                         }
    2734           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_w_0, 0);
    2735             :                 }
    2736             :         }
    2737          12 :         return NDR_ERR_SUCCESS;
    2738             : }
    2739             : 
    2740           8 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_COLLECTION_blob(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART_COLLECTION_blob *r)
    2741             : {
    2742           8 :         ndr_print_struct(ndr, name, "OP_PACKAGE_PART_COLLECTION_blob");
    2743           8 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2744           8 :         ndr->depth++;
    2745           8 :         ndr_print_uint32(ndr, "cbBlob", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_OP_PACKAGE_PART_COLLECTION_serialized_ptr(r->w, 0):r->cbBlob);
    2746           8 :         ndr_print_ptr(ndr, "w", r->w);
    2747           8 :         ndr->depth++;
    2748           8 :         if (r->w) {
    2749           8 :                 ndr_print_OP_PACKAGE_PART_COLLECTION_serialized_ptr(ndr, "w", r->w);
    2750             :         }
    2751           8 :         ndr->depth--;
    2752           8 :         ndr->depth--;
    2753             : }
    2754             : 
    2755          30 : static enum ndr_err_code ndr_push_OP_PACKAGE(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE *r)
    2756             : {
    2757          30 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2758          30 :         if (ndr_flags & NDR_SCALARS) {
    2759          30 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2760          30 :                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->EncryptionType));
    2761          30 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->EncryptionContext));
    2762          30 :                 NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION_blob(ndr, NDR_SCALARS, &r->WrappedPartCollection));
    2763          30 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbDecryptedPartCollection));
    2764          30 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
    2765          30 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2766             :         }
    2767          30 :         if (ndr_flags & NDR_BUFFERS) {
    2768          30 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->EncryptionContext));
    2769          30 :                 NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION_blob(ndr, NDR_BUFFERS, &r->WrappedPartCollection));
    2770          30 :                 NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
    2771             :         }
    2772          30 :         return NDR_ERR_SUCCESS;
    2773             : }
    2774             : 
    2775           8 : static enum ndr_err_code ndr_pull_OP_PACKAGE(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE *r)
    2776             : {
    2777           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2778           8 :         if (ndr_flags & NDR_SCALARS) {
    2779           8 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2780           8 :                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->EncryptionType));
    2781           8 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->EncryptionContext));
    2782           8 :                 NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION_blob(ndr, NDR_SCALARS, &r->WrappedPartCollection));
    2783           8 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbDecryptedPartCollection));
    2784           8 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
    2785           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2786             :         }
    2787           8 :         if (ndr_flags & NDR_BUFFERS) {
    2788           8 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->EncryptionContext));
    2789           8 :                 NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION_blob(ndr, NDR_BUFFERS, &r->WrappedPartCollection));
    2790           8 :                 NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
    2791             :         }
    2792           6 :         return NDR_ERR_SUCCESS;
    2793             : }
    2794             : 
    2795           8 : _PUBLIC_ void ndr_print_OP_PACKAGE(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE *r)
    2796             : {
    2797           8 :         ndr_print_struct(ndr, name, "OP_PACKAGE");
    2798           8 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2799           8 :         ndr->depth++;
    2800           8 :         ndr_print_GUID(ndr, "EncryptionType", &r->EncryptionType);
    2801           8 :         ndr_print_OP_BLOB(ndr, "EncryptionContext", &r->EncryptionContext);
    2802           8 :         ndr_print_OP_PACKAGE_PART_COLLECTION_blob(ndr, "WrappedPartCollection", &r->WrappedPartCollection);
    2803           8 :         ndr_print_uint32(ndr, "cbDecryptedPartCollection", r->cbDecryptedPartCollection);
    2804           8 :         ndr_print_OP_BLOB(ndr, "Extension", &r->Extension);
    2805           8 :         ndr->depth--;
    2806             : }
    2807             : 
    2808          30 : _PUBLIC_ enum ndr_err_code ndr_push_OP_PACKAGE_ctr(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE_ctr *r)
    2809             : {
    2810          30 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2811          30 :         if (ndr_flags & NDR_SCALARS) {
    2812          30 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2813          30 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
    2814          30 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2815             :         }
    2816          30 :         if (ndr_flags & NDR_BUFFERS) {
    2817          30 :                 if (r->p) {
    2818          30 :                         NDR_CHECK(ndr_push_OP_PACKAGE(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    2819             :                 }
    2820             :         }
    2821          30 :         return NDR_ERR_SUCCESS;
    2822             : }
    2823             : 
    2824           8 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_ctr(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE_ctr *r)
    2825             : {
    2826             :         uint32_t _ptr_p;
    2827           8 :         TALLOC_CTX *_mem_save_p_0 = NULL;
    2828           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2829           8 :         if (ndr_flags & NDR_SCALARS) {
    2830           8 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2831           8 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
    2832           8 :                 if (_ptr_p) {
    2833           8 :                         NDR_PULL_ALLOC(ndr, r->p);
    2834             :                 } else {
    2835           0 :                         r->p = NULL;
    2836             :                 }
    2837           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2838             :         }
    2839           8 :         if (ndr_flags & NDR_BUFFERS) {
    2840           8 :                 if (r->p) {
    2841           8 :                         _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2842           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
    2843           8 :                         NDR_CHECK(ndr_pull_OP_PACKAGE(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    2844           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
    2845             :                 }
    2846             :         }
    2847           6 :         return NDR_ERR_SUCCESS;
    2848             : }
    2849             : 
    2850           0 : static void ndr_print_flags_OP_PACKAGE_ctr(struct ndr_print *ndr, const char *name, int unused, const struct OP_PACKAGE_ctr *r)
    2851             : {
    2852           0 :         ndr_print_OP_PACKAGE_ctr(ndr, name, r);
    2853           0 : }
    2854             : 
    2855           8 : _PUBLIC_ void ndr_print_OP_PACKAGE_ctr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_ctr *r)
    2856             : {
    2857           8 :         ndr_print_struct(ndr, name, "OP_PACKAGE_ctr");
    2858           8 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2859           8 :         ndr->depth++;
    2860           8 :         ndr_print_ptr(ndr, "p", r->p);
    2861           8 :         ndr->depth++;
    2862           8 :         if (r->p) {
    2863           8 :                 ndr_print_OP_PACKAGE(ndr, "p", r->p);
    2864             :         }
    2865           8 :         ndr->depth--;
    2866           8 :         ndr->depth--;
    2867             : }
    2868             : 
    2869           0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_PACKAGE_serialized_ptr(struct ndr_push *ndr, int ndr_flags, const struct OP_PACKAGE_serialized_ptr *r)
    2870             : {
    2871           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2872           0 :         if (ndr_flags & NDR_SCALARS) {
    2873           0 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    2874             :                 {
    2875             :                         struct ndr_push *_ndr_s;
    2876           0 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    2877           0 :                         NDR_CHECK(ndr_push_OP_PACKAGE_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    2878           0 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    2879             :                 }
    2880           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    2881             :         }
    2882           0 :         if (ndr_flags & NDR_BUFFERS) {
    2883             :         }
    2884           0 :         return NDR_ERR_SUCCESS;
    2885             : }
    2886             : 
    2887           0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_serialized_ptr(struct ndr_pull *ndr, int ndr_flags, struct OP_PACKAGE_serialized_ptr *r)
    2888             : {
    2889           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2890           0 :         if (ndr_flags & NDR_SCALARS) {
    2891           0 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    2892             :                 {
    2893             :                         struct ndr_pull *_ndr_s;
    2894           0 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    2895           0 :                         NDR_CHECK(ndr_pull_OP_PACKAGE_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    2896           0 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    2897             :                 }
    2898           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    2899             :         }
    2900           0 :         if (ndr_flags & NDR_BUFFERS) {
    2901             :         }
    2902           0 :         return NDR_ERR_SUCCESS;
    2903             : }
    2904             : 
    2905           0 : static void ndr_print_flags_OP_PACKAGE_serialized_ptr(struct ndr_print *ndr, const char *name, int unused, const struct OP_PACKAGE_serialized_ptr *r)
    2906             : {
    2907           0 :         ndr_print_OP_PACKAGE_serialized_ptr(ndr, name, r);
    2908           0 : }
    2909             : 
    2910           0 : _PUBLIC_ void ndr_print_OP_PACKAGE_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_serialized_ptr *r)
    2911             : {
    2912           0 :         ndr_print_struct(ndr, name, "OP_PACKAGE_serialized_ptr");
    2913           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2914           0 :         ndr->depth++;
    2915           0 :         ndr_print_OP_PACKAGE_ctr(ndr, "s", &r->s);
    2916           0 :         ndr->depth--;
    2917             : }
    2918             : 
    2919           0 : _PUBLIC_ size_t ndr_size_OP_PACKAGE_serialized_ptr(const struct OP_PACKAGE_serialized_ptr *r, int flags)
    2920             : {
    2921           0 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_PACKAGE_serialized_ptr);
    2922             : }
    2923             : 
    2924          12 : _PUBLIC_ enum ndr_err_code ndr_push_ODJFormat(struct ndr_push *ndr, int ndr_flags, enum ODJFormat r)
    2925             : {
    2926          12 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    2927          12 :         return NDR_ERR_SUCCESS;
    2928             : }
    2929             : 
    2930          16 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJFormat(struct ndr_pull *ndr, int ndr_flags, enum ODJFormat *r)
    2931             : {
    2932             :         uint32_t v;
    2933          16 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    2934          16 :         *r = v;
    2935          16 :         return NDR_ERR_SUCCESS;
    2936             : }
    2937             : 
    2938          16 : _PUBLIC_ void ndr_print_ODJFormat(struct ndr_print *ndr, const char *name, enum ODJFormat r)
    2939             : {
    2940          16 :         const char *val = NULL;
    2941             : 
    2942          16 :         switch (r) {
    2943           8 :                 case ODJ_WIN7_FORMAT: val = "ODJ_WIN7_FORMAT"; break;
    2944           8 :                 case ODJ_WIN8_FORMAT: val = "ODJ_WIN8_FORMAT"; break;
    2945             :         }
    2946          16 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    2947          16 : }
    2948             : 
    2949          60 : _PUBLIC_ enum ndr_err_code ndr_push_ODJ_BLOB_u(struct ndr_push *ndr, int ndr_flags, const union ODJ_BLOB_u *r)
    2950             : {
    2951             :         uint32_t level;
    2952          60 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2953          60 :         if (ndr_flags & NDR_SCALARS) {
    2954             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    2955          60 :                 NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    2956          60 :                 NDR_CHECK(ndr_push_union_align(ndr, 1));
    2957          60 :                 switch (level) {
    2958          30 :                         case ODJ_WIN7_FORMAT: {
    2959          15 :                                 {
    2960             :                                         struct ndr_push *_ndr_odj_win7blob;
    2961          30 :                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_odj_win7blob, 0xFFFFFC01, -1));
    2962          30 :                                         NDR_CHECK(ndr_push_ODJ_WIN7BLOB(_ndr_odj_win7blob, NDR_SCALARS|NDR_BUFFERS, &r->odj_win7blob));
    2963          30 :                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_odj_win7blob, 0xFFFFFC01, -1));
    2964             :                                 }
    2965          30 :                         break; }
    2966             : 
    2967          30 :                         case ODJ_WIN8_FORMAT: {
    2968          15 :                                 {
    2969             :                                         struct ndr_push *_ndr_op_package;
    2970          30 :                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_op_package, 0xFFFFFC01, -1));
    2971          30 :                                         NDR_CHECK(ndr_push_OP_PACKAGE_ctr(_ndr_op_package, NDR_SCALARS|NDR_BUFFERS, &r->op_package));
    2972          30 :                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_op_package, 0xFFFFFC01, -1));
    2973             :                                 }
    2974          30 :                         break; }
    2975             : 
    2976           0 :                         default: {
    2977             :                                 {
    2978           0 :                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    2979           0 :                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    2980             :                                         {
    2981             :                                                 struct ndr_push *_ndr_blob;
    2982           0 :                                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_blob, 0xFFFFFC01, -1));
    2983           0 :                                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_blob, NDR_SCALARS, r->blob));
    2984           0 :                                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_blob, 0xFFFFFC01, -1));
    2985             :                                         }
    2986           0 :                                         ndr->flags = _flags_save_DATA_BLOB;
    2987             :                                 }
    2988           0 :                         break; }
    2989             : 
    2990             :                 }
    2991           0 :         }
    2992          60 :         if (ndr_flags & NDR_BUFFERS) {
    2993          60 :                 if (!(ndr_flags & NDR_SCALARS)) {
    2994             :                         /* We didn't get it above, and the token is not needed after this. */
    2995           0 :                         NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
    2996             :                 }
    2997          60 :                 switch (level) {
    2998          30 :                         case ODJ_WIN7_FORMAT:
    2999          30 :                         break;
    3000             : 
    3001          30 :                         case ODJ_WIN8_FORMAT:
    3002          30 :                         break;
    3003             : 
    3004           0 :                         default:
    3005           0 :                         break;
    3006             : 
    3007             :                 }
    3008           0 :         }
    3009          60 :         return NDR_ERR_SUCCESS;
    3010             : }
    3011             : 
    3012          16 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJ_BLOB_u(struct ndr_pull *ndr, int ndr_flags, union ODJ_BLOB_u *r)
    3013             : {
    3014             :         uint32_t level;
    3015          16 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3016          16 :         if (ndr_flags & NDR_SCALARS) {
    3017             :                 /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
    3018          16 :                 NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    3019          16 :                 NDR_CHECK(ndr_pull_union_align(ndr, 1));
    3020          16 :                 switch (level) {
    3021           8 :                         case ODJ_WIN7_FORMAT: {
    3022           5 :                                 {
    3023             :                                         struct ndr_pull *_ndr_odj_win7blob;
    3024           8 :                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_odj_win7blob, 0xFFFFFC01, -1));
    3025           8 :                                         NDR_CHECK(ndr_pull_ODJ_WIN7BLOB(_ndr_odj_win7blob, NDR_SCALARS|NDR_BUFFERS, &r->odj_win7blob));
    3026           8 :                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_odj_win7blob, 0xFFFFFC01, -1));
    3027             :                                 }
    3028           8 :                         break; }
    3029             : 
    3030           8 :                         case ODJ_WIN8_FORMAT: {
    3031           5 :                                 {
    3032             :                                         struct ndr_pull *_ndr_op_package;
    3033           8 :                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_op_package, 0xFFFFFC01, -1));
    3034           8 :                                         NDR_CHECK(ndr_pull_OP_PACKAGE_ctr(_ndr_op_package, NDR_SCALARS|NDR_BUFFERS, &r->op_package));
    3035           8 :                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_op_package, 0xFFFFFC01, -1));
    3036             :                                 }
    3037           8 :                         break; }
    3038             : 
    3039           0 :                         default: {
    3040             :                                 {
    3041           0 :                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    3042           0 :                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    3043             :                                         {
    3044             :                                                 struct ndr_pull *_ndr_blob;
    3045           0 :                                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_blob, 0xFFFFFC01, -1));
    3046           0 :                                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_blob, NDR_SCALARS, &r->blob));
    3047           0 :                                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_blob, 0xFFFFFC01, -1));
    3048             :                                         }
    3049           0 :                                         ndr->flags = _flags_save_DATA_BLOB;
    3050             :                                 }
    3051           0 :                         break; }
    3052             : 
    3053             :                 }
    3054           0 :         }
    3055          16 :         if (ndr_flags & NDR_BUFFERS) {
    3056          16 :                 if (!(ndr_flags & NDR_SCALARS)) {
    3057             :                         /* We didn't get it above, and the token is not needed after this. */
    3058           0 :                         NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
    3059             :                 }
    3060          12 :                 switch (level) {
    3061           6 :                         case ODJ_WIN7_FORMAT:
    3062           6 :                         break;
    3063             : 
    3064           6 :                         case ODJ_WIN8_FORMAT:
    3065           6 :                         break;
    3066             : 
    3067           0 :                         default:
    3068           0 :                         break;
    3069             : 
    3070             :                 }
    3071           0 :         }
    3072          12 :         return NDR_ERR_SUCCESS;
    3073             : }
    3074             : 
    3075          16 : _PUBLIC_ void ndr_print_ODJ_BLOB_u(struct ndr_print *ndr, const char *name, const union ODJ_BLOB_u *r)
    3076             : {
    3077             :         uint32_t level;
    3078          16 :         level = ndr_print_steal_switch_value(ndr, r);
    3079          16 :         ndr_print_union(ndr, name, level, "ODJ_BLOB_u");
    3080          16 :         switch (level) {
    3081           8 :                 case ODJ_WIN7_FORMAT:
    3082           8 :                         ndr_print_ODJ_WIN7BLOB(ndr, "odj_win7blob", &r->odj_win7blob);
    3083           8 :                 break;
    3084             : 
    3085           8 :                 case ODJ_WIN8_FORMAT:
    3086           8 :                         ndr_print_OP_PACKAGE_ctr(ndr, "op_package", &r->op_package);
    3087           8 :                 break;
    3088             : 
    3089           0 :                 default:
    3090             :                         {
    3091           0 :                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
    3092           0 :                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    3093           0 :                                 ndr_print_DATA_BLOB(ndr, "blob", r->blob);
    3094           0 :                                 ndr->flags = _flags_save_DATA_BLOB;
    3095             :                         }
    3096           0 :                 break;
    3097             : 
    3098             :         }
    3099          16 : }
    3100             : 
    3101          48 : _PUBLIC_ size_t ndr_size_ODJ_BLOB_u(const union ODJ_BLOB_u *r, uint32_t level, int flags)
    3102             : {
    3103          48 :         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_ODJ_BLOB_u);
    3104             : }
    3105             : 
    3106          24 : static enum ndr_err_code ndr_push_ODJ_BLOB(struct ndr_push *ndr, int ndr_flags, const struct ODJ_BLOB *r)
    3107             : {
    3108          24 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3109          24 :         if (ndr_flags & NDR_SCALARS) {
    3110          12 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    3111          12 :                 NDR_CHECK(ndr_push_ODJFormat(ndr, NDR_SCALARS, r->ulODJFormat));
    3112          12 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_ODJ_BLOB_u(r->pBlob, r->ulODJFormat, 0)));
    3113          12 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pBlob));
    3114          12 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    3115             :         }
    3116          24 :         if (ndr_flags & NDR_BUFFERS) {
    3117          12 :                 if (r->pBlob) {
    3118             :                         {
    3119             :                                 struct ndr_push *_ndr_pBlob;
    3120          12 :                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_pBlob, 4, ndr_size_ODJ_BLOB_u(r->pBlob, r->ulODJFormat, 0)));
    3121          12 :                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_pBlob, r->pBlob, r->ulODJFormat));
    3122          12 :                                 NDR_CHECK(ndr_push_ODJ_BLOB_u(_ndr_pBlob, NDR_SCALARS|NDR_BUFFERS, r->pBlob));
    3123          12 :                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_pBlob, 4, ndr_size_ODJ_BLOB_u(r->pBlob, r->ulODJFormat, 0)));
    3124             :                         }
    3125             :                 }
    3126             :         }
    3127          24 :         return NDR_ERR_SUCCESS;
    3128             : }
    3129             : 
    3130          32 : static enum ndr_err_code ndr_pull_ODJ_BLOB(struct ndr_pull *ndr, int ndr_flags, struct ODJ_BLOB *r)
    3131             : {
    3132             :         uint32_t _ptr_pBlob;
    3133          32 :         TALLOC_CTX *_mem_save_pBlob_0 = NULL;
    3134          32 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3135          32 :         if (ndr_flags & NDR_SCALARS) {
    3136          16 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    3137          16 :                 NDR_CHECK(ndr_pull_ODJFormat(ndr, NDR_SCALARS, &r->ulODJFormat));
    3138          16 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbBlob));
    3139          16 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pBlob));
    3140          16 :                 if (_ptr_pBlob) {
    3141          16 :                         NDR_PULL_ALLOC(ndr, r->pBlob);
    3142             :                 } else {
    3143           0 :                         r->pBlob = NULL;
    3144             :                 }
    3145          16 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    3146             :         }
    3147          32 :         if (ndr_flags & NDR_BUFFERS) {
    3148          16 :                 if (r->pBlob) {
    3149          16 :                         _mem_save_pBlob_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3150          16 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pBlob, 0);
    3151             :                         {
    3152             :                                 struct ndr_pull *_ndr_pBlob;
    3153          16 :                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_pBlob, 4, r->cbBlob));
    3154          16 :                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_pBlob, r->pBlob, r->ulODJFormat));
    3155          16 :                                 NDR_CHECK(ndr_pull_ODJ_BLOB_u(_ndr_pBlob, NDR_SCALARS|NDR_BUFFERS, r->pBlob));
    3156          16 :                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_pBlob, 4, r->cbBlob));
    3157             :                         }
    3158          16 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pBlob_0, 0);
    3159             :                 }
    3160             :         }
    3161          24 :         return NDR_ERR_SUCCESS;
    3162             : }
    3163             : 
    3164          16 : _PUBLIC_ void ndr_print_ODJ_BLOB(struct ndr_print *ndr, const char *name, const struct ODJ_BLOB *r)
    3165             : {
    3166          16 :         ndr_print_struct(ndr, name, "ODJ_BLOB");
    3167          16 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3168          16 :         ndr->depth++;
    3169          16 :         ndr_print_ODJFormat(ndr, "ulODJFormat", r->ulODJFormat);
    3170          16 :         ndr_print_uint32(ndr, "cbBlob", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_ODJ_BLOB_u(r->pBlob, r->ulODJFormat, 0):r->cbBlob);
    3171          16 :         ndr_print_ptr(ndr, "pBlob", r->pBlob);
    3172          16 :         ndr->depth++;
    3173          16 :         if (r->pBlob) {
    3174          16 :                 ndr_print_set_switch_value(ndr, r->pBlob, r->ulODJFormat);
    3175          16 :                 ndr_print_ODJ_BLOB_u(ndr, "pBlob", r->pBlob);
    3176             :         }
    3177          16 :         ndr->depth--;
    3178          16 :         ndr->depth--;
    3179             : }
    3180             : 
    3181           6 : _PUBLIC_ enum ndr_err_code ndr_push_ODJ_PROVISION_DATA(struct ndr_push *ndr, int ndr_flags, const struct ODJ_PROVISION_DATA *r)
    3182             : {
    3183             :         uint32_t cntr_pBlobs_1;
    3184           6 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3185           6 :         if (ndr_flags & NDR_SCALARS) {
    3186           6 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    3187           6 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
    3188           6 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulcBlobs));
    3189           6 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pBlobs));
    3190           6 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    3191             :         }
    3192           6 :         if (ndr_flags & NDR_BUFFERS) {
    3193           6 :                 if (r->pBlobs) {
    3194           6 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->ulcBlobs));
    3195          18 :                         for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (r->ulcBlobs); cntr_pBlobs_1++) {
    3196          12 :                                 NDR_CHECK(ndr_push_ODJ_BLOB(ndr, NDR_SCALARS, &r->pBlobs[cntr_pBlobs_1]));
    3197             :                         }
    3198          18 :                         for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (r->ulcBlobs); cntr_pBlobs_1++) {
    3199          12 :                                 NDR_CHECK(ndr_push_ODJ_BLOB(ndr, NDR_BUFFERS, &r->pBlobs[cntr_pBlobs_1]));
    3200             :                         }
    3201             :                 }
    3202             :         }
    3203           6 :         return NDR_ERR_SUCCESS;
    3204             : }
    3205             : 
    3206           8 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJ_PROVISION_DATA(struct ndr_pull *ndr, int ndr_flags, struct ODJ_PROVISION_DATA *r)
    3207             : {
    3208             :         uint32_t _ptr_pBlobs;
    3209           8 :         uint32_t size_pBlobs_1 = 0;
    3210             :         uint32_t cntr_pBlobs_1;
    3211           8 :         TALLOC_CTX *_mem_save_pBlobs_0 = NULL;
    3212           8 :         TALLOC_CTX *_mem_save_pBlobs_1 = NULL;
    3213           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3214           8 :         if (ndr_flags & NDR_SCALARS) {
    3215           8 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    3216           8 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulVersion));
    3217           8 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulcBlobs));
    3218           8 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pBlobs));
    3219           8 :                 if (_ptr_pBlobs) {
    3220           8 :                         NDR_PULL_ALLOC(ndr, r->pBlobs);
    3221             :                 } else {
    3222           0 :                         r->pBlobs = NULL;
    3223             :                 }
    3224           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    3225             :         }
    3226           8 :         if (ndr_flags & NDR_BUFFERS) {
    3227           8 :                 if (r->pBlobs) {
    3228           8 :                         _mem_save_pBlobs_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3229           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pBlobs, 0);
    3230           8 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pBlobs));
    3231           8 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pBlobs, &size_pBlobs_1));
    3232           8 :                         NDR_PULL_ALLOC_N(ndr, r->pBlobs, size_pBlobs_1);
    3233           8 :                         _mem_save_pBlobs_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3234           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pBlobs, 0);
    3235          24 :                         for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (size_pBlobs_1); cntr_pBlobs_1++) {
    3236          16 :                                 NDR_CHECK(ndr_pull_ODJ_BLOB(ndr, NDR_SCALARS, &r->pBlobs[cntr_pBlobs_1]));
    3237             :                         }
    3238          22 :                         for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (size_pBlobs_1); cntr_pBlobs_1++) {
    3239          16 :                                 NDR_CHECK(ndr_pull_ODJ_BLOB(ndr, NDR_BUFFERS, &r->pBlobs[cntr_pBlobs_1]));
    3240             :                         }
    3241           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pBlobs_1, 0);
    3242           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pBlobs_0, 0);
    3243             :                 }
    3244           8 :                 if (r->pBlobs) {
    3245           8 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pBlobs, r->ulcBlobs));
    3246             :                 }
    3247          14 :                 for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (size_pBlobs_1); cntr_pBlobs_1++) {
    3248             :                 }
    3249             :         }
    3250           6 :         return NDR_ERR_SUCCESS;
    3251             : }
    3252             : 
    3253           0 : static void ndr_print_flags_ODJ_PROVISION_DATA(struct ndr_print *ndr, const char *name, int unused, const struct ODJ_PROVISION_DATA *r)
    3254             : {
    3255           0 :         ndr_print_ODJ_PROVISION_DATA(ndr, name, r);
    3256           0 : }
    3257             : 
    3258           8 : _PUBLIC_ void ndr_print_ODJ_PROVISION_DATA(struct ndr_print *ndr, const char *name, const struct ODJ_PROVISION_DATA *r)
    3259             : {
    3260             :         uint32_t cntr_pBlobs_1;
    3261           8 :         ndr_print_struct(ndr, name, "ODJ_PROVISION_DATA");
    3262           8 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3263           8 :         ndr->depth++;
    3264           8 :         ndr_print_uint32(ndr, "ulVersion", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->ulVersion);
    3265           8 :         ndr_print_uint32(ndr, "ulcBlobs", r->ulcBlobs);
    3266           8 :         ndr_print_ptr(ndr, "pBlobs", r->pBlobs);
    3267           8 :         ndr->depth++;
    3268           8 :         if (r->pBlobs) {
    3269           8 :                 ndr->print(ndr, "%s: ARRAY(%d)", "pBlobs", (int)r->ulcBlobs);
    3270           8 :                 ndr->depth++;
    3271          24 :                 for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (r->ulcBlobs); cntr_pBlobs_1++) {
    3272          16 :                         ndr_print_ODJ_BLOB(ndr, "pBlobs", &r->pBlobs[cntr_pBlobs_1]);
    3273             :                 }
    3274           8 :                 ndr->depth--;
    3275             :         }
    3276           8 :         ndr->depth--;
    3277           8 :         ndr->depth--;
    3278             : }
    3279             : 
    3280           6 : _PUBLIC_ enum ndr_err_code ndr_push_ODJ_PROVISION_DATA_ctr(struct ndr_push *ndr, int ndr_flags, const struct ODJ_PROVISION_DATA_ctr *r)
    3281             : {
    3282           6 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3283           6 :         if (ndr_flags & NDR_SCALARS) {
    3284           6 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    3285           6 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
    3286           6 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    3287             :         }
    3288           6 :         if (ndr_flags & NDR_BUFFERS) {
    3289           6 :                 if (r->p) {
    3290           6 :                         NDR_CHECK(ndr_push_ODJ_PROVISION_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    3291             :                 }
    3292             :         }
    3293           6 :         return NDR_ERR_SUCCESS;
    3294             : }
    3295             : 
    3296           8 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJ_PROVISION_DATA_ctr(struct ndr_pull *ndr, int ndr_flags, struct ODJ_PROVISION_DATA_ctr *r)
    3297             : {
    3298             :         uint32_t _ptr_p;
    3299           8 :         TALLOC_CTX *_mem_save_p_0 = NULL;
    3300           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3301           8 :         if (ndr_flags & NDR_SCALARS) {
    3302           8 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    3303           8 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
    3304           8 :                 if (_ptr_p) {
    3305           8 :                         NDR_PULL_ALLOC(ndr, r->p);
    3306             :                 } else {
    3307           0 :                         r->p = NULL;
    3308             :                 }
    3309           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    3310             :         }
    3311           8 :         if (ndr_flags & NDR_BUFFERS) {
    3312           8 :                 if (r->p) {
    3313           8 :                         _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3314           8 :                         NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
    3315           8 :                         NDR_CHECK(ndr_pull_ODJ_PROVISION_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
    3316           8 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
    3317             :                 }
    3318             :         }
    3319           6 :         return NDR_ERR_SUCCESS;
    3320             : }
    3321             : 
    3322           0 : static void ndr_print_flags_ODJ_PROVISION_DATA_ctr(struct ndr_print *ndr, const char *name, int unused, const struct ODJ_PROVISION_DATA_ctr *r)
    3323             : {
    3324           0 :         ndr_print_ODJ_PROVISION_DATA_ctr(ndr, name, r);
    3325           0 : }
    3326             : 
    3327           2 : _PUBLIC_ void ndr_print_ODJ_PROVISION_DATA_ctr(struct ndr_print *ndr, const char *name, const struct ODJ_PROVISION_DATA_ctr *r)
    3328             : {
    3329           2 :         ndr_print_struct(ndr, name, "ODJ_PROVISION_DATA_ctr");
    3330           2 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3331           2 :         ndr->depth++;
    3332           2 :         ndr_print_ptr(ndr, "p", r->p);
    3333           2 :         ndr->depth++;
    3334           2 :         if (r->p) {
    3335           2 :                 ndr_print_ODJ_PROVISION_DATA(ndr, "p", r->p);
    3336             :         }
    3337           2 :         ndr->depth--;
    3338           2 :         ndr->depth--;
    3339             : }
    3340             : 
    3341           6 : _PUBLIC_ enum ndr_err_code ndr_push_ODJ_PROVISION_DATA_serialized_ptr(struct ndr_push *ndr, int ndr_flags, const struct ODJ_PROVISION_DATA_serialized_ptr *r)
    3342             : {
    3343           6 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    3344           6 :         if (ndr_flags & NDR_SCALARS) {
    3345           6 :                 NDR_CHECK(ndr_push_align(ndr, 1));
    3346             :                 {
    3347             :                         struct ndr_push *_ndr_s;
    3348           6 :                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    3349           6 :                         NDR_CHECK(ndr_push_ODJ_PROVISION_DATA_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    3350           6 :                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    3351             :                 }
    3352           6 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
    3353             :         }
    3354           6 :         if (ndr_flags & NDR_BUFFERS) {
    3355             :         }
    3356           6 :         return NDR_ERR_SUCCESS;
    3357             : }
    3358             : 
    3359           8 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJ_PROVISION_DATA_serialized_ptr(struct ndr_pull *ndr, int ndr_flags, struct ODJ_PROVISION_DATA_serialized_ptr *r)
    3360             : {
    3361           8 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    3362           8 :         if (ndr_flags & NDR_SCALARS) {
    3363           8 :                 NDR_CHECK(ndr_pull_align(ndr, 1));
    3364             :                 {
    3365             :                         struct ndr_pull *_ndr_s;
    3366           8 :                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
    3367           8 :                         NDR_CHECK(ndr_pull_ODJ_PROVISION_DATA_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
    3368           8 :                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
    3369             :                 }
    3370           8 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
    3371             :         }
    3372           6 :         if (ndr_flags & NDR_BUFFERS) {
    3373             :         }
    3374           8 :         return NDR_ERR_SUCCESS;
    3375             : }
    3376             : 
    3377           0 : static void ndr_print_flags_ODJ_PROVISION_DATA_serialized_ptr(struct ndr_print *ndr, const char *name, int unused, const struct ODJ_PROVISION_DATA_serialized_ptr *r)
    3378             : {
    3379           0 :         ndr_print_ODJ_PROVISION_DATA_serialized_ptr(ndr, name, r);
    3380           0 : }
    3381             : 
    3382           2 : _PUBLIC_ void ndr_print_ODJ_PROVISION_DATA_serialized_ptr(struct ndr_print *ndr, const char *name, const struct ODJ_PROVISION_DATA_serialized_ptr *r)
    3383             : {
    3384           2 :         ndr_print_struct(ndr, name, "ODJ_PROVISION_DATA_serialized_ptr");
    3385           2 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3386           2 :         ndr->depth++;
    3387           2 :         ndr_print_ODJ_PROVISION_DATA_ctr(ndr, "s", &r->s);
    3388           2 :         ndr->depth--;
    3389             : }
    3390             : 
    3391           0 : _PUBLIC_ size_t ndr_size_ODJ_PROVISION_DATA_serialized_ptr(const struct ODJ_PROVISION_DATA_serialized_ptr *r, int flags)
    3392             : {
    3393           0 :         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ODJ_PROVISION_DATA_serialized_ptr);
    3394             : }
    3395             : 
    3396             : #ifndef SKIP_NDR_TABLE_ODJ
    3397             : static const struct ndr_interface_public_struct ODJ_public_structs[] = {
    3398             :         {
    3399             :                 .name = "ODJ_WIN7BLOB_ctr",
    3400             :                 .struct_size = sizeof(struct ODJ_WIN7BLOB_ctr ),
    3401             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_WIN7BLOB_ctr,
    3402             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_WIN7BLOB_ctr,
    3403             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_WIN7BLOB_ctr,
    3404             :         },
    3405             :         {
    3406             :                 .name = "ODJ_WIN7BLOB_serialized_ptr",
    3407             :                 .struct_size = sizeof(struct ODJ_WIN7BLOB_serialized_ptr ),
    3408             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_WIN7BLOB_serialized_ptr,
    3409             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_WIN7BLOB_serialized_ptr,
    3410             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_WIN7BLOB_serialized_ptr,
    3411             :         },
    3412             :         {
    3413             :                 .name = "OP_JOINPROV2_PART_ctr",
    3414             :                 .struct_size = sizeof(struct OP_JOINPROV2_PART_ctr ),
    3415             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_JOINPROV2_PART_ctr,
    3416             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_JOINPROV2_PART_ctr,
    3417             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_JOINPROV2_PART_ctr,
    3418             :         },
    3419             :         {
    3420             :                 .name = "OP_JOINPROV2_PART_serialized_ptr",
    3421             :                 .struct_size = sizeof(struct OP_JOINPROV2_PART_serialized_ptr ),
    3422             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_JOINPROV2_PART_serialized_ptr,
    3423             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_JOINPROV2_PART_serialized_ptr,
    3424             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_JOINPROV2_PART_serialized_ptr,
    3425             :         },
    3426             :         {
    3427             :                 .name = "OP_JOINPROV3_PART_ctr",
    3428             :                 .struct_size = sizeof(struct OP_JOINPROV3_PART_ctr ),
    3429             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_JOINPROV3_PART_ctr,
    3430             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_JOINPROV3_PART_ctr,
    3431             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_JOINPROV3_PART_ctr,
    3432             :         },
    3433             :         {
    3434             :                 .name = "OP_JOINPROV3_PART_serialized_ptr",
    3435             :                 .struct_size = sizeof(struct OP_JOINPROV3_PART_serialized_ptr ),
    3436             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_JOINPROV3_PART_serialized_ptr,
    3437             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_JOINPROV3_PART_serialized_ptr,
    3438             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_JOINPROV3_PART_serialized_ptr,
    3439             :         },
    3440             :         {
    3441             :                 .name = "OP_POLICY_PART_ctr",
    3442             :                 .struct_size = sizeof(struct OP_POLICY_PART_ctr ),
    3443             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_POLICY_PART_ctr,
    3444             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_POLICY_PART_ctr,
    3445             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_POLICY_PART_ctr,
    3446             :         },
    3447             :         {
    3448             :                 .name = "OP_POLICY_PART_serialized_ptr",
    3449             :                 .struct_size = sizeof(struct OP_POLICY_PART_serialized_ptr ),
    3450             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_POLICY_PART_serialized_ptr,
    3451             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_POLICY_PART_serialized_ptr,
    3452             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_POLICY_PART_serialized_ptr,
    3453             :         },
    3454             :         {
    3455             :                 .name = "OP_CERT_PART_ctr",
    3456             :                 .struct_size = sizeof(struct OP_CERT_PART_ctr ),
    3457             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_CERT_PART_ctr,
    3458             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_CERT_PART_ctr,
    3459             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_CERT_PART_ctr,
    3460             :         },
    3461             :         {
    3462             :                 .name = "OP_CERT_PART_serialized_ptr",
    3463             :                 .struct_size = sizeof(struct OP_CERT_PART_serialized_ptr ),
    3464             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_CERT_PART_serialized_ptr,
    3465             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_CERT_PART_serialized_ptr,
    3466             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_CERT_PART_serialized_ptr,
    3467             :         },
    3468             :         {
    3469             :                 .name = "OP_PACKAGE_PART_ctr",
    3470             :                 .struct_size = sizeof(struct OP_PACKAGE_PART_ctr ),
    3471             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_PART_ctr,
    3472             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_PART_ctr,
    3473             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_PART_ctr,
    3474             :         },
    3475             :         {
    3476             :                 .name = "OP_PACKAGE_PART_serialized_ptr",
    3477             :                 .struct_size = sizeof(struct OP_PACKAGE_PART_serialized_ptr ),
    3478             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_PART_serialized_ptr,
    3479             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_PART_serialized_ptr,
    3480             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_PART_serialized_ptr,
    3481             :         },
    3482             :         {
    3483             :                 .name = "OP_PACKAGE_PART_COLLECTION_ctr",
    3484             :                 .struct_size = sizeof(struct OP_PACKAGE_PART_COLLECTION_ctr ),
    3485             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_PART_COLLECTION_ctr,
    3486             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_PART_COLLECTION_ctr,
    3487             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_PART_COLLECTION_ctr,
    3488             :         },
    3489             :         {
    3490             :                 .name = "OP_PACKAGE_PART_COLLECTION_serialized_ptr",
    3491             :                 .struct_size = sizeof(struct OP_PACKAGE_PART_COLLECTION_serialized_ptr ),
    3492             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_PART_COLLECTION_serialized_ptr,
    3493             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_PART_COLLECTION_serialized_ptr,
    3494             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_PART_COLLECTION_serialized_ptr,
    3495             :         },
    3496             :         {
    3497             :                 .name = "OP_PACKAGE_ctr",
    3498             :                 .struct_size = sizeof(struct OP_PACKAGE_ctr ),
    3499             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_ctr,
    3500             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_ctr,
    3501             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_ctr,
    3502             :         },
    3503             :         {
    3504             :                 .name = "OP_PACKAGE_serialized_ptr",
    3505             :                 .struct_size = sizeof(struct OP_PACKAGE_serialized_ptr ),
    3506             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_serialized_ptr,
    3507             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_serialized_ptr,
    3508             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_serialized_ptr,
    3509             :         },
    3510             :         {
    3511             :                 .name = "ODJ_PROVISION_DATA",
    3512             :                 .struct_size = sizeof(struct ODJ_PROVISION_DATA ),
    3513             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_PROVISION_DATA,
    3514             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_PROVISION_DATA,
    3515             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_PROVISION_DATA,
    3516             :         },
    3517             :         {
    3518             :                 .name = "ODJ_PROVISION_DATA_ctr",
    3519             :                 .struct_size = sizeof(struct ODJ_PROVISION_DATA_ctr ),
    3520             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_PROVISION_DATA_ctr,
    3521             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_PROVISION_DATA_ctr,
    3522             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_PROVISION_DATA_ctr,
    3523             :         },
    3524             :         {
    3525             :                 .name = "ODJ_PROVISION_DATA_serialized_ptr",
    3526             :                 .struct_size = sizeof(struct ODJ_PROVISION_DATA_serialized_ptr ),
    3527             :                 .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_PROVISION_DATA_serialized_ptr,
    3528             :                 .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_PROVISION_DATA_serialized_ptr,
    3529             :                 .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_PROVISION_DATA_serialized_ptr,
    3530             :         },
    3531             :         { .name = NULL }
    3532             : };
    3533             : 
    3534             : static const struct ndr_interface_call ODJ_calls[] = {
    3535             :         { .name = NULL }
    3536             : };
    3537             : 
    3538             : static const char * const ODJ_endpoint_strings[] = {
    3539             :         "ncacn_np:[\\pipe\\ODJ]", 
    3540             : };
    3541             : 
    3542             : static const struct ndr_interface_string_array ODJ_endpoints = {
    3543             :         .count  = 1,
    3544             :         .names  = ODJ_endpoint_strings
    3545             : };
    3546             : 
    3547             : static const char * const ODJ_authservice_strings[] = {
    3548             :         "host", 
    3549             : };
    3550             : 
    3551             : static const struct ndr_interface_string_array ODJ_authservices = {
    3552             :         .count  = 1,
    3553             :         .names  = ODJ_authservice_strings
    3554             : };
    3555             : 
    3556             : 
    3557             : const struct ndr_interface_table ndr_table_ODJ = {
    3558             :         .name           = "ODJ",
    3559             :         .syntax_id      = {
    3560             :                 {0x11111111,0x3333,0x5555,{0x77,0x77},{0x99,0x99,0x99,0x99}},
    3561             :                 NDR_ODJ_VERSION
    3562             :         },
    3563             :         .helpstring     = NDR_ODJ_HELPSTRING,
    3564             :         .num_calls      = 0,
    3565             :         .calls          = ODJ_calls,
    3566             :         .num_public_structs     = 19,
    3567             :         .public_structs         = ODJ_public_structs,
    3568             :         .endpoints      = &ODJ_endpoints,
    3569             :         .authservices   = &ODJ_authservices
    3570             : };
    3571             : 
    3572             : #endif /* SKIP_NDR_TABLE_ODJ */

Generated by: LCOV version 1.13