LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_efs.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 0 964 0.0 %
Date: 2021-09-23 10:06:22 Functions: 0 57 0.0 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_efs.h"
       5             : 
       6             : #include "librpc/gen_ndr/ndr_security.h"
       7           0 : static enum ndr_err_code ndr_push_EFS_HASH_BLOB(struct ndr_push *ndr, int ndr_flags, const struct EFS_HASH_BLOB *r)
       8             : {
       9           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      10           0 :         if (ndr_flags & NDR_SCALARS) {
      11           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
      12           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbData));
      13           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pbData));
      14           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
      15             :         }
      16           0 :         if (ndr_flags & NDR_BUFFERS) {
      17           0 :                 if (r->pbData) {
      18           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbData));
      19           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pbData, r->cbData));
      20             :                 }
      21             :         }
      22           0 :         return NDR_ERR_SUCCESS;
      23             : }
      24             : 
      25           0 : static enum ndr_err_code ndr_pull_EFS_HASH_BLOB(struct ndr_pull *ndr, int ndr_flags, struct EFS_HASH_BLOB *r)
      26             : {
      27             :         uint32_t _ptr_pbData;
      28           0 :         uint32_t size_pbData_1 = 0;
      29           0 :         TALLOC_CTX *_mem_save_pbData_0 = NULL;
      30           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      31           0 :         if (ndr_flags & NDR_SCALARS) {
      32           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
      33           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbData));
      34           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pbData));
      35           0 :                 if (_ptr_pbData) {
      36           0 :                         NDR_PULL_ALLOC(ndr, r->pbData);
      37             :                 } else {
      38           0 :                         r->pbData = NULL;
      39             :                 }
      40           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
      41             :         }
      42           0 :         if (ndr_flags & NDR_BUFFERS) {
      43           0 :                 if (r->pbData) {
      44           0 :                         _mem_save_pbData_0 = NDR_PULL_GET_MEM_CTX(ndr);
      45           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pbData, 0);
      46           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pbData));
      47           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pbData, &size_pbData_1));
      48           0 :                         NDR_PULL_ALLOC_N(ndr, r->pbData, size_pbData_1);
      49           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pbData, size_pbData_1));
      50           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pbData_0, 0);
      51             :                 }
      52           0 :                 if (r->pbData) {
      53           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->pbData, r->cbData));
      54             :                 }
      55             :         }
      56           0 :         return NDR_ERR_SUCCESS;
      57             : }
      58             : 
      59           0 : _PUBLIC_ void ndr_print_EFS_HASH_BLOB(struct ndr_print *ndr, const char *name, const struct EFS_HASH_BLOB *r)
      60             : {
      61           0 :         ndr_print_struct(ndr, name, "EFS_HASH_BLOB");
      62           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
      63           0 :         ndr->depth++;
      64           0 :         ndr_print_uint32(ndr, "cbData", r->cbData);
      65           0 :         ndr_print_ptr(ndr, "pbData", r->pbData);
      66           0 :         ndr->depth++;
      67           0 :         if (r->pbData) {
      68           0 :                 ndr_print_array_uint8(ndr, "pbData", r->pbData, r->cbData);
      69             :         }
      70           0 :         ndr->depth--;
      71           0 :         ndr->depth--;
      72             : }
      73             : 
      74           0 : static enum ndr_err_code ndr_push_ENCRYPTION_CERTIFICATE_HASH(struct ndr_push *ndr, int ndr_flags, const struct ENCRYPTION_CERTIFICATE_HASH *r)
      75             : {
      76           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      77           0 :         if (ndr_flags & NDR_SCALARS) {
      78           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
      79           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbTotalLength));
      80           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pUserSid));
      81           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pHash));
      82           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpDisplayInformation));
      83           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
      84             :         }
      85           0 :         if (ndr_flags & NDR_BUFFERS) {
      86           0 :                 if (r->pUserSid) {
      87           0 :                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->pUserSid));
      88             :                 }
      89           0 :                 if (r->pHash) {
      90           0 :                         NDR_CHECK(ndr_push_EFS_HASH_BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->pHash));
      91             :                 }
      92           0 :                 if (r->lpDisplayInformation) {
      93           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpDisplayInformation, CH_UTF16)));
      94           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
      95           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lpDisplayInformation, CH_UTF16)));
      96           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lpDisplayInformation, ndr_charset_length(r->lpDisplayInformation, CH_UTF16), sizeof(uint16_t), CH_UTF16));
      97             :                 }
      98             :         }
      99           0 :         return NDR_ERR_SUCCESS;
     100             : }
     101             : 
     102           0 : static enum ndr_err_code ndr_pull_ENCRYPTION_CERTIFICATE_HASH(struct ndr_pull *ndr, int ndr_flags, struct ENCRYPTION_CERTIFICATE_HASH *r)
     103             : {
     104             :         uint32_t _ptr_pUserSid;
     105           0 :         TALLOC_CTX *_mem_save_pUserSid_0 = NULL;
     106             :         uint32_t _ptr_pHash;
     107           0 :         TALLOC_CTX *_mem_save_pHash_0 = NULL;
     108             :         uint32_t _ptr_lpDisplayInformation;
     109           0 :         uint32_t size_lpDisplayInformation_1 = 0;
     110           0 :         uint32_t length_lpDisplayInformation_1 = 0;
     111           0 :         TALLOC_CTX *_mem_save_lpDisplayInformation_0 = NULL;
     112           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     113           0 :         if (ndr_flags & NDR_SCALARS) {
     114           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     115           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbTotalLength));
     116           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pUserSid));
     117           0 :                 if (_ptr_pUserSid) {
     118           0 :                         NDR_PULL_ALLOC(ndr, r->pUserSid);
     119             :                 } else {
     120           0 :                         r->pUserSid = NULL;
     121             :                 }
     122           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pHash));
     123           0 :                 if (_ptr_pHash) {
     124           0 :                         NDR_PULL_ALLOC(ndr, r->pHash);
     125             :                 } else {
     126           0 :                         r->pHash = NULL;
     127             :                 }
     128           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpDisplayInformation));
     129           0 :                 if (_ptr_lpDisplayInformation) {
     130           0 :                         NDR_PULL_ALLOC(ndr, r->lpDisplayInformation);
     131             :                 } else {
     132           0 :                         r->lpDisplayInformation = NULL;
     133             :                 }
     134           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     135             :         }
     136           0 :         if (ndr_flags & NDR_BUFFERS) {
     137           0 :                 if (r->pUserSid) {
     138           0 :                         _mem_save_pUserSid_0 = NDR_PULL_GET_MEM_CTX(ndr);
     139           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pUserSid, 0);
     140           0 :                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->pUserSid));
     141           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUserSid_0, 0);
     142             :                 }
     143           0 :                 if (r->pHash) {
     144           0 :                         _mem_save_pHash_0 = NDR_PULL_GET_MEM_CTX(ndr);
     145           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pHash, 0);
     146           0 :                         NDR_CHECK(ndr_pull_EFS_HASH_BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->pHash));
     147           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pHash_0, 0);
     148             :                 }
     149           0 :                 if (r->lpDisplayInformation) {
     150           0 :                         _mem_save_lpDisplayInformation_0 = NDR_PULL_GET_MEM_CTX(ndr);
     151           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->lpDisplayInformation, 0);
     152           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lpDisplayInformation));
     153           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lpDisplayInformation));
     154           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->lpDisplayInformation, &size_lpDisplayInformation_1));
     155           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->lpDisplayInformation, &length_lpDisplayInformation_1));
     156           0 :                         if (length_lpDisplayInformation_1 > size_lpDisplayInformation_1) {
     157           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpDisplayInformation_1, length_lpDisplayInformation_1);
     158             :                         }
     159           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpDisplayInformation_1, sizeof(uint16_t)));
     160           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lpDisplayInformation, length_lpDisplayInformation_1, sizeof(uint16_t), CH_UTF16));
     161           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpDisplayInformation_0, 0);
     162             :                 }
     163             :         }
     164           0 :         return NDR_ERR_SUCCESS;
     165             : }
     166             : 
     167           0 : _PUBLIC_ void ndr_print_ENCRYPTION_CERTIFICATE_HASH(struct ndr_print *ndr, const char *name, const struct ENCRYPTION_CERTIFICATE_HASH *r)
     168             : {
     169           0 :         ndr_print_struct(ndr, name, "ENCRYPTION_CERTIFICATE_HASH");
     170           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     171           0 :         ndr->depth++;
     172           0 :         ndr_print_uint32(ndr, "cbTotalLength", r->cbTotalLength);
     173           0 :         ndr_print_ptr(ndr, "pUserSid", r->pUserSid);
     174           0 :         ndr->depth++;
     175           0 :         if (r->pUserSid) {
     176           0 :                 ndr_print_dom_sid(ndr, "pUserSid", r->pUserSid);
     177             :         }
     178           0 :         ndr->depth--;
     179           0 :         ndr_print_ptr(ndr, "pHash", r->pHash);
     180           0 :         ndr->depth++;
     181           0 :         if (r->pHash) {
     182           0 :                 ndr_print_EFS_HASH_BLOB(ndr, "pHash", r->pHash);
     183             :         }
     184           0 :         ndr->depth--;
     185           0 :         ndr_print_ptr(ndr, "lpDisplayInformation", r->lpDisplayInformation);
     186           0 :         ndr->depth++;
     187           0 :         if (r->lpDisplayInformation) {
     188           0 :                 ndr_print_string(ndr, "lpDisplayInformation", r->lpDisplayInformation);
     189             :         }
     190           0 :         ndr->depth--;
     191           0 :         ndr->depth--;
     192             : }
     193             : 
     194           0 : static enum ndr_err_code ndr_push_ENCRYPTION_CERTIFICATE_HASH_LIST(struct ndr_push *ndr, int ndr_flags, const struct ENCRYPTION_CERTIFICATE_HASH_LIST *r)
     195             : {
     196             :         uint32_t cntr_pUsers_0;
     197           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     198           0 :         if (ndr_flags & NDR_SCALARS) {
     199           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->nCert_Hash));
     200           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     201           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nCert_Hash));
     202           0 :                 for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (r->nCert_Hash); cntr_pUsers_0++) {
     203           0 :                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->pUsers[cntr_pUsers_0]));
     204             :                 }
     205           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     206             :         }
     207           0 :         if (ndr_flags & NDR_BUFFERS) {
     208           0 :                 for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (r->nCert_Hash); cntr_pUsers_0++) {
     209           0 :                         if (r->pUsers[cntr_pUsers_0]) {
     210           0 :                                 NDR_CHECK(ndr_push_ENCRYPTION_CERTIFICATE_HASH(ndr, NDR_SCALARS|NDR_BUFFERS, r->pUsers[cntr_pUsers_0]));
     211             :                         }
     212             :                 }
     213             :         }
     214           0 :         return NDR_ERR_SUCCESS;
     215             : }
     216             : 
     217           0 : static enum ndr_err_code ndr_pull_ENCRYPTION_CERTIFICATE_HASH_LIST(struct ndr_pull *ndr, int ndr_flags, struct ENCRYPTION_CERTIFICATE_HASH_LIST *r)
     218             : {
     219             :         uint32_t _ptr_pUsers;
     220           0 :         uint32_t size_pUsers_0 = 0;
     221             :         uint32_t cntr_pUsers_0;
     222           0 :         TALLOC_CTX *_mem_save_pUsers_0 = NULL;
     223           0 :         TALLOC_CTX *_mem_save_pUsers_1 = NULL;
     224           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     225           0 :         if (ndr_flags & NDR_SCALARS) {
     226           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->pUsers));
     227           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     228           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nCert_Hash));
     229           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pUsers, &size_pUsers_0));
     230           0 :                 NDR_PULL_ALLOC_N(ndr, r->pUsers, size_pUsers_0);
     231           0 :                 _mem_save_pUsers_0 = NDR_PULL_GET_MEM_CTX(ndr);
     232           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->pUsers, 0);
     233           0 :                 for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (size_pUsers_0); cntr_pUsers_0++) {
     234           0 :                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pUsers));
     235           0 :                         if (_ptr_pUsers) {
     236           0 :                                 NDR_PULL_ALLOC(ndr, r->pUsers[cntr_pUsers_0]);
     237             :                         } else {
     238           0 :                                 r->pUsers[cntr_pUsers_0] = NULL;
     239             :                         }
     240             :                 }
     241           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_0, 0);
     242           0 :                 if (r->pUsers) {
     243           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pUsers, r->nCert_Hash));
     244             :                 }
     245           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     246             :         }
     247           0 :         if (ndr_flags & NDR_BUFFERS) {
     248           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pUsers, &size_pUsers_0));
     249           0 :                 _mem_save_pUsers_0 = NDR_PULL_GET_MEM_CTX(ndr);
     250           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->pUsers, 0);
     251           0 :                 for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (size_pUsers_0); cntr_pUsers_0++) {
     252           0 :                         if (r->pUsers[cntr_pUsers_0]) {
     253           0 :                                 _mem_save_pUsers_1 = NDR_PULL_GET_MEM_CTX(ndr);
     254           0 :                                 NDR_PULL_SET_MEM_CTX(ndr, r->pUsers[cntr_pUsers_0], 0);
     255           0 :                                 NDR_CHECK(ndr_pull_ENCRYPTION_CERTIFICATE_HASH(ndr, NDR_SCALARS|NDR_BUFFERS, r->pUsers[cntr_pUsers_0]));
     256           0 :                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_1, 0);
     257             :                         }
     258             :                 }
     259           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_0, 0);
     260           0 :                 for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (size_pUsers_0); cntr_pUsers_0++) {
     261             :                 }
     262             :         }
     263           0 :         return NDR_ERR_SUCCESS;
     264             : }
     265             : 
     266           0 : _PUBLIC_ void ndr_print_ENCRYPTION_CERTIFICATE_HASH_LIST(struct ndr_print *ndr, const char *name, const struct ENCRYPTION_CERTIFICATE_HASH_LIST *r)
     267             : {
     268             :         uint32_t cntr_pUsers_0;
     269           0 :         ndr_print_struct(ndr, name, "ENCRYPTION_CERTIFICATE_HASH_LIST");
     270           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     271           0 :         ndr->depth++;
     272           0 :         ndr_print_uint32(ndr, "nCert_Hash", r->nCert_Hash);
     273           0 :         ndr->print(ndr, "%s: ARRAY(%d)", "pUsers", (int)r->nCert_Hash);
     274           0 :         ndr->depth++;
     275           0 :         for (cntr_pUsers_0 = 0; cntr_pUsers_0 < (r->nCert_Hash); cntr_pUsers_0++) {
     276           0 :                 ndr_print_ptr(ndr, "pUsers", r->pUsers[cntr_pUsers_0]);
     277           0 :                 ndr->depth++;
     278           0 :                 if (r->pUsers[cntr_pUsers_0]) {
     279           0 :                         ndr_print_ENCRYPTION_CERTIFICATE_HASH(ndr, "pUsers", r->pUsers[cntr_pUsers_0]);
     280             :                 }
     281           0 :                 ndr->depth--;
     282             :         }
     283           0 :         ndr->depth--;
     284           0 :         ndr->depth--;
     285             : }
     286             : 
     287           0 : static enum ndr_err_code ndr_push_EFS_CERTIFICATE_BLOB(struct ndr_push *ndr, int ndr_flags, const struct EFS_CERTIFICATE_BLOB *r)
     288             : {
     289           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     290           0 :         if (ndr_flags & NDR_SCALARS) {
     291           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     292           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwCertEncodingType));
     293           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbData));
     294           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pbData));
     295           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     296             :         }
     297           0 :         if (ndr_flags & NDR_BUFFERS) {
     298           0 :                 if (r->pbData) {
     299           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbData));
     300           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pbData, r->cbData));
     301             :                 }
     302             :         }
     303           0 :         return NDR_ERR_SUCCESS;
     304             : }
     305             : 
     306           0 : static enum ndr_err_code ndr_pull_EFS_CERTIFICATE_BLOB(struct ndr_pull *ndr, int ndr_flags, struct EFS_CERTIFICATE_BLOB *r)
     307             : {
     308             :         uint32_t _ptr_pbData;
     309           0 :         uint32_t size_pbData_1 = 0;
     310           0 :         TALLOC_CTX *_mem_save_pbData_0 = NULL;
     311           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     312           0 :         if (ndr_flags & NDR_SCALARS) {
     313           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     314           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwCertEncodingType));
     315           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbData));
     316           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pbData));
     317           0 :                 if (_ptr_pbData) {
     318           0 :                         NDR_PULL_ALLOC(ndr, r->pbData);
     319             :                 } else {
     320           0 :                         r->pbData = NULL;
     321             :                 }
     322           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     323             :         }
     324           0 :         if (ndr_flags & NDR_BUFFERS) {
     325           0 :                 if (r->pbData) {
     326           0 :                         _mem_save_pbData_0 = NDR_PULL_GET_MEM_CTX(ndr);
     327           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pbData, 0);
     328           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pbData));
     329           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pbData, &size_pbData_1));
     330           0 :                         NDR_PULL_ALLOC_N(ndr, r->pbData, size_pbData_1);
     331           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pbData, size_pbData_1));
     332           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pbData_0, 0);
     333             :                 }
     334           0 :                 if (r->pbData) {
     335           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->pbData, r->cbData));
     336             :                 }
     337             :         }
     338           0 :         return NDR_ERR_SUCCESS;
     339             : }
     340             : 
     341           0 : _PUBLIC_ void ndr_print_EFS_CERTIFICATE_BLOB(struct ndr_print *ndr, const char *name, const struct EFS_CERTIFICATE_BLOB *r)
     342             : {
     343           0 :         ndr_print_struct(ndr, name, "EFS_CERTIFICATE_BLOB");
     344           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     345           0 :         ndr->depth++;
     346           0 :         ndr_print_uint32(ndr, "dwCertEncodingType", r->dwCertEncodingType);
     347           0 :         ndr_print_uint32(ndr, "cbData", r->cbData);
     348           0 :         ndr_print_ptr(ndr, "pbData", r->pbData);
     349           0 :         ndr->depth++;
     350           0 :         if (r->pbData) {
     351           0 :                 ndr_print_array_uint8(ndr, "pbData", r->pbData, r->cbData);
     352             :         }
     353           0 :         ndr->depth--;
     354           0 :         ndr->depth--;
     355             : }
     356             : 
     357           0 : static enum ndr_err_code ndr_push_ENCRYPTION_CERTIFICATE(struct ndr_push *ndr, int ndr_flags, const struct ENCRYPTION_CERTIFICATE *r)
     358             : {
     359           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     360           0 :         if (ndr_flags & NDR_SCALARS) {
     361           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     362           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->TotalLength));
     363           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pUserSid));
     364           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pCertBlob));
     365           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     366             :         }
     367           0 :         if (ndr_flags & NDR_BUFFERS) {
     368           0 :                 if (r->pUserSid) {
     369           0 :                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->pUserSid));
     370             :                 }
     371           0 :                 if (r->pCertBlob) {
     372           0 :                         NDR_CHECK(ndr_push_EFS_CERTIFICATE_BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->pCertBlob));
     373             :                 }
     374             :         }
     375           0 :         return NDR_ERR_SUCCESS;
     376             : }
     377             : 
     378           0 : static enum ndr_err_code ndr_pull_ENCRYPTION_CERTIFICATE(struct ndr_pull *ndr, int ndr_flags, struct ENCRYPTION_CERTIFICATE *r)
     379             : {
     380             :         uint32_t _ptr_pUserSid;
     381           0 :         TALLOC_CTX *_mem_save_pUserSid_0 = NULL;
     382             :         uint32_t _ptr_pCertBlob;
     383           0 :         TALLOC_CTX *_mem_save_pCertBlob_0 = NULL;
     384           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     385           0 :         if (ndr_flags & NDR_SCALARS) {
     386           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     387           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->TotalLength));
     388           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pUserSid));
     389           0 :                 if (_ptr_pUserSid) {
     390           0 :                         NDR_PULL_ALLOC(ndr, r->pUserSid);
     391             :                 } else {
     392           0 :                         r->pUserSid = NULL;
     393             :                 }
     394           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pCertBlob));
     395           0 :                 if (_ptr_pCertBlob) {
     396           0 :                         NDR_PULL_ALLOC(ndr, r->pCertBlob);
     397             :                 } else {
     398           0 :                         r->pCertBlob = NULL;
     399             :                 }
     400           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     401             :         }
     402           0 :         if (ndr_flags & NDR_BUFFERS) {
     403           0 :                 if (r->pUserSid) {
     404           0 :                         _mem_save_pUserSid_0 = NDR_PULL_GET_MEM_CTX(ndr);
     405           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pUserSid, 0);
     406           0 :                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->pUserSid));
     407           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUserSid_0, 0);
     408             :                 }
     409           0 :                 if (r->pCertBlob) {
     410           0 :                         _mem_save_pCertBlob_0 = NDR_PULL_GET_MEM_CTX(ndr);
     411           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pCertBlob, 0);
     412           0 :                         NDR_CHECK(ndr_pull_EFS_CERTIFICATE_BLOB(ndr, NDR_SCALARS|NDR_BUFFERS, r->pCertBlob));
     413           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pCertBlob_0, 0);
     414             :                 }
     415             :         }
     416           0 :         return NDR_ERR_SUCCESS;
     417             : }
     418             : 
     419           0 : _PUBLIC_ void ndr_print_ENCRYPTION_CERTIFICATE(struct ndr_print *ndr, const char *name, const struct ENCRYPTION_CERTIFICATE *r)
     420             : {
     421           0 :         ndr_print_struct(ndr, name, "ENCRYPTION_CERTIFICATE");
     422           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     423           0 :         ndr->depth++;
     424           0 :         ndr_print_uint32(ndr, "TotalLength", r->TotalLength);
     425           0 :         ndr_print_ptr(ndr, "pUserSid", r->pUserSid);
     426           0 :         ndr->depth++;
     427           0 :         if (r->pUserSid) {
     428           0 :                 ndr_print_dom_sid(ndr, "pUserSid", r->pUserSid);
     429             :         }
     430           0 :         ndr->depth--;
     431           0 :         ndr_print_ptr(ndr, "pCertBlob", r->pCertBlob);
     432           0 :         ndr->depth++;
     433           0 :         if (r->pCertBlob) {
     434           0 :                 ndr_print_EFS_CERTIFICATE_BLOB(ndr, "pCertBlob", r->pCertBlob);
     435             :         }
     436           0 :         ndr->depth--;
     437           0 :         ndr->depth--;
     438             : }
     439             : 
     440           0 : static enum ndr_err_code ndr_push_EfsRpcOpenFileRaw(struct ndr_push *ndr, int flags, const struct EfsRpcOpenFileRaw *r)
     441             : {
     442           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     443           0 :         if (flags & NDR_IN) {
     444           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
     445           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     446           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
     447           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     448           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Flags));
     449             :         }
     450           0 :         if (flags & NDR_OUT) {
     451           0 :                 if (r->out.pvContext == NULL) {
     452           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     453             :                 }
     454           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.pvContext));
     455           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     456             :         }
     457           0 :         return NDR_ERR_SUCCESS;
     458             : }
     459             : 
     460           0 : static enum ndr_err_code ndr_pull_EfsRpcOpenFileRaw(struct ndr_pull *ndr, int flags, struct EfsRpcOpenFileRaw *r)
     461             : {
     462           0 :         uint32_t size_FileName_0 = 0;
     463           0 :         uint32_t length_FileName_0 = 0;
     464           0 :         TALLOC_CTX *_mem_save_pvContext_0 = NULL;
     465           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     466           0 :         if (flags & NDR_IN) {
     467           0 :                 NDR_ZERO_STRUCT(r->out);
     468             : 
     469           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
     470           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
     471           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.FileName, &size_FileName_0));
     472           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.FileName, &length_FileName_0));
     473           0 :                 if (length_FileName_0 > size_FileName_0) {
     474           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
     475             :                 }
     476           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
     477           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
     478           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Flags));
     479           0 :                 NDR_PULL_ALLOC(ndr, r->out.pvContext);
     480           0 :                 NDR_ZERO_STRUCTP(r->out.pvContext);
     481             :         }
     482           0 :         if (flags & NDR_OUT) {
     483             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     484             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     485           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     486           0 :                         NDR_PULL_ALLOC(ndr, r->out.pvContext);
     487             :                 }
     488           0 :                 _mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
     489           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pvContext, LIBNDR_FLAG_REF_ALLOC);
     490           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.pvContext));
     491           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
     492           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     493             :         }
     494           0 :         return NDR_ERR_SUCCESS;
     495             : }
     496             : 
     497           0 : _PUBLIC_ void ndr_print_EfsRpcOpenFileRaw(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcOpenFileRaw *r)
     498             : {
     499           0 :         ndr_print_struct(ndr, name, "EfsRpcOpenFileRaw");
     500           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     501           0 :         ndr->depth++;
     502           0 :         if (flags & NDR_SET_VALUES) {
     503           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     504             :         }
     505           0 :         if (flags & NDR_IN) {
     506           0 :                 ndr_print_struct(ndr, "in", "EfsRpcOpenFileRaw");
     507           0 :                 ndr->depth++;
     508           0 :                 ndr_print_string(ndr, "FileName", r->in.FileName);
     509           0 :                 ndr_print_uint32(ndr, "Flags", r->in.Flags);
     510           0 :                 ndr->depth--;
     511             :         }
     512           0 :         if (flags & NDR_OUT) {
     513           0 :                 ndr_print_struct(ndr, "out", "EfsRpcOpenFileRaw");
     514           0 :                 ndr->depth++;
     515           0 :                 ndr_print_ptr(ndr, "pvContext", r->out.pvContext);
     516           0 :                 ndr->depth++;
     517           0 :                 ndr_print_policy_handle(ndr, "pvContext", r->out.pvContext);
     518           0 :                 ndr->depth--;
     519           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     520           0 :                 ndr->depth--;
     521             :         }
     522           0 :         ndr->depth--;
     523             : }
     524             : 
     525           0 : static enum ndr_err_code ndr_push_EfsRpcReadFileRaw(struct ndr_push *ndr, int flags, const struct EfsRpcReadFileRaw *r)
     526             : {
     527           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     528           0 :         if (flags & NDR_IN) {
     529           0 :                 if (r->in.pvContext == NULL) {
     530           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     531             :                 }
     532           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
     533             :         }
     534           0 :         if (flags & NDR_OUT) {
     535           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     536             :         }
     537           0 :         return NDR_ERR_SUCCESS;
     538             : }
     539             : 
     540           0 : static enum ndr_err_code ndr_pull_EfsRpcReadFileRaw(struct ndr_pull *ndr, int flags, struct EfsRpcReadFileRaw *r)
     541             : {
     542           0 :         TALLOC_CTX *_mem_save_pvContext_0 = NULL;
     543           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     544           0 :         if (flags & NDR_IN) {
     545           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     546           0 :                         NDR_PULL_ALLOC(ndr, r->in.pvContext);
     547             :                 }
     548           0 :                 _mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
     549           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pvContext, LIBNDR_FLAG_REF_ALLOC);
     550           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
     551           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
     552             :         }
     553           0 :         if (flags & NDR_OUT) {
     554             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     555             :                 if (r->in.pvContext == NULL) {
     556             :                         NDR_PULL_ALLOC(ndr, r->in.pvContext);
     557             :                         NDR_ZERO_STRUCTP(r->in.pvContext);
     558             :                 }
     559             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     560           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     561             :         }
     562           0 :         return NDR_ERR_SUCCESS;
     563             : }
     564             : 
     565           0 : _PUBLIC_ void ndr_print_EfsRpcReadFileRaw(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcReadFileRaw *r)
     566             : {
     567           0 :         ndr_print_struct(ndr, name, "EfsRpcReadFileRaw");
     568           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     569           0 :         ndr->depth++;
     570           0 :         if (flags & NDR_SET_VALUES) {
     571           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     572             :         }
     573           0 :         if (flags & NDR_IN) {
     574           0 :                 ndr_print_struct(ndr, "in", "EfsRpcReadFileRaw");
     575           0 :                 ndr->depth++;
     576           0 :                 ndr_print_ptr(ndr, "pvContext", r->in.pvContext);
     577           0 :                 ndr->depth++;
     578           0 :                 ndr_print_policy_handle(ndr, "pvContext", r->in.pvContext);
     579           0 :                 ndr->depth--;
     580           0 :                 ndr->depth--;
     581             :         }
     582           0 :         if (flags & NDR_OUT) {
     583           0 :                 ndr_print_struct(ndr, "out", "EfsRpcReadFileRaw");
     584           0 :                 ndr->depth++;
     585           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     586           0 :                 ndr->depth--;
     587             :         }
     588           0 :         ndr->depth--;
     589             : }
     590             : 
     591           0 : static enum ndr_err_code ndr_push_EfsRpcWriteFileRaw(struct ndr_push *ndr, int flags, const struct EfsRpcWriteFileRaw *r)
     592             : {
     593           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     594           0 :         if (flags & NDR_IN) {
     595           0 :                 if (r->in.pvContext == NULL) {
     596           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     597             :                 }
     598           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
     599             :         }
     600           0 :         if (flags & NDR_OUT) {
     601           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     602             :         }
     603           0 :         return NDR_ERR_SUCCESS;
     604             : }
     605             : 
     606           0 : static enum ndr_err_code ndr_pull_EfsRpcWriteFileRaw(struct ndr_pull *ndr, int flags, struct EfsRpcWriteFileRaw *r)
     607             : {
     608           0 :         TALLOC_CTX *_mem_save_pvContext_0 = NULL;
     609           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     610           0 :         if (flags & NDR_IN) {
     611           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     612           0 :                         NDR_PULL_ALLOC(ndr, r->in.pvContext);
     613             :                 }
     614           0 :                 _mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
     615           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pvContext, LIBNDR_FLAG_REF_ALLOC);
     616           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
     617           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
     618             :         }
     619           0 :         if (flags & NDR_OUT) {
     620             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     621             :                 if (r->in.pvContext == NULL) {
     622             :                         NDR_PULL_ALLOC(ndr, r->in.pvContext);
     623             :                         NDR_ZERO_STRUCTP(r->in.pvContext);
     624             :                 }
     625             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     626           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     627             :         }
     628           0 :         return NDR_ERR_SUCCESS;
     629             : }
     630             : 
     631           0 : _PUBLIC_ void ndr_print_EfsRpcWriteFileRaw(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcWriteFileRaw *r)
     632             : {
     633           0 :         ndr_print_struct(ndr, name, "EfsRpcWriteFileRaw");
     634           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     635           0 :         ndr->depth++;
     636           0 :         if (flags & NDR_SET_VALUES) {
     637           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     638             :         }
     639           0 :         if (flags & NDR_IN) {
     640           0 :                 ndr_print_struct(ndr, "in", "EfsRpcWriteFileRaw");
     641           0 :                 ndr->depth++;
     642           0 :                 ndr_print_ptr(ndr, "pvContext", r->in.pvContext);
     643           0 :                 ndr->depth++;
     644           0 :                 ndr_print_policy_handle(ndr, "pvContext", r->in.pvContext);
     645           0 :                 ndr->depth--;
     646           0 :                 ndr->depth--;
     647             :         }
     648           0 :         if (flags & NDR_OUT) {
     649           0 :                 ndr_print_struct(ndr, "out", "EfsRpcWriteFileRaw");
     650           0 :                 ndr->depth++;
     651           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     652           0 :                 ndr->depth--;
     653             :         }
     654           0 :         ndr->depth--;
     655             : }
     656             : 
     657           0 : static enum ndr_err_code ndr_push_EfsRpcCloseRaw(struct ndr_push *ndr, int flags, const struct EfsRpcCloseRaw *r)
     658             : {
     659           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     660           0 :         if (flags & NDR_IN) {
     661           0 :                 if (r->in.pvContext == NULL) {
     662           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     663             :                 }
     664           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
     665             :         }
     666           0 :         if (flags & NDR_OUT) {
     667           0 :                 if (r->out.pvContext == NULL) {
     668           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     669             :                 }
     670           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.pvContext));
     671             :         }
     672           0 :         return NDR_ERR_SUCCESS;
     673             : }
     674             : 
     675           0 : static enum ndr_err_code ndr_pull_EfsRpcCloseRaw(struct ndr_pull *ndr, int flags, struct EfsRpcCloseRaw *r)
     676             : {
     677           0 :         TALLOC_CTX *_mem_save_pvContext_0 = NULL;
     678           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     679           0 :         if (flags & NDR_IN) {
     680           0 :                 NDR_ZERO_STRUCT(r->out);
     681             : 
     682           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     683           0 :                         NDR_PULL_ALLOC(ndr, r->in.pvContext);
     684             :                 }
     685           0 :                 _mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
     686           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pvContext, LIBNDR_FLAG_REF_ALLOC);
     687           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.pvContext));
     688           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
     689           0 :                 NDR_PULL_ALLOC(ndr, r->out.pvContext);
     690           0 :                 *r->out.pvContext = *r->in.pvContext;
     691             :         }
     692           0 :         if (flags & NDR_OUT) {
     693             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     694             :                 if (r->in.pvContext == NULL) {
     695             :                         NDR_PULL_ALLOC(ndr, r->in.pvContext);
     696             :                         NDR_ZERO_STRUCTP(r->in.pvContext);
     697             :                 }
     698             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     699           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     700           0 :                         NDR_PULL_ALLOC(ndr, r->out.pvContext);
     701             :                 }
     702           0 :                 _mem_save_pvContext_0 = NDR_PULL_GET_MEM_CTX(ndr);
     703           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pvContext, LIBNDR_FLAG_REF_ALLOC);
     704           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.pvContext));
     705           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pvContext_0, LIBNDR_FLAG_REF_ALLOC);
     706             :         }
     707           0 :         return NDR_ERR_SUCCESS;
     708             : }
     709             : 
     710           0 : _PUBLIC_ void ndr_print_EfsRpcCloseRaw(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcCloseRaw *r)
     711             : {
     712           0 :         ndr_print_struct(ndr, name, "EfsRpcCloseRaw");
     713           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     714           0 :         ndr->depth++;
     715           0 :         if (flags & NDR_SET_VALUES) {
     716           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     717             :         }
     718           0 :         if (flags & NDR_IN) {
     719           0 :                 ndr_print_struct(ndr, "in", "EfsRpcCloseRaw");
     720           0 :                 ndr->depth++;
     721           0 :                 ndr_print_ptr(ndr, "pvContext", r->in.pvContext);
     722           0 :                 ndr->depth++;
     723           0 :                 ndr_print_policy_handle(ndr, "pvContext", r->in.pvContext);
     724           0 :                 ndr->depth--;
     725           0 :                 ndr->depth--;
     726             :         }
     727           0 :         if (flags & NDR_OUT) {
     728           0 :                 ndr_print_struct(ndr, "out", "EfsRpcCloseRaw");
     729           0 :                 ndr->depth++;
     730           0 :                 ndr_print_ptr(ndr, "pvContext", r->out.pvContext);
     731           0 :                 ndr->depth++;
     732           0 :                 ndr_print_policy_handle(ndr, "pvContext", r->out.pvContext);
     733           0 :                 ndr->depth--;
     734           0 :                 ndr->depth--;
     735             :         }
     736           0 :         ndr->depth--;
     737             : }
     738             : 
     739           0 : static enum ndr_err_code ndr_push_EfsRpcEncryptFileSrv(struct ndr_push *ndr, int flags, const struct EfsRpcEncryptFileSrv *r)
     740             : {
     741           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     742           0 :         if (flags & NDR_IN) {
     743           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Filename, CH_UTF16)));
     744           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     745           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Filename, CH_UTF16)));
     746           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Filename, ndr_charset_length(r->in.Filename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     747             :         }
     748           0 :         if (flags & NDR_OUT) {
     749           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     750             :         }
     751           0 :         return NDR_ERR_SUCCESS;
     752             : }
     753             : 
     754           0 : static enum ndr_err_code ndr_pull_EfsRpcEncryptFileSrv(struct ndr_pull *ndr, int flags, struct EfsRpcEncryptFileSrv *r)
     755             : {
     756           0 :         uint32_t size_Filename_0 = 0;
     757           0 :         uint32_t length_Filename_0 = 0;
     758           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     759           0 :         if (flags & NDR_IN) {
     760           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Filename));
     761           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Filename));
     762           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.Filename, &size_Filename_0));
     763           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.Filename, &length_Filename_0));
     764           0 :                 if (length_Filename_0 > size_Filename_0) {
     765           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Filename_0, length_Filename_0);
     766             :                 }
     767           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_Filename_0, sizeof(uint16_t)));
     768           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Filename, length_Filename_0, sizeof(uint16_t), CH_UTF16));
     769             :         }
     770           0 :         if (flags & NDR_OUT) {
     771             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     772             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     773           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     774             :         }
     775           0 :         return NDR_ERR_SUCCESS;
     776             : }
     777             : 
     778           0 : _PUBLIC_ void ndr_print_EfsRpcEncryptFileSrv(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcEncryptFileSrv *r)
     779             : {
     780           0 :         ndr_print_struct(ndr, name, "EfsRpcEncryptFileSrv");
     781           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     782           0 :         ndr->depth++;
     783           0 :         if (flags & NDR_SET_VALUES) {
     784           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     785             :         }
     786           0 :         if (flags & NDR_IN) {
     787           0 :                 ndr_print_struct(ndr, "in", "EfsRpcEncryptFileSrv");
     788           0 :                 ndr->depth++;
     789           0 :                 ndr_print_string(ndr, "Filename", r->in.Filename);
     790           0 :                 ndr->depth--;
     791             :         }
     792           0 :         if (flags & NDR_OUT) {
     793           0 :                 ndr_print_struct(ndr, "out", "EfsRpcEncryptFileSrv");
     794           0 :                 ndr->depth++;
     795           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     796           0 :                 ndr->depth--;
     797             :         }
     798           0 :         ndr->depth--;
     799             : }
     800             : 
     801           0 : static enum ndr_err_code ndr_push_EfsRpcDecryptFileSrv(struct ndr_push *ndr, int flags, const struct EfsRpcDecryptFileSrv *r)
     802             : {
     803           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     804           0 :         if (flags & NDR_IN) {
     805           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
     806           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     807           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
     808           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     809           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
     810             :         }
     811           0 :         if (flags & NDR_OUT) {
     812           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     813             :         }
     814           0 :         return NDR_ERR_SUCCESS;
     815             : }
     816             : 
     817           0 : static enum ndr_err_code ndr_pull_EfsRpcDecryptFileSrv(struct ndr_pull *ndr, int flags, struct EfsRpcDecryptFileSrv *r)
     818             : {
     819           0 :         uint32_t size_FileName_0 = 0;
     820           0 :         uint32_t length_FileName_0 = 0;
     821           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     822           0 :         if (flags & NDR_IN) {
     823           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
     824           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
     825           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.FileName, &size_FileName_0));
     826           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.FileName, &length_FileName_0));
     827           0 :                 if (length_FileName_0 > size_FileName_0) {
     828           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
     829             :                 }
     830           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
     831           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
     832           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
     833             :         }
     834           0 :         if (flags & NDR_OUT) {
     835             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     836             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     837           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     838             :         }
     839           0 :         return NDR_ERR_SUCCESS;
     840             : }
     841             : 
     842           0 : _PUBLIC_ void ndr_print_EfsRpcDecryptFileSrv(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcDecryptFileSrv *r)
     843             : {
     844           0 :         ndr_print_struct(ndr, name, "EfsRpcDecryptFileSrv");
     845           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     846           0 :         ndr->depth++;
     847           0 :         if (flags & NDR_SET_VALUES) {
     848           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     849             :         }
     850           0 :         if (flags & NDR_IN) {
     851           0 :                 ndr_print_struct(ndr, "in", "EfsRpcDecryptFileSrv");
     852           0 :                 ndr->depth++;
     853           0 :                 ndr_print_string(ndr, "FileName", r->in.FileName);
     854           0 :                 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
     855           0 :                 ndr->depth--;
     856             :         }
     857           0 :         if (flags & NDR_OUT) {
     858           0 :                 ndr_print_struct(ndr, "out", "EfsRpcDecryptFileSrv");
     859           0 :                 ndr->depth++;
     860           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     861           0 :                 ndr->depth--;
     862             :         }
     863           0 :         ndr->depth--;
     864             : }
     865             : 
     866           0 : static enum ndr_err_code ndr_push_EfsRpcQueryUsersOnFile(struct ndr_push *ndr, int flags, const struct EfsRpcQueryUsersOnFile *r)
     867             : {
     868           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     869           0 :         if (flags & NDR_IN) {
     870           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
     871           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     872           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
     873           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     874             :         }
     875           0 :         if (flags & NDR_OUT) {
     876           0 :                 if (r->out.pUsers == NULL) {
     877           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     878             :                 }
     879           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.pUsers));
     880           0 :                 if (*r->out.pUsers) {
     881           0 :                         NDR_CHECK(ndr_push_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.pUsers));
     882             :                 }
     883           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     884             :         }
     885           0 :         return NDR_ERR_SUCCESS;
     886             : }
     887             : 
     888           0 : static enum ndr_err_code ndr_pull_EfsRpcQueryUsersOnFile(struct ndr_pull *ndr, int flags, struct EfsRpcQueryUsersOnFile *r)
     889             : {
     890           0 :         uint32_t size_FileName_0 = 0;
     891           0 :         uint32_t length_FileName_0 = 0;
     892             :         uint32_t _ptr_pUsers;
     893           0 :         TALLOC_CTX *_mem_save_pUsers_0 = NULL;
     894           0 :         TALLOC_CTX *_mem_save_pUsers_1 = NULL;
     895           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     896           0 :         if (flags & NDR_IN) {
     897           0 :                 NDR_ZERO_STRUCT(r->out);
     898             : 
     899           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
     900           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
     901           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.FileName, &size_FileName_0));
     902           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.FileName, &length_FileName_0));
     903           0 :                 if (length_FileName_0 > size_FileName_0) {
     904           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
     905             :                 }
     906           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
     907           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
     908           0 :                 NDR_PULL_ALLOC(ndr, r->out.pUsers);
     909           0 :                 NDR_ZERO_STRUCTP(r->out.pUsers);
     910             :         }
     911           0 :         if (flags & NDR_OUT) {
     912             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     913             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     914           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
     915           0 :                         NDR_PULL_ALLOC(ndr, r->out.pUsers);
     916             :                 }
     917           0 :                 _mem_save_pUsers_0 = NDR_PULL_GET_MEM_CTX(ndr);
     918           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pUsers, LIBNDR_FLAG_REF_ALLOC);
     919           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pUsers));
     920           0 :                 if (_ptr_pUsers) {
     921           0 :                         NDR_PULL_ALLOC(ndr, *r->out.pUsers);
     922             :                 } else {
     923           0 :                         *r->out.pUsers = NULL;
     924             :                 }
     925           0 :                 if (*r->out.pUsers) {
     926           0 :                         _mem_save_pUsers_1 = NDR_PULL_GET_MEM_CTX(ndr);
     927           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.pUsers, 0);
     928           0 :                         NDR_CHECK(ndr_pull_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.pUsers));
     929           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_1, 0);
     930             :                 }
     931           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pUsers_0, LIBNDR_FLAG_REF_ALLOC);
     932           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
     933             :         }
     934           0 :         return NDR_ERR_SUCCESS;
     935             : }
     936             : 
     937           0 : _PUBLIC_ void ndr_print_EfsRpcQueryUsersOnFile(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcQueryUsersOnFile *r)
     938             : {
     939           0 :         ndr_print_struct(ndr, name, "EfsRpcQueryUsersOnFile");
     940           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     941           0 :         ndr->depth++;
     942           0 :         if (flags & NDR_SET_VALUES) {
     943           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     944             :         }
     945           0 :         if (flags & NDR_IN) {
     946           0 :                 ndr_print_struct(ndr, "in", "EfsRpcQueryUsersOnFile");
     947           0 :                 ndr->depth++;
     948           0 :                 ndr_print_string(ndr, "FileName", r->in.FileName);
     949           0 :                 ndr->depth--;
     950             :         }
     951           0 :         if (flags & NDR_OUT) {
     952           0 :                 ndr_print_struct(ndr, "out", "EfsRpcQueryUsersOnFile");
     953           0 :                 ndr->depth++;
     954           0 :                 ndr_print_ptr(ndr, "pUsers", r->out.pUsers);
     955           0 :                 ndr->depth++;
     956           0 :                 ndr_print_ptr(ndr, "pUsers", *r->out.pUsers);
     957           0 :                 ndr->depth++;
     958           0 :                 if (*r->out.pUsers) {
     959           0 :                         ndr_print_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, "pUsers", *r->out.pUsers);
     960             :                 }
     961           0 :                 ndr->depth--;
     962           0 :                 ndr->depth--;
     963           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
     964           0 :                 ndr->depth--;
     965             :         }
     966           0 :         ndr->depth--;
     967             : }
     968             : 
     969           0 : static enum ndr_err_code ndr_push_EfsRpcQueryRecoveryAgents(struct ndr_push *ndr, int flags, const struct EfsRpcQueryRecoveryAgents *r)
     970             : {
     971           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     972           0 :         if (flags & NDR_IN) {
     973           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
     974           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     975           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
     976           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     977             :         }
     978           0 :         if (flags & NDR_OUT) {
     979           0 :                 if (r->out.pRecoveryAgents == NULL) {
     980           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
     981             :                 }
     982           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.pRecoveryAgents));
     983           0 :                 if (*r->out.pRecoveryAgents) {
     984           0 :                         NDR_CHECK(ndr_push_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.pRecoveryAgents));
     985             :                 }
     986           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
     987             :         }
     988           0 :         return NDR_ERR_SUCCESS;
     989             : }
     990             : 
     991           0 : static enum ndr_err_code ndr_pull_EfsRpcQueryRecoveryAgents(struct ndr_pull *ndr, int flags, struct EfsRpcQueryRecoveryAgents *r)
     992             : {
     993           0 :         uint32_t size_FileName_0 = 0;
     994           0 :         uint32_t length_FileName_0 = 0;
     995             :         uint32_t _ptr_pRecoveryAgents;
     996           0 :         TALLOC_CTX *_mem_save_pRecoveryAgents_0 = NULL;
     997           0 :         TALLOC_CTX *_mem_save_pRecoveryAgents_1 = NULL;
     998           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     999           0 :         if (flags & NDR_IN) {
    1000           0 :                 NDR_ZERO_STRUCT(r->out);
    1001             : 
    1002           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
    1003           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
    1004           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.FileName, &size_FileName_0));
    1005           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.FileName, &length_FileName_0));
    1006           0 :                 if (length_FileName_0 > size_FileName_0) {
    1007           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
    1008             :                 }
    1009           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
    1010           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
    1011           0 :                 NDR_PULL_ALLOC(ndr, r->out.pRecoveryAgents);
    1012           0 :                 NDR_ZERO_STRUCTP(r->out.pRecoveryAgents);
    1013             :         }
    1014           0 :         if (flags & NDR_OUT) {
    1015             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1016             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1017           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    1018           0 :                         NDR_PULL_ALLOC(ndr, r->out.pRecoveryAgents);
    1019             :                 }
    1020           0 :                 _mem_save_pRecoveryAgents_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1021           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pRecoveryAgents, LIBNDR_FLAG_REF_ALLOC);
    1022           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pRecoveryAgents));
    1023           0 :                 if (_ptr_pRecoveryAgents) {
    1024           0 :                         NDR_PULL_ALLOC(ndr, *r->out.pRecoveryAgents);
    1025             :                 } else {
    1026           0 :                         *r->out.pRecoveryAgents = NULL;
    1027             :                 }
    1028           0 :                 if (*r->out.pRecoveryAgents) {
    1029           0 :                         _mem_save_pRecoveryAgents_1 = NDR_PULL_GET_MEM_CTX(ndr);
    1030           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.pRecoveryAgents, 0);
    1031           0 :                         NDR_CHECK(ndr_pull_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.pRecoveryAgents));
    1032           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pRecoveryAgents_1, 0);
    1033             :                 }
    1034           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pRecoveryAgents_0, LIBNDR_FLAG_REF_ALLOC);
    1035           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1036             :         }
    1037           0 :         return NDR_ERR_SUCCESS;
    1038             : }
    1039             : 
    1040           0 : _PUBLIC_ void ndr_print_EfsRpcQueryRecoveryAgents(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcQueryRecoveryAgents *r)
    1041             : {
    1042           0 :         ndr_print_struct(ndr, name, "EfsRpcQueryRecoveryAgents");
    1043           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1044           0 :         ndr->depth++;
    1045           0 :         if (flags & NDR_SET_VALUES) {
    1046           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1047             :         }
    1048           0 :         if (flags & NDR_IN) {
    1049           0 :                 ndr_print_struct(ndr, "in", "EfsRpcQueryRecoveryAgents");
    1050           0 :                 ndr->depth++;
    1051           0 :                 ndr_print_string(ndr, "FileName", r->in.FileName);
    1052           0 :                 ndr->depth--;
    1053             :         }
    1054           0 :         if (flags & NDR_OUT) {
    1055           0 :                 ndr_print_struct(ndr, "out", "EfsRpcQueryRecoveryAgents");
    1056           0 :                 ndr->depth++;
    1057           0 :                 ndr_print_ptr(ndr, "pRecoveryAgents", r->out.pRecoveryAgents);
    1058           0 :                 ndr->depth++;
    1059           0 :                 ndr_print_ptr(ndr, "pRecoveryAgents", *r->out.pRecoveryAgents);
    1060           0 :                 ndr->depth++;
    1061           0 :                 if (*r->out.pRecoveryAgents) {
    1062           0 :                         ndr_print_ENCRYPTION_CERTIFICATE_HASH_LIST(ndr, "pRecoveryAgents", *r->out.pRecoveryAgents);
    1063             :                 }
    1064           0 :                 ndr->depth--;
    1065           0 :                 ndr->depth--;
    1066           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1067           0 :                 ndr->depth--;
    1068             :         }
    1069           0 :         ndr->depth--;
    1070             : }
    1071             : 
    1072           0 : static enum ndr_err_code ndr_push_EfsRpcRemoveUsersFromFile(struct ndr_push *ndr, int flags, const struct EfsRpcRemoveUsersFromFile *r)
    1073             : {
    1074           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1075           0 :         if (flags & NDR_IN) {
    1076           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
    1077           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1078           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
    1079           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1080             :         }
    1081           0 :         if (flags & NDR_OUT) {
    1082           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1083             :         }
    1084           0 :         return NDR_ERR_SUCCESS;
    1085             : }
    1086             : 
    1087           0 : static enum ndr_err_code ndr_pull_EfsRpcRemoveUsersFromFile(struct ndr_pull *ndr, int flags, struct EfsRpcRemoveUsersFromFile *r)
    1088             : {
    1089           0 :         uint32_t size_FileName_0 = 0;
    1090           0 :         uint32_t length_FileName_0 = 0;
    1091           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1092           0 :         if (flags & NDR_IN) {
    1093           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
    1094           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
    1095           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.FileName, &size_FileName_0));
    1096           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.FileName, &length_FileName_0));
    1097           0 :                 if (length_FileName_0 > size_FileName_0) {
    1098           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
    1099             :                 }
    1100           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
    1101           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
    1102             :         }
    1103           0 :         if (flags & NDR_OUT) {
    1104             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1105             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1106           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1107             :         }
    1108           0 :         return NDR_ERR_SUCCESS;
    1109             : }
    1110             : 
    1111           0 : _PUBLIC_ void ndr_print_EfsRpcRemoveUsersFromFile(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcRemoveUsersFromFile *r)
    1112             : {
    1113           0 :         ndr_print_struct(ndr, name, "EfsRpcRemoveUsersFromFile");
    1114           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1115           0 :         ndr->depth++;
    1116           0 :         if (flags & NDR_SET_VALUES) {
    1117           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1118             :         }
    1119           0 :         if (flags & NDR_IN) {
    1120           0 :                 ndr_print_struct(ndr, "in", "EfsRpcRemoveUsersFromFile");
    1121           0 :                 ndr->depth++;
    1122           0 :                 ndr_print_string(ndr, "FileName", r->in.FileName);
    1123           0 :                 ndr->depth--;
    1124             :         }
    1125           0 :         if (flags & NDR_OUT) {
    1126           0 :                 ndr_print_struct(ndr, "out", "EfsRpcRemoveUsersFromFile");
    1127           0 :                 ndr->depth++;
    1128           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1129           0 :                 ndr->depth--;
    1130             :         }
    1131           0 :         ndr->depth--;
    1132             : }
    1133             : 
    1134           0 : static enum ndr_err_code ndr_push_EfsRpcAddUsersToFile(struct ndr_push *ndr, int flags, const struct EfsRpcAddUsersToFile *r)
    1135             : {
    1136           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1137           0 :         if (flags & NDR_IN) {
    1138           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
    1139           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1140           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.FileName, CH_UTF16)));
    1141           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.FileName, ndr_charset_length(r->in.FileName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1142             :         }
    1143           0 :         if (flags & NDR_OUT) {
    1144           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1145             :         }
    1146           0 :         return NDR_ERR_SUCCESS;
    1147             : }
    1148             : 
    1149           0 : static enum ndr_err_code ndr_pull_EfsRpcAddUsersToFile(struct ndr_pull *ndr, int flags, struct EfsRpcAddUsersToFile *r)
    1150             : {
    1151           0 :         uint32_t size_FileName_0 = 0;
    1152           0 :         uint32_t length_FileName_0 = 0;
    1153           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1154           0 :         if (flags & NDR_IN) {
    1155           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.FileName));
    1156           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.FileName));
    1157           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.FileName, &size_FileName_0));
    1158           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.FileName, &length_FileName_0));
    1159           0 :                 if (length_FileName_0 > size_FileName_0) {
    1160           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_FileName_0, length_FileName_0);
    1161             :                 }
    1162           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_FileName_0, sizeof(uint16_t)));
    1163           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.FileName, length_FileName_0, sizeof(uint16_t), CH_UTF16));
    1164             :         }
    1165           0 :         if (flags & NDR_OUT) {
    1166             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1167             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1168           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1169             :         }
    1170           0 :         return NDR_ERR_SUCCESS;
    1171             : }
    1172             : 
    1173           0 : _PUBLIC_ void ndr_print_EfsRpcAddUsersToFile(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcAddUsersToFile *r)
    1174             : {
    1175           0 :         ndr_print_struct(ndr, name, "EfsRpcAddUsersToFile");
    1176           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1177           0 :         ndr->depth++;
    1178           0 :         if (flags & NDR_SET_VALUES) {
    1179           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1180             :         }
    1181           0 :         if (flags & NDR_IN) {
    1182           0 :                 ndr_print_struct(ndr, "in", "EfsRpcAddUsersToFile");
    1183           0 :                 ndr->depth++;
    1184           0 :                 ndr_print_string(ndr, "FileName", r->in.FileName);
    1185           0 :                 ndr->depth--;
    1186             :         }
    1187           0 :         if (flags & NDR_OUT) {
    1188           0 :                 ndr_print_struct(ndr, "out", "EfsRpcAddUsersToFile");
    1189           0 :                 ndr->depth++;
    1190           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1191           0 :                 ndr->depth--;
    1192             :         }
    1193           0 :         ndr->depth--;
    1194             : }
    1195             : 
    1196           0 : static enum ndr_err_code ndr_push_EfsRpcSetFileEncryptionKey(struct ndr_push *ndr, int flags, const struct EfsRpcSetFileEncryptionKey *r)
    1197             : {
    1198           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1199           0 :         if (flags & NDR_IN) {
    1200           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.pEncryptionCertificate));
    1201           0 :                 if (r->in.pEncryptionCertificate) {
    1202           0 :                         NDR_CHECK(ndr_push_ENCRYPTION_CERTIFICATE(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.pEncryptionCertificate));
    1203             :                 }
    1204             :         }
    1205           0 :         if (flags & NDR_OUT) {
    1206           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1207             :         }
    1208           0 :         return NDR_ERR_SUCCESS;
    1209             : }
    1210             : 
    1211           0 : static enum ndr_err_code ndr_pull_EfsRpcSetFileEncryptionKey(struct ndr_pull *ndr, int flags, struct EfsRpcSetFileEncryptionKey *r)
    1212             : {
    1213             :         uint32_t _ptr_pEncryptionCertificate;
    1214           0 :         TALLOC_CTX *_mem_save_pEncryptionCertificate_0 = NULL;
    1215           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1216           0 :         if (flags & NDR_IN) {
    1217           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pEncryptionCertificate));
    1218           0 :                 if (_ptr_pEncryptionCertificate) {
    1219           0 :                         NDR_PULL_ALLOC(ndr, r->in.pEncryptionCertificate);
    1220             :                 } else {
    1221           0 :                         r->in.pEncryptionCertificate = NULL;
    1222             :                 }
    1223           0 :                 if (r->in.pEncryptionCertificate) {
    1224           0 :                         _mem_save_pEncryptionCertificate_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1225           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.pEncryptionCertificate, 0);
    1226           0 :                         NDR_CHECK(ndr_pull_ENCRYPTION_CERTIFICATE(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.pEncryptionCertificate));
    1227           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pEncryptionCertificate_0, 0);
    1228             :                 }
    1229             :         }
    1230           0 :         if (flags & NDR_OUT) {
    1231             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1232             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1233           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1234             :         }
    1235           0 :         return NDR_ERR_SUCCESS;
    1236             : }
    1237             : 
    1238           0 : _PUBLIC_ void ndr_print_EfsRpcSetFileEncryptionKey(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcSetFileEncryptionKey *r)
    1239             : {
    1240           0 :         ndr_print_struct(ndr, name, "EfsRpcSetFileEncryptionKey");
    1241           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1242           0 :         ndr->depth++;
    1243           0 :         if (flags & NDR_SET_VALUES) {
    1244           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1245             :         }
    1246           0 :         if (flags & NDR_IN) {
    1247           0 :                 ndr_print_struct(ndr, "in", "EfsRpcSetFileEncryptionKey");
    1248           0 :                 ndr->depth++;
    1249           0 :                 ndr_print_ptr(ndr, "pEncryptionCertificate", r->in.pEncryptionCertificate);
    1250           0 :                 ndr->depth++;
    1251           0 :                 if (r->in.pEncryptionCertificate) {
    1252           0 :                         ndr_print_ENCRYPTION_CERTIFICATE(ndr, "pEncryptionCertificate", r->in.pEncryptionCertificate);
    1253             :                 }
    1254           0 :                 ndr->depth--;
    1255           0 :                 ndr->depth--;
    1256             :         }
    1257           0 :         if (flags & NDR_OUT) {
    1258           0 :                 ndr_print_struct(ndr, "out", "EfsRpcSetFileEncryptionKey");
    1259           0 :                 ndr->depth++;
    1260           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1261           0 :                 ndr->depth--;
    1262             :         }
    1263           0 :         ndr->depth--;
    1264             : }
    1265             : 
    1266           0 : static enum ndr_err_code ndr_push_EfsRpcNotSupported(struct ndr_push *ndr, int flags, const struct EfsRpcNotSupported *r)
    1267             : {
    1268           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1269           0 :         if (flags & NDR_IN) {
    1270             :         }
    1271           0 :         if (flags & NDR_OUT) {
    1272           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1273             :         }
    1274           0 :         return NDR_ERR_SUCCESS;
    1275             : }
    1276             : 
    1277           0 : static enum ndr_err_code ndr_pull_EfsRpcNotSupported(struct ndr_pull *ndr, int flags, struct EfsRpcNotSupported *r)
    1278             : {
    1279           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1280           0 :         if (flags & NDR_IN) {
    1281             :         }
    1282           0 :         if (flags & NDR_OUT) {
    1283             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1284             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1285           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1286             :         }
    1287           0 :         return NDR_ERR_SUCCESS;
    1288             : }
    1289             : 
    1290           0 : _PUBLIC_ void ndr_print_EfsRpcNotSupported(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcNotSupported *r)
    1291             : {
    1292           0 :         ndr_print_struct(ndr, name, "EfsRpcNotSupported");
    1293           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1294           0 :         ndr->depth++;
    1295           0 :         if (flags & NDR_SET_VALUES) {
    1296           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1297             :         }
    1298           0 :         if (flags & NDR_IN) {
    1299           0 :                 ndr_print_struct(ndr, "in", "EfsRpcNotSupported");
    1300           0 :                 ndr->depth++;
    1301           0 :                 ndr->depth--;
    1302             :         }
    1303           0 :         if (flags & NDR_OUT) {
    1304           0 :                 ndr_print_struct(ndr, "out", "EfsRpcNotSupported");
    1305           0 :                 ndr->depth++;
    1306           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1307           0 :                 ndr->depth--;
    1308             :         }
    1309           0 :         ndr->depth--;
    1310             : }
    1311             : 
    1312           0 : static enum ndr_err_code ndr_push_EfsRpcFileKeyInfo(struct ndr_push *ndr, int flags, const struct EfsRpcFileKeyInfo *r)
    1313             : {
    1314           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1315           0 :         if (flags & NDR_IN) {
    1316             :         }
    1317           0 :         if (flags & NDR_OUT) {
    1318           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1319             :         }
    1320           0 :         return NDR_ERR_SUCCESS;
    1321             : }
    1322             : 
    1323           0 : static enum ndr_err_code ndr_pull_EfsRpcFileKeyInfo(struct ndr_pull *ndr, int flags, struct EfsRpcFileKeyInfo *r)
    1324             : {
    1325           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1326           0 :         if (flags & NDR_IN) {
    1327             :         }
    1328           0 :         if (flags & NDR_OUT) {
    1329             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1330             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1331           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1332             :         }
    1333           0 :         return NDR_ERR_SUCCESS;
    1334             : }
    1335             : 
    1336           0 : _PUBLIC_ void ndr_print_EfsRpcFileKeyInfo(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcFileKeyInfo *r)
    1337             : {
    1338           0 :         ndr_print_struct(ndr, name, "EfsRpcFileKeyInfo");
    1339           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1340           0 :         ndr->depth++;
    1341           0 :         if (flags & NDR_SET_VALUES) {
    1342           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1343             :         }
    1344           0 :         if (flags & NDR_IN) {
    1345           0 :                 ndr_print_struct(ndr, "in", "EfsRpcFileKeyInfo");
    1346           0 :                 ndr->depth++;
    1347           0 :                 ndr->depth--;
    1348             :         }
    1349           0 :         if (flags & NDR_OUT) {
    1350           0 :                 ndr_print_struct(ndr, "out", "EfsRpcFileKeyInfo");
    1351           0 :                 ndr->depth++;
    1352           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1353           0 :                 ndr->depth--;
    1354             :         }
    1355           0 :         ndr->depth--;
    1356             : }
    1357             : 
    1358           0 : static enum ndr_err_code ndr_push_EfsRpcDuplicateEncryptionInfoFile(struct ndr_push *ndr, int flags, const struct EfsRpcDuplicateEncryptionInfoFile *r)
    1359             : {
    1360           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    1361           0 :         if (flags & NDR_IN) {
    1362             :         }
    1363           0 :         if (flags & NDR_OUT) {
    1364           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    1365             :         }
    1366           0 :         return NDR_ERR_SUCCESS;
    1367             : }
    1368             : 
    1369           0 : static enum ndr_err_code ndr_pull_EfsRpcDuplicateEncryptionInfoFile(struct ndr_pull *ndr, int flags, struct EfsRpcDuplicateEncryptionInfoFile *r)
    1370             : {
    1371           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    1372           0 :         if (flags & NDR_IN) {
    1373             :         }
    1374           0 :         if (flags & NDR_OUT) {
    1375             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    1376             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    1377           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    1378             :         }
    1379           0 :         return NDR_ERR_SUCCESS;
    1380             : }
    1381             : 
    1382           0 : _PUBLIC_ void ndr_print_EfsRpcDuplicateEncryptionInfoFile(struct ndr_print *ndr, const char *name, int flags, const struct EfsRpcDuplicateEncryptionInfoFile *r)
    1383             : {
    1384           0 :         ndr_print_struct(ndr, name, "EfsRpcDuplicateEncryptionInfoFile");
    1385           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1386           0 :         ndr->depth++;
    1387           0 :         if (flags & NDR_SET_VALUES) {
    1388           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    1389             :         }
    1390           0 :         if (flags & NDR_IN) {
    1391           0 :                 ndr_print_struct(ndr, "in", "EfsRpcDuplicateEncryptionInfoFile");
    1392           0 :                 ndr->depth++;
    1393           0 :                 ndr->depth--;
    1394             :         }
    1395           0 :         if (flags & NDR_OUT) {
    1396           0 :                 ndr_print_struct(ndr, "out", "EfsRpcDuplicateEncryptionInfoFile");
    1397           0 :                 ndr->depth++;
    1398           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    1399           0 :                 ndr->depth--;
    1400             :         }
    1401           0 :         ndr->depth--;
    1402             : }
    1403             : 
    1404             : #ifndef SKIP_NDR_TABLE_efs
    1405             : static const struct ndr_interface_public_struct efs_public_structs[] = {
    1406             :         { .name = NULL }
    1407             : };
    1408             : 
    1409             : static const struct ndr_interface_call efs_calls[] = {
    1410             :         {
    1411             :                 "EfsRpcOpenFileRaw",
    1412             :                 sizeof(struct EfsRpcOpenFileRaw),
    1413             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcOpenFileRaw,
    1414             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcOpenFileRaw,
    1415             :                 (ndr_print_function_t) ndr_print_EfsRpcOpenFileRaw,
    1416             :                 { 0, NULL },
    1417             :                 { 0, NULL },
    1418             :         },
    1419             :         {
    1420             :                 "EfsRpcReadFileRaw",
    1421             :                 sizeof(struct EfsRpcReadFileRaw),
    1422             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcReadFileRaw,
    1423             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcReadFileRaw,
    1424             :                 (ndr_print_function_t) ndr_print_EfsRpcReadFileRaw,
    1425             :                 { 0, NULL },
    1426             :                 { 0, NULL },
    1427             :         },
    1428             :         {
    1429             :                 "EfsRpcWriteFileRaw",
    1430             :                 sizeof(struct EfsRpcWriteFileRaw),
    1431             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcWriteFileRaw,
    1432             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcWriteFileRaw,
    1433             :                 (ndr_print_function_t) ndr_print_EfsRpcWriteFileRaw,
    1434             :                 { 0, NULL },
    1435             :                 { 0, NULL },
    1436             :         },
    1437             :         {
    1438             :                 "EfsRpcCloseRaw",
    1439             :                 sizeof(struct EfsRpcCloseRaw),
    1440             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcCloseRaw,
    1441             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcCloseRaw,
    1442             :                 (ndr_print_function_t) ndr_print_EfsRpcCloseRaw,
    1443             :                 { 0, NULL },
    1444             :                 { 0, NULL },
    1445             :         },
    1446             :         {
    1447             :                 "EfsRpcEncryptFileSrv",
    1448             :                 sizeof(struct EfsRpcEncryptFileSrv),
    1449             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcEncryptFileSrv,
    1450             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcEncryptFileSrv,
    1451             :                 (ndr_print_function_t) ndr_print_EfsRpcEncryptFileSrv,
    1452             :                 { 0, NULL },
    1453             :                 { 0, NULL },
    1454             :         },
    1455             :         {
    1456             :                 "EfsRpcDecryptFileSrv",
    1457             :                 sizeof(struct EfsRpcDecryptFileSrv),
    1458             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcDecryptFileSrv,
    1459             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcDecryptFileSrv,
    1460             :                 (ndr_print_function_t) ndr_print_EfsRpcDecryptFileSrv,
    1461             :                 { 0, NULL },
    1462             :                 { 0, NULL },
    1463             :         },
    1464             :         {
    1465             :                 "EfsRpcQueryUsersOnFile",
    1466             :                 sizeof(struct EfsRpcQueryUsersOnFile),
    1467             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcQueryUsersOnFile,
    1468             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcQueryUsersOnFile,
    1469             :                 (ndr_print_function_t) ndr_print_EfsRpcQueryUsersOnFile,
    1470             :                 { 0, NULL },
    1471             :                 { 0, NULL },
    1472             :         },
    1473             :         {
    1474             :                 "EfsRpcQueryRecoveryAgents",
    1475             :                 sizeof(struct EfsRpcQueryRecoveryAgents),
    1476             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcQueryRecoveryAgents,
    1477             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcQueryRecoveryAgents,
    1478             :                 (ndr_print_function_t) ndr_print_EfsRpcQueryRecoveryAgents,
    1479             :                 { 0, NULL },
    1480             :                 { 0, NULL },
    1481             :         },
    1482             :         {
    1483             :                 "EfsRpcRemoveUsersFromFile",
    1484             :                 sizeof(struct EfsRpcRemoveUsersFromFile),
    1485             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcRemoveUsersFromFile,
    1486             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcRemoveUsersFromFile,
    1487             :                 (ndr_print_function_t) ndr_print_EfsRpcRemoveUsersFromFile,
    1488             :                 { 0, NULL },
    1489             :                 { 0, NULL },
    1490             :         },
    1491             :         {
    1492             :                 "EfsRpcAddUsersToFile",
    1493             :                 sizeof(struct EfsRpcAddUsersToFile),
    1494             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcAddUsersToFile,
    1495             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcAddUsersToFile,
    1496             :                 (ndr_print_function_t) ndr_print_EfsRpcAddUsersToFile,
    1497             :                 { 0, NULL },
    1498             :                 { 0, NULL },
    1499             :         },
    1500             :         {
    1501             :                 "EfsRpcSetFileEncryptionKey",
    1502             :                 sizeof(struct EfsRpcSetFileEncryptionKey),
    1503             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcSetFileEncryptionKey,
    1504             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcSetFileEncryptionKey,
    1505             :                 (ndr_print_function_t) ndr_print_EfsRpcSetFileEncryptionKey,
    1506             :                 { 0, NULL },
    1507             :                 { 0, NULL },
    1508             :         },
    1509             :         {
    1510             :                 "EfsRpcNotSupported",
    1511             :                 sizeof(struct EfsRpcNotSupported),
    1512             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcNotSupported,
    1513             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcNotSupported,
    1514             :                 (ndr_print_function_t) ndr_print_EfsRpcNotSupported,
    1515             :                 { 0, NULL },
    1516             :                 { 0, NULL },
    1517             :         },
    1518             :         {
    1519             :                 "EfsRpcFileKeyInfo",
    1520             :                 sizeof(struct EfsRpcFileKeyInfo),
    1521             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcFileKeyInfo,
    1522             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcFileKeyInfo,
    1523             :                 (ndr_print_function_t) ndr_print_EfsRpcFileKeyInfo,
    1524             :                 { 0, NULL },
    1525             :                 { 0, NULL },
    1526             :         },
    1527             :         {
    1528             :                 "EfsRpcDuplicateEncryptionInfoFile",
    1529             :                 sizeof(struct EfsRpcDuplicateEncryptionInfoFile),
    1530             :                 (ndr_push_flags_fn_t) ndr_push_EfsRpcDuplicateEncryptionInfoFile,
    1531             :                 (ndr_pull_flags_fn_t) ndr_pull_EfsRpcDuplicateEncryptionInfoFile,
    1532             :                 (ndr_print_function_t) ndr_print_EfsRpcDuplicateEncryptionInfoFile,
    1533             :                 { 0, NULL },
    1534             :                 { 0, NULL },
    1535             :         },
    1536             :         { .name = NULL }
    1537             : };
    1538             : 
    1539             : static const char * const efs_endpoint_strings[] = {
    1540             :         "ncacn_np:[\\pipe\\efs]", 
    1541             : };
    1542             : 
    1543             : static const struct ndr_interface_string_array efs_endpoints = {
    1544             :         .count  = 1,
    1545             :         .names  = efs_endpoint_strings
    1546             : };
    1547             : 
    1548             : static const char * const efs_authservice_strings[] = {
    1549             :         "host", 
    1550             : };
    1551             : 
    1552             : static const struct ndr_interface_string_array efs_authservices = {
    1553             :         .count  = 1,
    1554             :         .names  = efs_authservice_strings
    1555             : };
    1556             : 
    1557             : 
    1558             : const struct ndr_interface_table ndr_table_efs = {
    1559             :         .name           = "efs",
    1560             :         .syntax_id      = {
    1561             :                 {0xc681d488,0xd850,0x11d0,{0x8c,0x52},{0x00,0xc0,0x4f,0xd9,0x0f,0x7e}},
    1562             :                 NDR_EFS_VERSION
    1563             :         },
    1564             :         .helpstring     = NDR_EFS_HELPSTRING,
    1565             :         .num_calls      = 14,
    1566             :         .calls          = efs_calls,
    1567             :         .num_public_structs     = 0,
    1568             :         .public_structs         = efs_public_structs,
    1569             :         .endpoints      = &efs_endpoints,
    1570             :         .authservices   = &efs_authservices
    1571             : };
    1572             : 
    1573             : #endif /* SKIP_NDR_TABLE_efs */

Generated by: LCOV version 1.13