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