← Back to branch summary

~lefteris-nikoltsios/+junk/samba-lp1016895

« back to all changes in this revision

Viewing changes to source3/librpc/gen_ndr/ndr_efs.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

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