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 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
1547 0 : NDR_CHECK(ndr_pull_ODJ_WIN7BLOB_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
1548 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
1549 : }
1550 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1551 : }
1552 0 : if (ndr_flags & NDR_BUFFERS) {
1553 0 : }
1554 0 : return NDR_ERR_SUCCESS;
1555 : }
1556 :
1557 0 : static void ndr_print_flags_ODJ_WIN7BLOB_serialized_ptr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct ODJ_WIN7BLOB_serialized_ptr *r)
1558 : {
1559 0 : ndr_print_ODJ_WIN7BLOB_serialized_ptr(ndr, name, r);
1560 0 : }
1561 :
1562 0 : _PUBLIC_ void ndr_print_ODJ_WIN7BLOB_serialized_ptr(struct ndr_print *ndr, const char *name, const struct ODJ_WIN7BLOB_serialized_ptr *r)
1563 : {
1564 0 : ndr_print_struct(ndr, name, "ODJ_WIN7BLOB_serialized_ptr");
1565 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1566 0 : ndr->depth++;
1567 0 : ndr_print_ODJ_WIN7BLOB_ctr(ndr, "s", &r->s);
1568 0 : ndr->depth--;
1569 : }
1570 :
1571 0 : _PUBLIC_ size_t ndr_size_ODJ_WIN7BLOB_serialized_ptr(const struct ODJ_WIN7BLOB_serialized_ptr *r, libndr_flags flags)
1572 : {
1573 0 : return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ODJ_WIN7BLOB_serialized_ptr);
1574 : }
1575 :
1576 0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_JOINPROV2_PART_ctr(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct OP_JOINPROV2_PART_ctr *r)
1577 : {
1578 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1579 0 : if (ndr_flags & NDR_SCALARS) {
1580 0 : NDR_CHECK(ndr_push_align(ndr, 5));
1581 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
1582 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1583 : }
1584 0 : if (ndr_flags & NDR_BUFFERS) {
1585 0 : if (r->p) {
1586 0 : NDR_CHECK(ndr_push_OP_JOINPROV2_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
1587 : }
1588 : }
1589 0 : return NDR_ERR_SUCCESS;
1590 : }
1591 :
1592 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_JOINPROV2_PART_ctr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_JOINPROV2_PART_ctr *r)
1593 : {
1594 0 : uint32_t _ptr_p;
1595 0 : TALLOC_CTX *_mem_save_p_0 = NULL;
1596 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1597 0 : if (ndr_flags & NDR_SCALARS) {
1598 0 : NDR_CHECK(ndr_pull_align(ndr, 5));
1599 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
1600 0 : if (_ptr_p) {
1601 0 : NDR_PULL_ALLOC(ndr, r->p);
1602 : } else {
1603 0 : r->p = NULL;
1604 : }
1605 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1606 : }
1607 0 : if (ndr_flags & NDR_BUFFERS) {
1608 0 : if (r->p) {
1609 0 : _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
1610 0 : NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
1611 0 : NDR_CHECK(ndr_pull_OP_JOINPROV2_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
1612 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
1613 : }
1614 : }
1615 0 : return NDR_ERR_SUCCESS;
1616 : }
1617 :
1618 0 : static void ndr_print_flags_OP_JOINPROV2_PART_ctr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_JOINPROV2_PART_ctr *r)
1619 : {
1620 0 : ndr_print_OP_JOINPROV2_PART_ctr(ndr, name, r);
1621 0 : }
1622 :
1623 0 : _PUBLIC_ void ndr_print_OP_JOINPROV2_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV2_PART_ctr *r)
1624 : {
1625 0 : ndr_print_struct(ndr, name, "OP_JOINPROV2_PART_ctr");
1626 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1627 0 : ndr->depth++;
1628 0 : ndr_print_ptr(ndr, "p", r->p);
1629 0 : ndr->depth++;
1630 0 : if (r->p) {
1631 0 : ndr_print_OP_JOINPROV2_PART(ndr, "p", r->p);
1632 : }
1633 0 : ndr->depth--;
1634 0 : ndr->depth--;
1635 : }
1636 :
1637 0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_JOINPROV2_PART_serialized_ptr(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct OP_JOINPROV2_PART_serialized_ptr *r)
1638 : {
1639 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1640 0 : if (ndr_flags & NDR_SCALARS) {
1641 0 : NDR_CHECK(ndr_push_align(ndr, 1));
1642 : {
1643 0 : struct ndr_push *_ndr_s;
1644 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
1645 0 : NDR_CHECK(ndr_push_OP_JOINPROV2_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
1646 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
1647 : }
1648 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1649 : }
1650 0 : if (ndr_flags & NDR_BUFFERS) {
1651 0 : }
1652 0 : return NDR_ERR_SUCCESS;
1653 : }
1654 :
1655 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_JOINPROV2_PART_serialized_ptr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_JOINPROV2_PART_serialized_ptr *r)
1656 : {
1657 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1658 0 : if (ndr_flags & NDR_SCALARS) {
1659 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
1660 : {
1661 0 : struct ndr_pull *_ndr_s;
1662 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
1663 0 : NDR_CHECK(ndr_pull_OP_JOINPROV2_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
1664 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
1665 : }
1666 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1667 : }
1668 0 : if (ndr_flags & NDR_BUFFERS) {
1669 0 : }
1670 0 : return NDR_ERR_SUCCESS;
1671 : }
1672 :
1673 0 : static void ndr_print_flags_OP_JOINPROV2_PART_serialized_ptr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_JOINPROV2_PART_serialized_ptr *r)
1674 : {
1675 0 : ndr_print_OP_JOINPROV2_PART_serialized_ptr(ndr, name, r);
1676 0 : }
1677 :
1678 0 : _PUBLIC_ void ndr_print_OP_JOINPROV2_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV2_PART_serialized_ptr *r)
1679 : {
1680 0 : ndr_print_struct(ndr, name, "OP_JOINPROV2_PART_serialized_ptr");
1681 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1682 0 : ndr->depth++;
1683 0 : ndr_print_OP_JOINPROV2_PART_ctr(ndr, "s", &r->s);
1684 0 : ndr->depth--;
1685 : }
1686 :
1687 0 : _PUBLIC_ size_t ndr_size_OP_JOINPROV2_PART_serialized_ptr(const struct OP_JOINPROV2_PART_serialized_ptr *r, libndr_flags flags)
1688 : {
1689 0 : return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_JOINPROV2_PART_serialized_ptr);
1690 : }
1691 :
1692 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)
1693 : {
1694 1530 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1695 1530 : if (ndr_flags & NDR_SCALARS) {
1696 1530 : NDR_CHECK(ndr_push_align(ndr, 5));
1697 1530 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
1698 1530 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1699 : }
1700 1530 : if (ndr_flags & NDR_BUFFERS) {
1701 1530 : if (r->p) {
1702 1530 : NDR_CHECK(ndr_push_OP_JOINPROV3_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
1703 : }
1704 : }
1705 1530 : return NDR_ERR_SUCCESS;
1706 : }
1707 :
1708 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)
1709 : {
1710 2 : uint32_t _ptr_p;
1711 20 : TALLOC_CTX *_mem_save_p_0 = NULL;
1712 20 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1713 20 : if (ndr_flags & NDR_SCALARS) {
1714 20 : NDR_CHECK(ndr_pull_align(ndr, 5));
1715 20 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
1716 20 : if (_ptr_p) {
1717 20 : NDR_PULL_ALLOC(ndr, r->p);
1718 : } else {
1719 0 : r->p = NULL;
1720 : }
1721 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1722 : }
1723 20 : if (ndr_flags & NDR_BUFFERS) {
1724 20 : if (r->p) {
1725 20 : _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
1726 20 : NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
1727 20 : NDR_CHECK(ndr_pull_OP_JOINPROV3_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
1728 20 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
1729 : }
1730 : }
1731 18 : return NDR_ERR_SUCCESS;
1732 : }
1733 :
1734 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)
1735 : {
1736 0 : ndr_print_OP_JOINPROV3_PART_ctr(ndr, name, r);
1737 0 : }
1738 :
1739 20 : _PUBLIC_ void ndr_print_OP_JOINPROV3_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV3_PART_ctr *r)
1740 : {
1741 20 : ndr_print_struct(ndr, name, "OP_JOINPROV3_PART_ctr");
1742 20 : if (r == NULL) { ndr_print_null(ndr); return; }
1743 20 : ndr->depth++;
1744 20 : ndr_print_ptr(ndr, "p", r->p);
1745 20 : ndr->depth++;
1746 20 : if (r->p) {
1747 20 : ndr_print_OP_JOINPROV3_PART(ndr, "p", r->p);
1748 : }
1749 20 : ndr->depth--;
1750 20 : ndr->depth--;
1751 : }
1752 :
1753 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)
1754 : {
1755 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1756 0 : if (ndr_flags & NDR_SCALARS) {
1757 0 : NDR_CHECK(ndr_push_align(ndr, 1));
1758 : {
1759 0 : struct ndr_push *_ndr_s;
1760 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
1761 0 : NDR_CHECK(ndr_push_OP_JOINPROV3_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
1762 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
1763 : }
1764 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1765 : }
1766 0 : if (ndr_flags & NDR_BUFFERS) {
1767 0 : }
1768 0 : return NDR_ERR_SUCCESS;
1769 : }
1770 :
1771 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_JOINPROV3_PART_serialized_ptr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_JOINPROV3_PART_serialized_ptr *r)
1772 : {
1773 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1774 0 : if (ndr_flags & NDR_SCALARS) {
1775 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
1776 : {
1777 0 : struct ndr_pull *_ndr_s;
1778 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
1779 0 : NDR_CHECK(ndr_pull_OP_JOINPROV3_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
1780 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
1781 : }
1782 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1783 : }
1784 0 : if (ndr_flags & NDR_BUFFERS) {
1785 0 : }
1786 0 : return NDR_ERR_SUCCESS;
1787 : }
1788 :
1789 0 : static void ndr_print_flags_OP_JOINPROV3_PART_serialized_ptr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_JOINPROV3_PART_serialized_ptr *r)
1790 : {
1791 0 : ndr_print_OP_JOINPROV3_PART_serialized_ptr(ndr, name, r);
1792 0 : }
1793 :
1794 0 : _PUBLIC_ void ndr_print_OP_JOINPROV3_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_JOINPROV3_PART_serialized_ptr *r)
1795 : {
1796 0 : ndr_print_struct(ndr, name, "OP_JOINPROV3_PART_serialized_ptr");
1797 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1798 0 : ndr->depth++;
1799 0 : ndr_print_OP_JOINPROV3_PART_ctr(ndr, "s", &r->s);
1800 0 : ndr->depth--;
1801 : }
1802 :
1803 0 : _PUBLIC_ size_t ndr_size_OP_JOINPROV3_PART_serialized_ptr(const struct OP_JOINPROV3_PART_serialized_ptr *r, libndr_flags flags)
1804 : {
1805 0 : return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_JOINPROV3_PART_serialized_ptr);
1806 : }
1807 :
1808 0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_POLICY_PART_ctr(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct OP_POLICY_PART_ctr *r)
1809 : {
1810 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1811 0 : if (ndr_flags & NDR_SCALARS) {
1812 0 : NDR_CHECK(ndr_push_align(ndr, 5));
1813 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
1814 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1815 : }
1816 0 : if (ndr_flags & NDR_BUFFERS) {
1817 0 : if (r->p) {
1818 0 : NDR_CHECK(ndr_push_OP_POLICY_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
1819 : }
1820 : }
1821 0 : return NDR_ERR_SUCCESS;
1822 : }
1823 :
1824 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_POLICY_PART_ctr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_POLICY_PART_ctr *r)
1825 : {
1826 0 : uint32_t _ptr_p;
1827 0 : TALLOC_CTX *_mem_save_p_0 = NULL;
1828 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1829 0 : if (ndr_flags & NDR_SCALARS) {
1830 0 : NDR_CHECK(ndr_pull_align(ndr, 5));
1831 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
1832 0 : if (_ptr_p) {
1833 0 : NDR_PULL_ALLOC(ndr, r->p);
1834 : } else {
1835 0 : r->p = NULL;
1836 : }
1837 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1838 : }
1839 0 : if (ndr_flags & NDR_BUFFERS) {
1840 0 : if (r->p) {
1841 0 : _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
1842 0 : NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
1843 0 : NDR_CHECK(ndr_pull_OP_POLICY_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
1844 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
1845 : }
1846 : }
1847 0 : return NDR_ERR_SUCCESS;
1848 : }
1849 :
1850 0 : static void ndr_print_flags_OP_POLICY_PART_ctr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_POLICY_PART_ctr *r)
1851 : {
1852 0 : ndr_print_OP_POLICY_PART_ctr(ndr, name, r);
1853 0 : }
1854 :
1855 0 : _PUBLIC_ void ndr_print_OP_POLICY_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_POLICY_PART_ctr *r)
1856 : {
1857 0 : ndr_print_struct(ndr, name, "OP_POLICY_PART_ctr");
1858 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1859 0 : ndr->depth++;
1860 0 : ndr_print_ptr(ndr, "p", r->p);
1861 0 : ndr->depth++;
1862 0 : if (r->p) {
1863 0 : ndr_print_OP_POLICY_PART(ndr, "p", r->p);
1864 : }
1865 0 : ndr->depth--;
1866 0 : ndr->depth--;
1867 : }
1868 :
1869 0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_POLICY_PART_serialized_ptr(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct OP_POLICY_PART_serialized_ptr *r)
1870 : {
1871 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1872 0 : if (ndr_flags & NDR_SCALARS) {
1873 0 : NDR_CHECK(ndr_push_align(ndr, 1));
1874 : {
1875 0 : struct ndr_push *_ndr_s;
1876 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
1877 0 : NDR_CHECK(ndr_push_OP_POLICY_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
1878 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
1879 : }
1880 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1881 : }
1882 0 : if (ndr_flags & NDR_BUFFERS) {
1883 0 : }
1884 0 : return NDR_ERR_SUCCESS;
1885 : }
1886 :
1887 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_POLICY_PART_serialized_ptr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_POLICY_PART_serialized_ptr *r)
1888 : {
1889 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1890 0 : if (ndr_flags & NDR_SCALARS) {
1891 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
1892 : {
1893 0 : struct ndr_pull *_ndr_s;
1894 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
1895 0 : NDR_CHECK(ndr_pull_OP_POLICY_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
1896 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
1897 : }
1898 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1899 : }
1900 0 : if (ndr_flags & NDR_BUFFERS) {
1901 0 : }
1902 0 : return NDR_ERR_SUCCESS;
1903 : }
1904 :
1905 0 : static void ndr_print_flags_OP_POLICY_PART_serialized_ptr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_POLICY_PART_serialized_ptr *r)
1906 : {
1907 0 : ndr_print_OP_POLICY_PART_serialized_ptr(ndr, name, r);
1908 0 : }
1909 :
1910 0 : _PUBLIC_ void ndr_print_OP_POLICY_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_POLICY_PART_serialized_ptr *r)
1911 : {
1912 0 : ndr_print_struct(ndr, name, "OP_POLICY_PART_serialized_ptr");
1913 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1914 0 : ndr->depth++;
1915 0 : ndr_print_OP_POLICY_PART_ctr(ndr, "s", &r->s);
1916 0 : ndr->depth--;
1917 : }
1918 :
1919 0 : _PUBLIC_ size_t ndr_size_OP_POLICY_PART_serialized_ptr(const struct OP_POLICY_PART_serialized_ptr *r, libndr_flags flags)
1920 : {
1921 0 : return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_POLICY_PART_serialized_ptr);
1922 : }
1923 :
1924 0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_CERT_PART_ctr(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct OP_CERT_PART_ctr *r)
1925 : {
1926 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1927 0 : if (ndr_flags & NDR_SCALARS) {
1928 0 : NDR_CHECK(ndr_push_align(ndr, 5));
1929 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
1930 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1931 : }
1932 0 : if (ndr_flags & NDR_BUFFERS) {
1933 0 : if (r->p) {
1934 0 : NDR_CHECK(ndr_push_OP_CERT_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
1935 : }
1936 : }
1937 0 : return NDR_ERR_SUCCESS;
1938 : }
1939 :
1940 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_CERT_PART_ctr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_CERT_PART_ctr *r)
1941 : {
1942 0 : uint32_t _ptr_p;
1943 0 : TALLOC_CTX *_mem_save_p_0 = NULL;
1944 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1945 0 : if (ndr_flags & NDR_SCALARS) {
1946 0 : NDR_CHECK(ndr_pull_align(ndr, 5));
1947 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
1948 0 : if (_ptr_p) {
1949 0 : NDR_PULL_ALLOC(ndr, r->p);
1950 : } else {
1951 0 : r->p = NULL;
1952 : }
1953 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1954 : }
1955 0 : if (ndr_flags & NDR_BUFFERS) {
1956 0 : if (r->p) {
1957 0 : _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
1958 0 : NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
1959 0 : NDR_CHECK(ndr_pull_OP_CERT_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
1960 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
1961 : }
1962 : }
1963 0 : return NDR_ERR_SUCCESS;
1964 : }
1965 :
1966 0 : static void ndr_print_flags_OP_CERT_PART_ctr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_CERT_PART_ctr *r)
1967 : {
1968 0 : ndr_print_OP_CERT_PART_ctr(ndr, name, r);
1969 0 : }
1970 :
1971 0 : _PUBLIC_ void ndr_print_OP_CERT_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_CERT_PART_ctr *r)
1972 : {
1973 0 : ndr_print_struct(ndr, name, "OP_CERT_PART_ctr");
1974 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1975 0 : ndr->depth++;
1976 0 : ndr_print_ptr(ndr, "p", r->p);
1977 0 : ndr->depth++;
1978 0 : if (r->p) {
1979 0 : ndr_print_OP_CERT_PART(ndr, "p", r->p);
1980 : }
1981 0 : ndr->depth--;
1982 0 : ndr->depth--;
1983 : }
1984 :
1985 0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_CERT_PART_serialized_ptr(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct OP_CERT_PART_serialized_ptr *r)
1986 : {
1987 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1988 0 : if (ndr_flags & NDR_SCALARS) {
1989 0 : NDR_CHECK(ndr_push_align(ndr, 1));
1990 : {
1991 0 : struct ndr_push *_ndr_s;
1992 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
1993 0 : NDR_CHECK(ndr_push_OP_CERT_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
1994 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
1995 : }
1996 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1997 : }
1998 0 : if (ndr_flags & NDR_BUFFERS) {
1999 0 : }
2000 0 : return NDR_ERR_SUCCESS;
2001 : }
2002 :
2003 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_CERT_PART_serialized_ptr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_CERT_PART_serialized_ptr *r)
2004 : {
2005 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2006 0 : if (ndr_flags & NDR_SCALARS) {
2007 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
2008 : {
2009 0 : struct ndr_pull *_ndr_s;
2010 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
2011 0 : NDR_CHECK(ndr_pull_OP_CERT_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
2012 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
2013 : }
2014 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2015 : }
2016 0 : if (ndr_flags & NDR_BUFFERS) {
2017 0 : }
2018 0 : return NDR_ERR_SUCCESS;
2019 : }
2020 :
2021 0 : static void ndr_print_flags_OP_CERT_PART_serialized_ptr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_CERT_PART_serialized_ptr *r)
2022 : {
2023 0 : ndr_print_OP_CERT_PART_serialized_ptr(ndr, name, r);
2024 0 : }
2025 :
2026 0 : _PUBLIC_ void ndr_print_OP_CERT_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_CERT_PART_serialized_ptr *r)
2027 : {
2028 0 : ndr_print_struct(ndr, name, "OP_CERT_PART_serialized_ptr");
2029 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2030 0 : ndr->depth++;
2031 0 : ndr_print_OP_CERT_PART_ctr(ndr, "s", &r->s);
2032 0 : ndr->depth--;
2033 : }
2034 :
2035 0 : _PUBLIC_ size_t ndr_size_OP_CERT_PART_serialized_ptr(const struct OP_CERT_PART_serialized_ptr *r, libndr_flags flags)
2036 : {
2037 0 : return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_CERT_PART_serialized_ptr);
2038 : }
2039 :
2040 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)
2041 : {
2042 0 : uint32_t level;
2043 3060 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2044 3060 : if (ndr_flags & NDR_SCALARS) {
2045 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
2046 3060 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
2047 3060 : NDR_CHECK(ndr_push_union_align(ndr, 1));
2048 3060 : switch (level) {
2049 1530 : case 1: {
2050 : {
2051 0 : struct ndr_push *_ndr_win7blob;
2052 1530 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_win7blob, 0xFFFFFC01, -1));
2053 1530 : NDR_CHECK(ndr_push_ODJ_WIN7BLOB(_ndr_win7blob, NDR_SCALARS|NDR_BUFFERS, &r->win7blob));
2054 1530 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_win7blob, 0xFFFFFC01, -1));
2055 : }
2056 1530 : break; }
2057 :
2058 0 : case 2: {
2059 : {
2060 0 : struct ndr_push *_ndr_join_prov2;
2061 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_join_prov2, 0xFFFFFC01, -1));
2062 0 : NDR_CHECK(ndr_push_OP_JOINPROV2_PART_ctr(_ndr_join_prov2, NDR_SCALARS|NDR_BUFFERS, &r->join_prov2));
2063 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_join_prov2, 0xFFFFFC01, -1));
2064 : }
2065 0 : break; }
2066 :
2067 1530 : case 3: {
2068 : {
2069 0 : struct ndr_push *_ndr_join_prov3;
2070 1530 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_join_prov3, 0xFFFFFC01, -1));
2071 1530 : NDR_CHECK(ndr_push_OP_JOINPROV3_PART_ctr(_ndr_join_prov3, NDR_SCALARS|NDR_BUFFERS, &r->join_prov3));
2072 1530 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_join_prov3, 0xFFFFFC01, -1));
2073 : }
2074 1530 : break; }
2075 :
2076 0 : case 4: {
2077 : {
2078 0 : struct ndr_push *_ndr_cert_part;
2079 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_cert_part, 0xFFFFFC01, -1));
2080 0 : NDR_CHECK(ndr_push_OP_CERT_PART_ctr(_ndr_cert_part, NDR_SCALARS|NDR_BUFFERS, &r->cert_part));
2081 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_cert_part, 0xFFFFFC01, -1));
2082 : }
2083 0 : break; }
2084 :
2085 0 : case 5: {
2086 : {
2087 0 : struct ndr_push *_ndr_policy_part;
2088 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_policy_part, 0xFFFFFC01, -1));
2089 0 : NDR_CHECK(ndr_push_OP_POLICY_PART_ctr(_ndr_policy_part, NDR_SCALARS|NDR_BUFFERS, &r->policy_part));
2090 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_policy_part, 0xFFFFFC01, -1));
2091 : }
2092 0 : break; }
2093 :
2094 0 : default: {
2095 0 : break; }
2096 :
2097 : }
2098 : }
2099 3060 : if (ndr_flags & NDR_BUFFERS) {
2100 3060 : if (!(ndr_flags & NDR_SCALARS)) {
2101 : /* We didn't get it above, and the token is not needed after this. */
2102 0 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
2103 : }
2104 3060 : switch (level) {
2105 1530 : case 1:
2106 1530 : break;
2107 :
2108 0 : case 2:
2109 0 : break;
2110 :
2111 1530 : case 3:
2112 1530 : break;
2113 :
2114 0 : case 4:
2115 0 : break;
2116 :
2117 0 : case 5:
2118 0 : break;
2119 :
2120 0 : default:
2121 0 : break;
2122 :
2123 : }
2124 : }
2125 3060 : return NDR_ERR_SUCCESS;
2126 : }
2127 :
2128 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)
2129 : {
2130 4 : uint32_t level;
2131 40 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2132 40 : if (ndr_flags & NDR_SCALARS) {
2133 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
2134 40 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
2135 40 : NDR_CHECK(ndr_pull_union_align(ndr, 1));
2136 40 : switch (level) {
2137 20 : case 1: {
2138 : {
2139 2 : struct ndr_pull *_ndr_win7blob;
2140 20 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_win7blob, 0xFFFFFC01, -1));
2141 20 : NDR_CHECK(ndr_pull_ODJ_WIN7BLOB(_ndr_win7blob, NDR_SCALARS|NDR_BUFFERS, &r->win7blob));
2142 20 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_win7blob, 0xFFFFFC01, -1));
2143 : }
2144 20 : break; }
2145 :
2146 0 : case 2: {
2147 : {
2148 0 : struct ndr_pull *_ndr_join_prov2;
2149 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_join_prov2, 0xFFFFFC01, -1));
2150 0 : NDR_CHECK(ndr_pull_OP_JOINPROV2_PART_ctr(_ndr_join_prov2, NDR_SCALARS|NDR_BUFFERS, &r->join_prov2));
2151 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_join_prov2, 0xFFFFFC01, -1));
2152 : }
2153 0 : break; }
2154 :
2155 20 : case 3: {
2156 : {
2157 2 : struct ndr_pull *_ndr_join_prov3;
2158 20 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_join_prov3, 0xFFFFFC01, -1));
2159 20 : NDR_CHECK(ndr_pull_OP_JOINPROV3_PART_ctr(_ndr_join_prov3, NDR_SCALARS|NDR_BUFFERS, &r->join_prov3));
2160 20 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_join_prov3, 0xFFFFFC01, -1));
2161 : }
2162 20 : break; }
2163 :
2164 0 : case 4: {
2165 : {
2166 0 : struct ndr_pull *_ndr_cert_part;
2167 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_cert_part, 0xFFFFFC01, -1));
2168 0 : NDR_CHECK(ndr_pull_OP_CERT_PART_ctr(_ndr_cert_part, NDR_SCALARS|NDR_BUFFERS, &r->cert_part));
2169 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_cert_part, 0xFFFFFC01, -1));
2170 : }
2171 0 : break; }
2172 :
2173 0 : case 5: {
2174 : {
2175 0 : struct ndr_pull *_ndr_policy_part;
2176 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_policy_part, 0xFFFFFC01, -1));
2177 0 : NDR_CHECK(ndr_pull_OP_POLICY_PART_ctr(_ndr_policy_part, NDR_SCALARS|NDR_BUFFERS, &r->policy_part));
2178 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_policy_part, 0xFFFFFC01, -1));
2179 : }
2180 0 : break; }
2181 :
2182 0 : default: {
2183 0 : break; }
2184 :
2185 : }
2186 : }
2187 40 : if (ndr_flags & NDR_BUFFERS) {
2188 40 : if (!(ndr_flags & NDR_SCALARS)) {
2189 : /* We didn't get it above, and the token is not needed after this. */
2190 0 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
2191 : }
2192 40 : switch (level) {
2193 18 : case 1:
2194 18 : break;
2195 :
2196 0 : case 2:
2197 0 : break;
2198 :
2199 18 : case 3:
2200 18 : break;
2201 :
2202 0 : case 4:
2203 0 : break;
2204 :
2205 0 : case 5:
2206 0 : break;
2207 :
2208 0 : default:
2209 0 : break;
2210 :
2211 : }
2212 : }
2213 36 : return NDR_ERR_SUCCESS;
2214 : }
2215 :
2216 40 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_u(struct ndr_print *ndr, const char *name, const union OP_PACKAGE_PART_u *r)
2217 : {
2218 4 : uint32_t level;
2219 40 : level = ndr_print_steal_switch_value(ndr, r);
2220 40 : ndr_print_union(ndr, name, level, "OP_PACKAGE_PART_u");
2221 40 : switch (level) {
2222 20 : case 1:
2223 20 : ndr_print_ODJ_WIN7BLOB(ndr, "win7blob", &r->win7blob);
2224 20 : break;
2225 :
2226 0 : case 2:
2227 0 : ndr_print_OP_JOINPROV2_PART_ctr(ndr, "join_prov2", &r->join_prov2);
2228 0 : break;
2229 :
2230 20 : case 3:
2231 20 : ndr_print_OP_JOINPROV3_PART_ctr(ndr, "join_prov3", &r->join_prov3);
2232 20 : break;
2233 :
2234 0 : case 4:
2235 0 : ndr_print_OP_CERT_PART_ctr(ndr, "cert_part", &r->cert_part);
2236 0 : break;
2237 :
2238 0 : case 5:
2239 0 : ndr_print_OP_POLICY_PART_ctr(ndr, "policy_part", &r->policy_part);
2240 0 : break;
2241 :
2242 0 : default:
2243 0 : break;
2244 :
2245 : }
2246 40 : }
2247 :
2248 2304 : _PUBLIC_ size_t ndr_size_OP_PACKAGE_PART_u(const union OP_PACKAGE_PART_u *r, uint32_t level, libndr_flags flags)
2249 : {
2250 2304 : return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_OP_PACKAGE_PART_u);
2251 : }
2252 :
2253 0 : _PUBLIC_ enum ndr_err_code ndr_push_ODJ_PackageFlags(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t r)
2254 : {
2255 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2256 0 : return NDR_ERR_SUCCESS;
2257 : }
2258 :
2259 0 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJ_PackageFlags(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t *r)
2260 : {
2261 0 : uint32_t v;
2262 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2263 0 : *r = v;
2264 0 : return NDR_ERR_SUCCESS;
2265 : }
2266 :
2267 0 : _PUBLIC_ void ndr_print_ODJ_PackageFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2268 : {
2269 0 : ndr_print_uint32(ndr, name, r);
2270 0 : ndr->depth++;
2271 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "OPSPI_PACKAGE_PART_ESSENTIAL", OPSPI_PACKAGE_PART_ESSENTIAL, r);
2272 0 : ndr->depth--;
2273 0 : }
2274 :
2275 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)
2276 : {
2277 1512 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2278 1512 : if (ndr_flags & NDR_SCALARS) {
2279 756 : NDR_CHECK(ndr_push_align(ndr, 5));
2280 756 : NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->PartType));
2281 756 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulFlags));
2282 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)));
2283 756 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->Part));
2284 756 : NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
2285 756 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2286 : }
2287 1512 : if (ndr_flags & NDR_BUFFERS) {
2288 756 : if (r->Part) {
2289 : {
2290 0 : struct ndr_push *_ndr_Part;
2291 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)));
2292 756 : NDR_CHECK(ndr_push_set_switch_value(_ndr_Part, r->Part, odj_switch_level_from_guid(&r->PartType)));
2293 756 : NDR_CHECK(ndr_push_OP_PACKAGE_PART_u(_ndr_Part, NDR_SCALARS|NDR_BUFFERS, r->Part));
2294 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)));
2295 : }
2296 : }
2297 756 : NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
2298 : }
2299 1512 : return NDR_ERR_SUCCESS;
2300 : }
2301 :
2302 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)
2303 : {
2304 8 : uint32_t _ptr_Part;
2305 80 : TALLOC_CTX *_mem_save_Part_0 = NULL;
2306 80 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2307 80 : if (ndr_flags & NDR_SCALARS) {
2308 40 : NDR_CHECK(ndr_pull_align(ndr, 5));
2309 40 : NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->PartType));
2310 40 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulFlags));
2311 40 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->part_len));
2312 40 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Part));
2313 40 : if (_ptr_Part) {
2314 40 : NDR_PULL_ALLOC(ndr, r->Part);
2315 : } else {
2316 0 : r->Part = NULL;
2317 : }
2318 40 : NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
2319 40 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2320 : }
2321 80 : if (ndr_flags & NDR_BUFFERS) {
2322 40 : if (r->Part) {
2323 40 : _mem_save_Part_0 = NDR_PULL_GET_MEM_CTX(ndr);
2324 40 : NDR_PULL_SET_MEM_CTX(ndr, r->Part, 0);
2325 : {
2326 4 : struct ndr_pull *_ndr_Part;
2327 40 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_Part, 4, r->part_len));
2328 40 : NDR_CHECK(ndr_pull_set_switch_value(_ndr_Part, r->Part, odj_switch_level_from_guid(&r->PartType)));
2329 40 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART_u(_ndr_Part, NDR_SCALARS|NDR_BUFFERS, r->Part));
2330 40 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_Part, 4, r->part_len));
2331 : }
2332 40 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Part_0, 0);
2333 : }
2334 40 : NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
2335 : }
2336 72 : return NDR_ERR_SUCCESS;
2337 : }
2338 :
2339 40 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART *r)
2340 : {
2341 40 : ndr_print_struct(ndr, name, "OP_PACKAGE_PART");
2342 40 : if (r == NULL) { ndr_print_null(ndr); return; }
2343 40 : ndr->depth++;
2344 40 : ndr_print_GUID(ndr, "PartType", &r->PartType);
2345 40 : ndr_print_uint32(ndr, "ulFlags", r->ulFlags);
2346 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);
2347 40 : ndr_print_ptr(ndr, "Part", r->Part);
2348 40 : ndr->depth++;
2349 40 : if (r->Part) {
2350 40 : ndr_print_set_switch_value(ndr, r->Part, odj_switch_level_from_guid(&r->PartType));
2351 40 : ndr_print_OP_PACKAGE_PART_u(ndr, "Part", r->Part);
2352 : }
2353 40 : ndr->depth--;
2354 40 : ndr_print_OP_BLOB(ndr, "Extension", &r->Extension);
2355 40 : ndr->depth--;
2356 : }
2357 :
2358 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)
2359 : {
2360 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2361 0 : if (ndr_flags & NDR_SCALARS) {
2362 0 : NDR_CHECK(ndr_push_align(ndr, 5));
2363 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
2364 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2365 : }
2366 0 : if (ndr_flags & NDR_BUFFERS) {
2367 0 : if (r->p) {
2368 0 : NDR_CHECK(ndr_push_OP_PACKAGE_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
2369 : }
2370 : }
2371 0 : return NDR_ERR_SUCCESS;
2372 : }
2373 :
2374 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_PART_ctr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_PACKAGE_PART_ctr *r)
2375 : {
2376 0 : uint32_t _ptr_p;
2377 0 : TALLOC_CTX *_mem_save_p_0 = NULL;
2378 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2379 0 : if (ndr_flags & NDR_SCALARS) {
2380 0 : NDR_CHECK(ndr_pull_align(ndr, 5));
2381 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
2382 0 : if (_ptr_p) {
2383 0 : NDR_PULL_ALLOC(ndr, r->p);
2384 : } else {
2385 0 : r->p = NULL;
2386 : }
2387 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2388 : }
2389 0 : if (ndr_flags & NDR_BUFFERS) {
2390 0 : if (r->p) {
2391 0 : _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
2392 0 : NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
2393 0 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
2394 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
2395 : }
2396 : }
2397 0 : return NDR_ERR_SUCCESS;
2398 : }
2399 :
2400 0 : static void ndr_print_flags_OP_PACKAGE_PART_ctr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_PACKAGE_PART_ctr *r)
2401 : {
2402 0 : ndr_print_OP_PACKAGE_PART_ctr(ndr, name, r);
2403 0 : }
2404 :
2405 0 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_ctr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART_ctr *r)
2406 : {
2407 0 : ndr_print_struct(ndr, name, "OP_PACKAGE_PART_ctr");
2408 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2409 0 : ndr->depth++;
2410 0 : ndr_print_ptr(ndr, "p", r->p);
2411 0 : ndr->depth++;
2412 0 : if (r->p) {
2413 0 : ndr_print_OP_PACKAGE_PART(ndr, "p", r->p);
2414 : }
2415 0 : ndr->depth--;
2416 0 : ndr->depth--;
2417 : }
2418 :
2419 0 : _PUBLIC_ enum ndr_err_code ndr_push_OP_PACKAGE_PART_serialized_ptr(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct OP_PACKAGE_PART_serialized_ptr *r)
2420 : {
2421 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2422 0 : if (ndr_flags & NDR_SCALARS) {
2423 0 : NDR_CHECK(ndr_push_align(ndr, 1));
2424 : {
2425 0 : struct ndr_push *_ndr_s;
2426 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
2427 0 : NDR_CHECK(ndr_push_OP_PACKAGE_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
2428 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
2429 : }
2430 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2431 : }
2432 0 : if (ndr_flags & NDR_BUFFERS) {
2433 0 : }
2434 0 : return NDR_ERR_SUCCESS;
2435 : }
2436 :
2437 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_PART_serialized_ptr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_PACKAGE_PART_serialized_ptr *r)
2438 : {
2439 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2440 0 : if (ndr_flags & NDR_SCALARS) {
2441 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
2442 : {
2443 0 : struct ndr_pull *_ndr_s;
2444 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
2445 0 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
2446 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
2447 : }
2448 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2449 : }
2450 0 : if (ndr_flags & NDR_BUFFERS) {
2451 0 : }
2452 0 : return NDR_ERR_SUCCESS;
2453 : }
2454 :
2455 0 : static void ndr_print_flags_OP_PACKAGE_PART_serialized_ptr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_PACKAGE_PART_serialized_ptr *r)
2456 : {
2457 0 : ndr_print_OP_PACKAGE_PART_serialized_ptr(ndr, name, r);
2458 0 : }
2459 :
2460 0 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART_serialized_ptr *r)
2461 : {
2462 0 : ndr_print_struct(ndr, name, "OP_PACKAGE_PART_serialized_ptr");
2463 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2464 0 : ndr->depth++;
2465 0 : ndr_print_OP_PACKAGE_PART_ctr(ndr, "s", &r->s);
2466 0 : ndr->depth--;
2467 : }
2468 :
2469 0 : _PUBLIC_ size_t ndr_size_OP_PACKAGE_PART_serialized_ptr(const struct OP_PACKAGE_PART_serialized_ptr *r, libndr_flags flags)
2470 : {
2471 0 : return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_PACKAGE_PART_serialized_ptr);
2472 : }
2473 :
2474 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)
2475 : {
2476 0 : uint32_t cntr_pParts_1;
2477 378 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2478 378 : if (ndr_flags & NDR_SCALARS) {
2479 378 : NDR_CHECK(ndr_push_align(ndr, 5));
2480 378 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cParts));
2481 378 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->pParts));
2482 378 : NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
2483 378 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2484 : }
2485 378 : if (ndr_flags & NDR_BUFFERS) {
2486 378 : if (r->pParts) {
2487 378 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cParts));
2488 1134 : for (cntr_pParts_1 = 0; cntr_pParts_1 < (r->cParts); cntr_pParts_1++) {
2489 756 : NDR_CHECK(ndr_push_OP_PACKAGE_PART(ndr, NDR_SCALARS, &r->pParts[cntr_pParts_1]));
2490 : }
2491 1134 : for (cntr_pParts_1 = 0; cntr_pParts_1 < (r->cParts); cntr_pParts_1++) {
2492 756 : NDR_CHECK(ndr_push_OP_PACKAGE_PART(ndr, NDR_BUFFERS, &r->pParts[cntr_pParts_1]));
2493 : }
2494 : }
2495 378 : NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
2496 : }
2497 378 : return NDR_ERR_SUCCESS;
2498 : }
2499 :
2500 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)
2501 : {
2502 2 : uint32_t _ptr_pParts;
2503 20 : uint32_t size_pParts_1 = 0;
2504 2 : uint32_t cntr_pParts_1;
2505 20 : TALLOC_CTX *_mem_save_pParts_0 = NULL;
2506 20 : TALLOC_CTX *_mem_save_pParts_1 = NULL;
2507 20 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2508 20 : if (ndr_flags & NDR_SCALARS) {
2509 20 : NDR_CHECK(ndr_pull_align(ndr, 5));
2510 20 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cParts));
2511 20 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pParts));
2512 20 : if (_ptr_pParts) {
2513 20 : NDR_PULL_ALLOC(ndr, r->pParts);
2514 : } else {
2515 0 : r->pParts = NULL;
2516 : }
2517 20 : NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
2518 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2519 : }
2520 20 : if (ndr_flags & NDR_BUFFERS) {
2521 20 : if (r->pParts) {
2522 20 : _mem_save_pParts_0 = NDR_PULL_GET_MEM_CTX(ndr);
2523 20 : NDR_PULL_SET_MEM_CTX(ndr, r->pParts, 0);
2524 20 : NDR_CHECK(ndr_pull_array_size(ndr, &r->pParts));
2525 20 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pParts, &size_pParts_1));
2526 20 : NDR_PULL_ALLOC_N(ndr, r->pParts, size_pParts_1);
2527 20 : _mem_save_pParts_1 = NDR_PULL_GET_MEM_CTX(ndr);
2528 20 : NDR_PULL_SET_MEM_CTX(ndr, r->pParts, 0);
2529 60 : for (cntr_pParts_1 = 0; cntr_pParts_1 < (size_pParts_1); cntr_pParts_1++) {
2530 40 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART(ndr, NDR_SCALARS, &r->pParts[cntr_pParts_1]));
2531 : }
2532 60 : for (cntr_pParts_1 = 0; cntr_pParts_1 < (size_pParts_1); cntr_pParts_1++) {
2533 40 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART(ndr, NDR_BUFFERS, &r->pParts[cntr_pParts_1]));
2534 : }
2535 20 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pParts_1, 0);
2536 20 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pParts_0, 0);
2537 : }
2538 20 : NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
2539 20 : if (r->pParts) {
2540 20 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pParts, r->cParts));
2541 : }
2542 60 : for (cntr_pParts_1 = 0; cntr_pParts_1 < (size_pParts_1); cntr_pParts_1++) {
2543 4 : }
2544 : }
2545 18 : return NDR_ERR_SUCCESS;
2546 : }
2547 :
2548 20 : _PUBLIC_ void ndr_print_OP_PACKAGE_PART_COLLECTION(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_PART_COLLECTION *r)
2549 : {
2550 2 : uint32_t cntr_pParts_1;
2551 20 : ndr_print_struct(ndr, name, "OP_PACKAGE_PART_COLLECTION");
2552 20 : if (r == NULL) { ndr_print_null(ndr); return; }
2553 20 : ndr->depth++;
2554 20 : ndr_print_uint32(ndr, "cParts", r->cParts);
2555 20 : ndr_print_ptr(ndr, "pParts", r->pParts);
2556 20 : ndr->depth++;
2557 20 : if (r->pParts) {
2558 20 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "pParts", (uint32_t)(r->cParts));
2559 20 : ndr->depth++;
2560 60 : for (cntr_pParts_1 = 0; cntr_pParts_1 < (r->cParts); cntr_pParts_1++) {
2561 40 : ndr_print_OP_PACKAGE_PART(ndr, "pParts", &r->pParts[cntr_pParts_1]);
2562 : }
2563 20 : ndr->depth--;
2564 : }
2565 20 : ndr->depth--;
2566 20 : ndr_print_OP_BLOB(ndr, "Extension", &r->Extension);
2567 20 : ndr->depth--;
2568 : }
2569 :
2570 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)
2571 : {
2572 378 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2573 378 : if (ndr_flags & NDR_SCALARS) {
2574 378 : NDR_CHECK(ndr_push_align(ndr, 5));
2575 378 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
2576 378 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2577 : }
2578 378 : if (ndr_flags & NDR_BUFFERS) {
2579 378 : if (r->p) {
2580 378 : NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
2581 : }
2582 : }
2583 378 : return NDR_ERR_SUCCESS;
2584 : }
2585 :
2586 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)
2587 : {
2588 2 : uint32_t _ptr_p;
2589 20 : TALLOC_CTX *_mem_save_p_0 = NULL;
2590 20 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2591 20 : if (ndr_flags & NDR_SCALARS) {
2592 20 : NDR_CHECK(ndr_pull_align(ndr, 5));
2593 20 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
2594 20 : if (_ptr_p) {
2595 20 : NDR_PULL_ALLOC(ndr, r->p);
2596 : } else {
2597 0 : r->p = NULL;
2598 : }
2599 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2600 : }
2601 20 : if (ndr_flags & NDR_BUFFERS) {
2602 20 : if (r->p) {
2603 20 : _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
2604 20 : NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
2605 20 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
2606 20 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
2607 : }
2608 : }
2609 18 : return NDR_ERR_SUCCESS;
2610 : }
2611 :
2612 0 : static void ndr_print_flags_OP_PACKAGE_PART_COLLECTION_ctr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_PACKAGE_PART_COLLECTION_ctr *r)
2613 : {
2614 0 : ndr_print_OP_PACKAGE_PART_COLLECTION_ctr(ndr, name, r);
2615 0 : }
2616 :
2617 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)
2618 : {
2619 20 : ndr_print_struct(ndr, name, "OP_PACKAGE_PART_COLLECTION_ctr");
2620 20 : if (r == NULL) { ndr_print_null(ndr); return; }
2621 20 : ndr->depth++;
2622 20 : ndr_print_ptr(ndr, "p", r->p);
2623 20 : ndr->depth++;
2624 20 : if (r->p) {
2625 20 : ndr_print_OP_PACKAGE_PART_COLLECTION(ndr, "p", r->p);
2626 : }
2627 20 : ndr->depth--;
2628 20 : ndr->depth--;
2629 : }
2630 :
2631 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)
2632 : {
2633 378 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2634 378 : if (ndr_flags & NDR_SCALARS) {
2635 378 : NDR_CHECK(ndr_push_align(ndr, 1));
2636 : {
2637 0 : struct ndr_push *_ndr_s;
2638 378 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
2639 378 : NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
2640 378 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
2641 : }
2642 378 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2643 : }
2644 378 : if (ndr_flags & NDR_BUFFERS) {
2645 0 : }
2646 378 : return NDR_ERR_SUCCESS;
2647 : }
2648 :
2649 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)
2650 : {
2651 20 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2652 20 : if (ndr_flags & NDR_SCALARS) {
2653 20 : NDR_CHECK(ndr_pull_align(ndr, 1));
2654 : {
2655 2 : struct ndr_pull *_ndr_s;
2656 20 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
2657 20 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
2658 20 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
2659 : }
2660 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2661 : }
2662 20 : if (ndr_flags & NDR_BUFFERS) {
2663 2 : }
2664 20 : return NDR_ERR_SUCCESS;
2665 : }
2666 :
2667 0 : static void ndr_print_flags_OP_PACKAGE_PART_COLLECTION_serialized_ptr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_PACKAGE_PART_COLLECTION_serialized_ptr *r)
2668 : {
2669 0 : ndr_print_OP_PACKAGE_PART_COLLECTION_serialized_ptr(ndr, name, r);
2670 0 : }
2671 :
2672 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)
2673 : {
2674 20 : ndr_print_struct(ndr, name, "OP_PACKAGE_PART_COLLECTION_serialized_ptr");
2675 20 : if (r == NULL) { ndr_print_null(ndr); return; }
2676 20 : ndr->depth++;
2677 20 : ndr_print_OP_PACKAGE_PART_COLLECTION_ctr(ndr, "s", &r->s);
2678 20 : ndr->depth--;
2679 : }
2680 :
2681 288 : _PUBLIC_ size_t ndr_size_OP_PACKAGE_PART_COLLECTION_serialized_ptr(const struct OP_PACKAGE_PART_COLLECTION_serialized_ptr *r, libndr_flags flags)
2682 : {
2683 288 : return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_PACKAGE_PART_COLLECTION_serialized_ptr);
2684 : }
2685 :
2686 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)
2687 : {
2688 180 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2689 180 : if (ndr_flags & NDR_SCALARS) {
2690 90 : NDR_CHECK(ndr_push_align(ndr, 5));
2691 90 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_OP_PACKAGE_PART_COLLECTION_serialized_ptr(r->w, 0)));
2692 90 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->w));
2693 90 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2694 : }
2695 180 : if (ndr_flags & NDR_BUFFERS) {
2696 90 : if (r->w) {
2697 : {
2698 0 : struct ndr_push *_ndr_w;
2699 90 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_w, 4, ndr_size_OP_PACKAGE_PART_COLLECTION_serialized_ptr(r->w, 0)));
2700 90 : NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION_serialized_ptr(_ndr_w, NDR_SCALARS|NDR_BUFFERS, r->w));
2701 90 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_w, 4, ndr_size_OP_PACKAGE_PART_COLLECTION_serialized_ptr(r->w, 0)));
2702 : }
2703 : }
2704 : }
2705 180 : return NDR_ERR_SUCCESS;
2706 : }
2707 :
2708 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)
2709 : {
2710 4 : uint32_t _ptr_w;
2711 40 : TALLOC_CTX *_mem_save_w_0 = NULL;
2712 40 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2713 40 : if (ndr_flags & NDR_SCALARS) {
2714 20 : NDR_CHECK(ndr_pull_align(ndr, 5));
2715 20 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbBlob));
2716 20 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_w));
2717 20 : if (_ptr_w) {
2718 20 : NDR_PULL_ALLOC(ndr, r->w);
2719 : } else {
2720 0 : r->w = NULL;
2721 : }
2722 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2723 : }
2724 40 : if (ndr_flags & NDR_BUFFERS) {
2725 20 : if (r->w) {
2726 20 : _mem_save_w_0 = NDR_PULL_GET_MEM_CTX(ndr);
2727 20 : NDR_PULL_SET_MEM_CTX(ndr, r->w, 0);
2728 : {
2729 2 : struct ndr_pull *_ndr_w;
2730 20 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_w, 4, r->cbBlob));
2731 20 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION_serialized_ptr(_ndr_w, NDR_SCALARS|NDR_BUFFERS, r->w));
2732 20 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_w, 4, r->cbBlob));
2733 : }
2734 20 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_w_0, 0);
2735 : }
2736 : }
2737 36 : return NDR_ERR_SUCCESS;
2738 : }
2739 :
2740 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)
2741 : {
2742 20 : ndr_print_struct(ndr, name, "OP_PACKAGE_PART_COLLECTION_blob");
2743 20 : if (r == NULL) { ndr_print_null(ndr); return; }
2744 20 : ndr->depth++;
2745 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);
2746 20 : ndr_print_ptr(ndr, "w", r->w);
2747 20 : ndr->depth++;
2748 20 : if (r->w) {
2749 20 : ndr_print_OP_PACKAGE_PART_COLLECTION_serialized_ptr(ndr, "w", r->w);
2750 : }
2751 20 : ndr->depth--;
2752 20 : ndr->depth--;
2753 : }
2754 :
2755 90 : static enum ndr_err_code ndr_push_OP_PACKAGE(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct OP_PACKAGE *r)
2756 : {
2757 90 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2758 90 : if (ndr_flags & NDR_SCALARS) {
2759 90 : NDR_CHECK(ndr_push_align(ndr, 5));
2760 90 : NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->EncryptionType));
2761 90 : NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->EncryptionContext));
2762 90 : NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION_blob(ndr, NDR_SCALARS, &r->WrappedPartCollection));
2763 90 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbDecryptedPartCollection));
2764 90 : NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
2765 90 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2766 : }
2767 90 : if (ndr_flags & NDR_BUFFERS) {
2768 90 : NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->EncryptionContext));
2769 90 : NDR_CHECK(ndr_push_OP_PACKAGE_PART_COLLECTION_blob(ndr, NDR_BUFFERS, &r->WrappedPartCollection));
2770 90 : NDR_CHECK(ndr_push_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
2771 : }
2772 90 : return NDR_ERR_SUCCESS;
2773 : }
2774 :
2775 20 : static enum ndr_err_code ndr_pull_OP_PACKAGE(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_PACKAGE *r)
2776 : {
2777 20 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2778 20 : if (ndr_flags & NDR_SCALARS) {
2779 20 : NDR_CHECK(ndr_pull_align(ndr, 5));
2780 20 : NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->EncryptionType));
2781 20 : NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->EncryptionContext));
2782 20 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION_blob(ndr, NDR_SCALARS, &r->WrappedPartCollection));
2783 20 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbDecryptedPartCollection));
2784 20 : NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_SCALARS, &r->Extension));
2785 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2786 : }
2787 20 : if (ndr_flags & NDR_BUFFERS) {
2788 20 : NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->EncryptionContext));
2789 20 : NDR_CHECK(ndr_pull_OP_PACKAGE_PART_COLLECTION_blob(ndr, NDR_BUFFERS, &r->WrappedPartCollection));
2790 20 : NDR_CHECK(ndr_pull_OP_BLOB(ndr, NDR_BUFFERS, &r->Extension));
2791 : }
2792 18 : return NDR_ERR_SUCCESS;
2793 : }
2794 :
2795 20 : _PUBLIC_ void ndr_print_OP_PACKAGE(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE *r)
2796 : {
2797 20 : ndr_print_struct(ndr, name, "OP_PACKAGE");
2798 20 : if (r == NULL) { ndr_print_null(ndr); return; }
2799 20 : ndr->depth++;
2800 20 : ndr_print_GUID(ndr, "EncryptionType", &r->EncryptionType);
2801 20 : ndr_print_OP_BLOB(ndr, "EncryptionContext", &r->EncryptionContext);
2802 20 : ndr_print_OP_PACKAGE_PART_COLLECTION_blob(ndr, "WrappedPartCollection", &r->WrappedPartCollection);
2803 20 : ndr_print_uint32(ndr, "cbDecryptedPartCollection", r->cbDecryptedPartCollection);
2804 20 : ndr_print_OP_BLOB(ndr, "Extension", &r->Extension);
2805 20 : ndr->depth--;
2806 : }
2807 :
2808 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)
2809 : {
2810 90 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2811 90 : if (ndr_flags & NDR_SCALARS) {
2812 90 : NDR_CHECK(ndr_push_align(ndr, 5));
2813 90 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
2814 90 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2815 : }
2816 90 : if (ndr_flags & NDR_BUFFERS) {
2817 90 : if (r->p) {
2818 90 : NDR_CHECK(ndr_push_OP_PACKAGE(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
2819 : }
2820 : }
2821 90 : return NDR_ERR_SUCCESS;
2822 : }
2823 :
2824 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)
2825 : {
2826 2 : uint32_t _ptr_p;
2827 20 : TALLOC_CTX *_mem_save_p_0 = NULL;
2828 20 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2829 20 : if (ndr_flags & NDR_SCALARS) {
2830 20 : NDR_CHECK(ndr_pull_align(ndr, 5));
2831 20 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
2832 20 : if (_ptr_p) {
2833 20 : NDR_PULL_ALLOC(ndr, r->p);
2834 : } else {
2835 0 : r->p = NULL;
2836 : }
2837 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2838 : }
2839 20 : if (ndr_flags & NDR_BUFFERS) {
2840 20 : if (r->p) {
2841 20 : _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
2842 20 : NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
2843 20 : NDR_CHECK(ndr_pull_OP_PACKAGE(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
2844 20 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
2845 : }
2846 : }
2847 18 : return NDR_ERR_SUCCESS;
2848 : }
2849 :
2850 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)
2851 : {
2852 0 : ndr_print_OP_PACKAGE_ctr(ndr, name, r);
2853 0 : }
2854 :
2855 20 : _PUBLIC_ void ndr_print_OP_PACKAGE_ctr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_ctr *r)
2856 : {
2857 20 : ndr_print_struct(ndr, name, "OP_PACKAGE_ctr");
2858 20 : if (r == NULL) { ndr_print_null(ndr); return; }
2859 20 : ndr->depth++;
2860 20 : ndr_print_ptr(ndr, "p", r->p);
2861 20 : ndr->depth++;
2862 20 : if (r->p) {
2863 20 : ndr_print_OP_PACKAGE(ndr, "p", r->p);
2864 : }
2865 20 : ndr->depth--;
2866 20 : ndr->depth--;
2867 : }
2868 :
2869 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)
2870 : {
2871 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2872 0 : if (ndr_flags & NDR_SCALARS) {
2873 0 : NDR_CHECK(ndr_push_align(ndr, 1));
2874 : {
2875 0 : struct ndr_push *_ndr_s;
2876 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
2877 0 : NDR_CHECK(ndr_push_OP_PACKAGE_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
2878 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
2879 : }
2880 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2881 : }
2882 0 : if (ndr_flags & NDR_BUFFERS) {
2883 0 : }
2884 0 : return NDR_ERR_SUCCESS;
2885 : }
2886 :
2887 0 : _PUBLIC_ enum ndr_err_code ndr_pull_OP_PACKAGE_serialized_ptr(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct OP_PACKAGE_serialized_ptr *r)
2888 : {
2889 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2890 0 : if (ndr_flags & NDR_SCALARS) {
2891 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
2892 : {
2893 0 : struct ndr_pull *_ndr_s;
2894 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
2895 0 : NDR_CHECK(ndr_pull_OP_PACKAGE_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
2896 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
2897 : }
2898 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2899 : }
2900 0 : if (ndr_flags & NDR_BUFFERS) {
2901 0 : }
2902 0 : return NDR_ERR_SUCCESS;
2903 : }
2904 :
2905 0 : static void ndr_print_flags_OP_PACKAGE_serialized_ptr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct OP_PACKAGE_serialized_ptr *r)
2906 : {
2907 0 : ndr_print_OP_PACKAGE_serialized_ptr(ndr, name, r);
2908 0 : }
2909 :
2910 0 : _PUBLIC_ void ndr_print_OP_PACKAGE_serialized_ptr(struct ndr_print *ndr, const char *name, const struct OP_PACKAGE_serialized_ptr *r)
2911 : {
2912 0 : ndr_print_struct(ndr, name, "OP_PACKAGE_serialized_ptr");
2913 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2914 0 : ndr->depth++;
2915 0 : ndr_print_OP_PACKAGE_ctr(ndr, "s", &r->s);
2916 0 : ndr->depth--;
2917 : }
2918 :
2919 0 : _PUBLIC_ size_t ndr_size_OP_PACKAGE_serialized_ptr(const struct OP_PACKAGE_serialized_ptr *r, libndr_flags flags)
2920 : {
2921 0 : return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_OP_PACKAGE_serialized_ptr);
2922 : }
2923 :
2924 36 : _PUBLIC_ enum ndr_err_code ndr_push_ODJFormat(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum ODJFormat r)
2925 : {
2926 36 : NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
2927 36 : return NDR_ERR_SUCCESS;
2928 : }
2929 :
2930 40 : _PUBLIC_ enum ndr_err_code ndr_pull_ODJFormat(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum ODJFormat *r)
2931 : {
2932 4 : uint32_t v;
2933 40 : NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
2934 40 : *r = v;
2935 40 : return NDR_ERR_SUCCESS;
2936 : }
2937 :
2938 40 : _PUBLIC_ void ndr_print_ODJFormat(struct ndr_print *ndr, const char *name, enum ODJFormat r)
2939 : {
2940 40 : const char *val = NULL;
2941 :
2942 40 : switch (r) {
2943 20 : case ODJ_WIN7_FORMAT: val = "ODJ_WIN7_FORMAT"; break;
2944 20 : case ODJ_WIN8_FORMAT: val = "ODJ_WIN8_FORMAT"; break;
2945 : }
2946 40 : ndr_print_enum(ndr, name, "ENUM", val, r);
2947 40 : }
2948 :
2949 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)
2950 : {
2951 0 : uint32_t level;
2952 180 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2953 180 : if (ndr_flags & NDR_SCALARS) {
2954 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
2955 180 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
2956 180 : NDR_CHECK(ndr_push_union_align(ndr, 1));
2957 180 : switch (level) {
2958 90 : case ODJ_WIN7_FORMAT: {
2959 : {
2960 0 : struct ndr_push *_ndr_odj_win7blob;
2961 90 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_odj_win7blob, 0xFFFFFC01, -1));
2962 90 : NDR_CHECK(ndr_push_ODJ_WIN7BLOB(_ndr_odj_win7blob, NDR_SCALARS|NDR_BUFFERS, &r->odj_win7blob));
2963 90 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_odj_win7blob, 0xFFFFFC01, -1));
2964 : }
2965 90 : break; }
2966 :
2967 90 : case ODJ_WIN8_FORMAT: {
2968 : {
2969 0 : struct ndr_push *_ndr_op_package;
2970 90 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_op_package, 0xFFFFFC01, -1));
2971 90 : NDR_CHECK(ndr_push_OP_PACKAGE_ctr(_ndr_op_package, NDR_SCALARS|NDR_BUFFERS, &r->op_package));
2972 90 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_op_package, 0xFFFFFC01, -1));
2973 : }
2974 90 : break; }
2975 :
2976 0 : default: {
2977 : {
2978 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
2979 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2980 : {
2981 0 : struct ndr_push *_ndr_blob;
2982 0 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_blob, 0xFFFFFC01, -1));
2983 0 : NDR_CHECK(ndr_push_DATA_BLOB(_ndr_blob, NDR_SCALARS, r->blob));
2984 0 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_blob, 0xFFFFFC01, -1));
2985 : }
2986 0 : ndr->flags = _flags_save_DATA_BLOB;
2987 : }
2988 0 : break; }
2989 :
2990 : }
2991 : }
2992 180 : if (ndr_flags & NDR_BUFFERS) {
2993 180 : if (!(ndr_flags & NDR_SCALARS)) {
2994 : /* We didn't get it above, and the token is not needed after this. */
2995 0 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
2996 : }
2997 180 : switch (level) {
2998 90 : case ODJ_WIN7_FORMAT:
2999 90 : break;
3000 :
3001 90 : case ODJ_WIN8_FORMAT:
3002 90 : break;
3003 :
3004 0 : default:
3005 0 : break;
3006 :
3007 : }
3008 : }
3009 180 : return NDR_ERR_SUCCESS;
3010 : }
3011 :
3012 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)
3013 : {
3014 4 : uint32_t level;
3015 40 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3016 40 : if (ndr_flags & NDR_SCALARS) {
3017 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
3018 40 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
3019 40 : NDR_CHECK(ndr_pull_union_align(ndr, 1));
3020 40 : switch (level) {
3021 20 : case ODJ_WIN7_FORMAT: {
3022 : {
3023 2 : struct ndr_pull *_ndr_odj_win7blob;
3024 20 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_odj_win7blob, 0xFFFFFC01, -1));
3025 20 : NDR_CHECK(ndr_pull_ODJ_WIN7BLOB(_ndr_odj_win7blob, NDR_SCALARS|NDR_BUFFERS, &r->odj_win7blob));
3026 20 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_odj_win7blob, 0xFFFFFC01, -1));
3027 : }
3028 20 : break; }
3029 :
3030 20 : case ODJ_WIN8_FORMAT: {
3031 : {
3032 2 : struct ndr_pull *_ndr_op_package;
3033 20 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_op_package, 0xFFFFFC01, -1));
3034 20 : NDR_CHECK(ndr_pull_OP_PACKAGE_ctr(_ndr_op_package, NDR_SCALARS|NDR_BUFFERS, &r->op_package));
3035 20 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_op_package, 0xFFFFFC01, -1));
3036 : }
3037 20 : break; }
3038 :
3039 0 : default: {
3040 : {
3041 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
3042 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
3043 : {
3044 0 : struct ndr_pull *_ndr_blob;
3045 0 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_blob, 0xFFFFFC01, -1));
3046 0 : NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_blob, NDR_SCALARS, &r->blob));
3047 0 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_blob, 0xFFFFFC01, -1));
3048 : }
3049 0 : ndr->flags = _flags_save_DATA_BLOB;
3050 : }
3051 0 : break; }
3052 :
3053 : }
3054 : }
3055 40 : if (ndr_flags & NDR_BUFFERS) {
3056 40 : if (!(ndr_flags & NDR_SCALARS)) {
3057 : /* We didn't get it above, and the token is not needed after this. */
3058 0 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
3059 : }
3060 40 : switch (level) {
3061 18 : case ODJ_WIN7_FORMAT:
3062 18 : break;
3063 :
3064 18 : case ODJ_WIN8_FORMAT:
3065 18 : break;
3066 :
3067 0 : default:
3068 0 : break;
3069 :
3070 : }
3071 : }
3072 36 : return NDR_ERR_SUCCESS;
3073 : }
3074 :
3075 40 : _PUBLIC_ void ndr_print_ODJ_BLOB_u(struct ndr_print *ndr, const char *name, const union ODJ_BLOB_u *r)
3076 : {
3077 4 : uint32_t level;
3078 40 : level = ndr_print_steal_switch_value(ndr, r);
3079 40 : ndr_print_union(ndr, name, level, "ODJ_BLOB_u");
3080 40 : switch (level) {
3081 20 : case ODJ_WIN7_FORMAT:
3082 20 : ndr_print_ODJ_WIN7BLOB(ndr, "odj_win7blob", &r->odj_win7blob);
3083 20 : break;
3084 :
3085 20 : case ODJ_WIN8_FORMAT:
3086 20 : ndr_print_OP_PACKAGE_ctr(ndr, "op_package", &r->op_package);
3087 20 : break;
3088 :
3089 0 : default:
3090 : {
3091 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
3092 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
3093 0 : ndr_print_DATA_BLOB(ndr, "blob", r->blob);
3094 0 : ndr->flags = _flags_save_DATA_BLOB;
3095 : }
3096 0 : break;
3097 :
3098 : }
3099 40 : }
3100 :
3101 144 : _PUBLIC_ size_t ndr_size_ODJ_BLOB_u(const union ODJ_BLOB_u *r, uint32_t level, libndr_flags flags)
3102 : {
3103 144 : return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_ODJ_BLOB_u);
3104 : }
3105 :
3106 72 : static enum ndr_err_code ndr_push_ODJ_BLOB(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct ODJ_BLOB *r)
3107 : {
3108 72 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3109 72 : if (ndr_flags & NDR_SCALARS) {
3110 36 : NDR_CHECK(ndr_push_align(ndr, 5));
3111 36 : NDR_CHECK(ndr_push_ODJFormat(ndr, NDR_SCALARS, r->ulODJFormat));
3112 36 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_ODJ_BLOB_u(r->pBlob, r->ulODJFormat, 0)));
3113 36 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->pBlob));
3114 36 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3115 : }
3116 72 : if (ndr_flags & NDR_BUFFERS) {
3117 36 : if (r->pBlob) {
3118 : {
3119 0 : struct ndr_push *_ndr_pBlob;
3120 36 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_pBlob, 4, ndr_size_ODJ_BLOB_u(r->pBlob, r->ulODJFormat, 0)));
3121 36 : NDR_CHECK(ndr_push_set_switch_value(_ndr_pBlob, r->pBlob, r->ulODJFormat));
3122 36 : NDR_CHECK(ndr_push_ODJ_BLOB_u(_ndr_pBlob, NDR_SCALARS|NDR_BUFFERS, r->pBlob));
3123 36 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_pBlob, 4, ndr_size_ODJ_BLOB_u(r->pBlob, r->ulODJFormat, 0)));
3124 : }
3125 : }
3126 : }
3127 72 : return NDR_ERR_SUCCESS;
3128 : }
3129 :
3130 80 : static enum ndr_err_code ndr_pull_ODJ_BLOB(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct ODJ_BLOB *r)
3131 : {
3132 8 : uint32_t _ptr_pBlob;
3133 80 : TALLOC_CTX *_mem_save_pBlob_0 = NULL;
3134 80 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3135 80 : if (ndr_flags & NDR_SCALARS) {
3136 40 : NDR_CHECK(ndr_pull_align(ndr, 5));
3137 40 : NDR_CHECK(ndr_pull_ODJFormat(ndr, NDR_SCALARS, &r->ulODJFormat));
3138 40 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbBlob));
3139 40 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pBlob));
3140 40 : if (_ptr_pBlob) {
3141 40 : NDR_PULL_ALLOC(ndr, r->pBlob);
3142 : } else {
3143 0 : r->pBlob = NULL;
3144 : }
3145 40 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3146 : }
3147 80 : if (ndr_flags & NDR_BUFFERS) {
3148 40 : if (r->pBlob) {
3149 40 : _mem_save_pBlob_0 = NDR_PULL_GET_MEM_CTX(ndr);
3150 40 : NDR_PULL_SET_MEM_CTX(ndr, r->pBlob, 0);
3151 : {
3152 4 : struct ndr_pull *_ndr_pBlob;
3153 40 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_pBlob, 4, r->cbBlob));
3154 40 : NDR_CHECK(ndr_pull_set_switch_value(_ndr_pBlob, r->pBlob, r->ulODJFormat));
3155 40 : NDR_CHECK(ndr_pull_ODJ_BLOB_u(_ndr_pBlob, NDR_SCALARS|NDR_BUFFERS, r->pBlob));
3156 40 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_pBlob, 4, r->cbBlob));
3157 : }
3158 40 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pBlob_0, 0);
3159 : }
3160 : }
3161 72 : return NDR_ERR_SUCCESS;
3162 : }
3163 :
3164 40 : _PUBLIC_ void ndr_print_ODJ_BLOB(struct ndr_print *ndr, const char *name, const struct ODJ_BLOB *r)
3165 : {
3166 40 : ndr_print_struct(ndr, name, "ODJ_BLOB");
3167 40 : if (r == NULL) { ndr_print_null(ndr); return; }
3168 40 : ndr->depth++;
3169 40 : ndr_print_ODJFormat(ndr, "ulODJFormat", r->ulODJFormat);
3170 40 : ndr_print_uint32(ndr, "cbBlob", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_ODJ_BLOB_u(r->pBlob, r->ulODJFormat, 0):r->cbBlob);
3171 40 : ndr_print_ptr(ndr, "pBlob", r->pBlob);
3172 40 : ndr->depth++;
3173 40 : if (r->pBlob) {
3174 40 : ndr_print_set_switch_value(ndr, r->pBlob, r->ulODJFormat);
3175 40 : ndr_print_ODJ_BLOB_u(ndr, "pBlob", r->pBlob);
3176 : }
3177 40 : ndr->depth--;
3178 40 : ndr->depth--;
3179 : }
3180 :
3181 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)
3182 : {
3183 0 : uint32_t cntr_pBlobs_1;
3184 18 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3185 18 : if (ndr_flags & NDR_SCALARS) {
3186 18 : NDR_CHECK(ndr_push_align(ndr, 5));
3187 18 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
3188 18 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulcBlobs));
3189 18 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->pBlobs));
3190 18 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3191 : }
3192 18 : if (ndr_flags & NDR_BUFFERS) {
3193 18 : if (r->pBlobs) {
3194 18 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->ulcBlobs));
3195 54 : for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (r->ulcBlobs); cntr_pBlobs_1++) {
3196 36 : NDR_CHECK(ndr_push_ODJ_BLOB(ndr, NDR_SCALARS, &r->pBlobs[cntr_pBlobs_1]));
3197 : }
3198 54 : for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (r->ulcBlobs); cntr_pBlobs_1++) {
3199 36 : NDR_CHECK(ndr_push_ODJ_BLOB(ndr, NDR_BUFFERS, &r->pBlobs[cntr_pBlobs_1]));
3200 : }
3201 : }
3202 : }
3203 18 : return NDR_ERR_SUCCESS;
3204 : }
3205 :
3206 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)
3207 : {
3208 2 : uint32_t _ptr_pBlobs;
3209 20 : uint32_t size_pBlobs_1 = 0;
3210 2 : uint32_t cntr_pBlobs_1;
3211 20 : TALLOC_CTX *_mem_save_pBlobs_0 = NULL;
3212 20 : TALLOC_CTX *_mem_save_pBlobs_1 = NULL;
3213 20 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3214 20 : if (ndr_flags & NDR_SCALARS) {
3215 20 : NDR_CHECK(ndr_pull_align(ndr, 5));
3216 20 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulVersion));
3217 20 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulcBlobs));
3218 20 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pBlobs));
3219 20 : if (_ptr_pBlobs) {
3220 20 : NDR_PULL_ALLOC(ndr, r->pBlobs);
3221 : } else {
3222 0 : r->pBlobs = NULL;
3223 : }
3224 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3225 : }
3226 20 : if (ndr_flags & NDR_BUFFERS) {
3227 20 : if (r->pBlobs) {
3228 20 : _mem_save_pBlobs_0 = NDR_PULL_GET_MEM_CTX(ndr);
3229 20 : NDR_PULL_SET_MEM_CTX(ndr, r->pBlobs, 0);
3230 20 : NDR_CHECK(ndr_pull_array_size(ndr, &r->pBlobs));
3231 20 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pBlobs, &size_pBlobs_1));
3232 20 : NDR_PULL_ALLOC_N(ndr, r->pBlobs, size_pBlobs_1);
3233 20 : _mem_save_pBlobs_1 = NDR_PULL_GET_MEM_CTX(ndr);
3234 20 : NDR_PULL_SET_MEM_CTX(ndr, r->pBlobs, 0);
3235 60 : for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (size_pBlobs_1); cntr_pBlobs_1++) {
3236 40 : NDR_CHECK(ndr_pull_ODJ_BLOB(ndr, NDR_SCALARS, &r->pBlobs[cntr_pBlobs_1]));
3237 : }
3238 60 : for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (size_pBlobs_1); cntr_pBlobs_1++) {
3239 40 : NDR_CHECK(ndr_pull_ODJ_BLOB(ndr, NDR_BUFFERS, &r->pBlobs[cntr_pBlobs_1]));
3240 : }
3241 20 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pBlobs_1, 0);
3242 20 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pBlobs_0, 0);
3243 : }
3244 20 : if (r->pBlobs) {
3245 20 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pBlobs, r->ulcBlobs));
3246 : }
3247 60 : for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (size_pBlobs_1); cntr_pBlobs_1++) {
3248 4 : }
3249 : }
3250 18 : return NDR_ERR_SUCCESS;
3251 : }
3252 :
3253 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)
3254 : {
3255 0 : ndr_print_ODJ_PROVISION_DATA(ndr, name, r);
3256 0 : }
3257 :
3258 20 : _PUBLIC_ void ndr_print_ODJ_PROVISION_DATA(struct ndr_print *ndr, const char *name, const struct ODJ_PROVISION_DATA *r)
3259 : {
3260 2 : uint32_t cntr_pBlobs_1;
3261 20 : ndr_print_struct(ndr, name, "ODJ_PROVISION_DATA");
3262 20 : if (r == NULL) { ndr_print_null(ndr); return; }
3263 20 : ndr->depth++;
3264 20 : ndr_print_uint32(ndr, "ulVersion", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->ulVersion);
3265 20 : ndr_print_uint32(ndr, "ulcBlobs", r->ulcBlobs);
3266 20 : ndr_print_ptr(ndr, "pBlobs", r->pBlobs);
3267 20 : ndr->depth++;
3268 20 : if (r->pBlobs) {
3269 20 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "pBlobs", (uint32_t)(r->ulcBlobs));
3270 20 : ndr->depth++;
3271 60 : for (cntr_pBlobs_1 = 0; cntr_pBlobs_1 < (r->ulcBlobs); cntr_pBlobs_1++) {
3272 40 : ndr_print_ODJ_BLOB(ndr, "pBlobs", &r->pBlobs[cntr_pBlobs_1]);
3273 : }
3274 20 : ndr->depth--;
3275 : }
3276 20 : ndr->depth--;
3277 20 : ndr->depth--;
3278 : }
3279 :
3280 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)
3281 : {
3282 18 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3283 18 : if (ndr_flags & NDR_SCALARS) {
3284 18 : NDR_CHECK(ndr_push_align(ndr, 5));
3285 18 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->p));
3286 18 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3287 : }
3288 18 : if (ndr_flags & NDR_BUFFERS) {
3289 18 : if (r->p) {
3290 18 : NDR_CHECK(ndr_push_ODJ_PROVISION_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
3291 : }
3292 : }
3293 18 : return NDR_ERR_SUCCESS;
3294 : }
3295 :
3296 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)
3297 : {
3298 2 : uint32_t _ptr_p;
3299 20 : TALLOC_CTX *_mem_save_p_0 = NULL;
3300 20 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3301 20 : if (ndr_flags & NDR_SCALARS) {
3302 20 : NDR_CHECK(ndr_pull_align(ndr, 5));
3303 20 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_p));
3304 20 : if (_ptr_p) {
3305 20 : NDR_PULL_ALLOC(ndr, r->p);
3306 : } else {
3307 0 : r->p = NULL;
3308 : }
3309 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3310 : }
3311 20 : if (ndr_flags & NDR_BUFFERS) {
3312 20 : if (r->p) {
3313 20 : _mem_save_p_0 = NDR_PULL_GET_MEM_CTX(ndr);
3314 20 : NDR_PULL_SET_MEM_CTX(ndr, r->p, 0);
3315 20 : NDR_CHECK(ndr_pull_ODJ_PROVISION_DATA(ndr, NDR_SCALARS|NDR_BUFFERS, r->p));
3316 20 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_p_0, 0);
3317 : }
3318 : }
3319 18 : return NDR_ERR_SUCCESS;
3320 : }
3321 :
3322 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)
3323 : {
3324 0 : ndr_print_ODJ_PROVISION_DATA_ctr(ndr, name, r);
3325 0 : }
3326 :
3327 2 : _PUBLIC_ void ndr_print_ODJ_PROVISION_DATA_ctr(struct ndr_print *ndr, const char *name, const struct ODJ_PROVISION_DATA_ctr *r)
3328 : {
3329 2 : ndr_print_struct(ndr, name, "ODJ_PROVISION_DATA_ctr");
3330 2 : if (r == NULL) { ndr_print_null(ndr); return; }
3331 2 : ndr->depth++;
3332 2 : ndr_print_ptr(ndr, "p", r->p);
3333 2 : ndr->depth++;
3334 2 : if (r->p) {
3335 2 : ndr_print_ODJ_PROVISION_DATA(ndr, "p", r->p);
3336 : }
3337 2 : ndr->depth--;
3338 2 : ndr->depth--;
3339 : }
3340 :
3341 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)
3342 : {
3343 18 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3344 18 : if (ndr_flags & NDR_SCALARS) {
3345 18 : NDR_CHECK(ndr_push_align(ndr, 1));
3346 : {
3347 0 : struct ndr_push *_ndr_s;
3348 18 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
3349 18 : NDR_CHECK(ndr_push_ODJ_PROVISION_DATA_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
3350 18 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
3351 : }
3352 18 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3353 : }
3354 18 : if (ndr_flags & NDR_BUFFERS) {
3355 0 : }
3356 18 : return NDR_ERR_SUCCESS;
3357 : }
3358 :
3359 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)
3360 : {
3361 20 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3362 20 : if (ndr_flags & NDR_SCALARS) {
3363 20 : NDR_CHECK(ndr_pull_align(ndr, 1));
3364 : {
3365 2 : struct ndr_pull *_ndr_s;
3366 20 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_s, 0xFFFFFC01, -1));
3367 20 : NDR_CHECK(ndr_pull_ODJ_PROVISION_DATA_ctr(_ndr_s, NDR_SCALARS|NDR_BUFFERS, &r->s));
3368 20 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_s, 0xFFFFFC01, -1));
3369 : }
3370 20 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3371 : }
3372 20 : if (ndr_flags & NDR_BUFFERS) {
3373 2 : }
3374 20 : return NDR_ERR_SUCCESS;
3375 : }
3376 :
3377 0 : static void ndr_print_flags_ODJ_PROVISION_DATA_serialized_ptr(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct ODJ_PROVISION_DATA_serialized_ptr *r)
3378 : {
3379 0 : ndr_print_ODJ_PROVISION_DATA_serialized_ptr(ndr, name, r);
3380 0 : }
3381 :
3382 2 : _PUBLIC_ void ndr_print_ODJ_PROVISION_DATA_serialized_ptr(struct ndr_print *ndr, const char *name, const struct ODJ_PROVISION_DATA_serialized_ptr *r)
3383 : {
3384 2 : ndr_print_struct(ndr, name, "ODJ_PROVISION_DATA_serialized_ptr");
3385 2 : if (r == NULL) { ndr_print_null(ndr); return; }
3386 2 : ndr->depth++;
3387 2 : ndr_print_ODJ_PROVISION_DATA_ctr(ndr, "s", &r->s);
3388 2 : ndr->depth--;
3389 : }
3390 :
3391 0 : _PUBLIC_ size_t ndr_size_ODJ_PROVISION_DATA_serialized_ptr(const struct ODJ_PROVISION_DATA_serialized_ptr *r, libndr_flags flags)
3392 : {
3393 0 : return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ODJ_PROVISION_DATA_serialized_ptr);
3394 : }
3395 :
3396 : #ifndef SKIP_NDR_TABLE_ODJ
3397 : static const struct ndr_interface_public_struct ODJ_public_structs[] = {
3398 : {
3399 : .name = "ODJ_WIN7BLOB_ctr",
3400 : .struct_size = sizeof(struct ODJ_WIN7BLOB_ctr ),
3401 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_WIN7BLOB_ctr,
3402 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_WIN7BLOB_ctr,
3403 : .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_WIN7BLOB_ctr,
3404 : },
3405 : {
3406 : .name = "ODJ_WIN7BLOB_serialized_ptr",
3407 : .struct_size = sizeof(struct ODJ_WIN7BLOB_serialized_ptr ),
3408 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_WIN7BLOB_serialized_ptr,
3409 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_WIN7BLOB_serialized_ptr,
3410 : .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_WIN7BLOB_serialized_ptr,
3411 : },
3412 : {
3413 : .name = "OP_JOINPROV2_PART_ctr",
3414 : .struct_size = sizeof(struct OP_JOINPROV2_PART_ctr ),
3415 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_JOINPROV2_PART_ctr,
3416 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_JOINPROV2_PART_ctr,
3417 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_JOINPROV2_PART_ctr,
3418 : },
3419 : {
3420 : .name = "OP_JOINPROV2_PART_serialized_ptr",
3421 : .struct_size = sizeof(struct OP_JOINPROV2_PART_serialized_ptr ),
3422 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_JOINPROV2_PART_serialized_ptr,
3423 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_JOINPROV2_PART_serialized_ptr,
3424 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_JOINPROV2_PART_serialized_ptr,
3425 : },
3426 : {
3427 : .name = "OP_JOINPROV3_PART_ctr",
3428 : .struct_size = sizeof(struct OP_JOINPROV3_PART_ctr ),
3429 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_JOINPROV3_PART_ctr,
3430 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_JOINPROV3_PART_ctr,
3431 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_JOINPROV3_PART_ctr,
3432 : },
3433 : {
3434 : .name = "OP_JOINPROV3_PART_serialized_ptr",
3435 : .struct_size = sizeof(struct OP_JOINPROV3_PART_serialized_ptr ),
3436 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_JOINPROV3_PART_serialized_ptr,
3437 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_JOINPROV3_PART_serialized_ptr,
3438 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_JOINPROV3_PART_serialized_ptr,
3439 : },
3440 : {
3441 : .name = "OP_POLICY_PART_ctr",
3442 : .struct_size = sizeof(struct OP_POLICY_PART_ctr ),
3443 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_POLICY_PART_ctr,
3444 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_POLICY_PART_ctr,
3445 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_POLICY_PART_ctr,
3446 : },
3447 : {
3448 : .name = "OP_POLICY_PART_serialized_ptr",
3449 : .struct_size = sizeof(struct OP_POLICY_PART_serialized_ptr ),
3450 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_POLICY_PART_serialized_ptr,
3451 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_POLICY_PART_serialized_ptr,
3452 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_POLICY_PART_serialized_ptr,
3453 : },
3454 : {
3455 : .name = "OP_CERT_PART_ctr",
3456 : .struct_size = sizeof(struct OP_CERT_PART_ctr ),
3457 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_CERT_PART_ctr,
3458 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_CERT_PART_ctr,
3459 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_CERT_PART_ctr,
3460 : },
3461 : {
3462 : .name = "OP_CERT_PART_serialized_ptr",
3463 : .struct_size = sizeof(struct OP_CERT_PART_serialized_ptr ),
3464 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_CERT_PART_serialized_ptr,
3465 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_CERT_PART_serialized_ptr,
3466 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_CERT_PART_serialized_ptr,
3467 : },
3468 : {
3469 : .name = "OP_PACKAGE_PART_ctr",
3470 : .struct_size = sizeof(struct OP_PACKAGE_PART_ctr ),
3471 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_PART_ctr,
3472 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_PART_ctr,
3473 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_PART_ctr,
3474 : },
3475 : {
3476 : .name = "OP_PACKAGE_PART_serialized_ptr",
3477 : .struct_size = sizeof(struct OP_PACKAGE_PART_serialized_ptr ),
3478 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_PART_serialized_ptr,
3479 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_PART_serialized_ptr,
3480 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_PART_serialized_ptr,
3481 : },
3482 : {
3483 : .name = "OP_PACKAGE_PART_COLLECTION_ctr",
3484 : .struct_size = sizeof(struct OP_PACKAGE_PART_COLLECTION_ctr ),
3485 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_PART_COLLECTION_ctr,
3486 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_PART_COLLECTION_ctr,
3487 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_PART_COLLECTION_ctr,
3488 : },
3489 : {
3490 : .name = "OP_PACKAGE_PART_COLLECTION_serialized_ptr",
3491 : .struct_size = sizeof(struct OP_PACKAGE_PART_COLLECTION_serialized_ptr ),
3492 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_PART_COLLECTION_serialized_ptr,
3493 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_PART_COLLECTION_serialized_ptr,
3494 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_PART_COLLECTION_serialized_ptr,
3495 : },
3496 : {
3497 : .name = "OP_PACKAGE_ctr",
3498 : .struct_size = sizeof(struct OP_PACKAGE_ctr ),
3499 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_ctr,
3500 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_ctr,
3501 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_ctr,
3502 : },
3503 : {
3504 : .name = "OP_PACKAGE_serialized_ptr",
3505 : .struct_size = sizeof(struct OP_PACKAGE_serialized_ptr ),
3506 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_OP_PACKAGE_serialized_ptr,
3507 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_OP_PACKAGE_serialized_ptr,
3508 : .ndr_print = (ndr_print_function_t) ndr_print_flags_OP_PACKAGE_serialized_ptr,
3509 : },
3510 : {
3511 : .name = "ODJ_PROVISION_DATA",
3512 : .struct_size = sizeof(struct ODJ_PROVISION_DATA ),
3513 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_PROVISION_DATA,
3514 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_PROVISION_DATA,
3515 : .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_PROVISION_DATA,
3516 : },
3517 : {
3518 : .name = "ODJ_PROVISION_DATA_ctr",
3519 : .struct_size = sizeof(struct ODJ_PROVISION_DATA_ctr ),
3520 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_PROVISION_DATA_ctr,
3521 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_PROVISION_DATA_ctr,
3522 : .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_PROVISION_DATA_ctr,
3523 : },
3524 : {
3525 : .name = "ODJ_PROVISION_DATA_serialized_ptr",
3526 : .struct_size = sizeof(struct ODJ_PROVISION_DATA_serialized_ptr ),
3527 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_ODJ_PROVISION_DATA_serialized_ptr,
3528 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ODJ_PROVISION_DATA_serialized_ptr,
3529 : .ndr_print = (ndr_print_function_t) ndr_print_flags_ODJ_PROVISION_DATA_serialized_ptr,
3530 : },
3531 : { .name = NULL }
3532 : };
3533 :
3534 : static const struct ndr_interface_call ODJ_calls[] = {
3535 : { .name = NULL }
3536 : };
3537 :
3538 : static const char * const ODJ_endpoint_strings[] = {
3539 : "ncacn_np:[\\pipe\\ODJ]",
3540 : };
3541 :
3542 : static const struct ndr_interface_string_array ODJ_endpoints = {
3543 : .count = 1,
3544 : .names = ODJ_endpoint_strings
3545 : };
3546 :
3547 : static const char * const ODJ_authservice_strings[] = {
3548 : "host",
3549 : };
3550 :
3551 : static const struct ndr_interface_string_array ODJ_authservices = {
3552 : .count = 1,
3553 : .names = ODJ_authservice_strings
3554 : };
3555 :
3556 :
3557 : const struct ndr_interface_table ndr_table_ODJ = {
3558 : .name = "ODJ",
3559 : .syntax_id = {
3560 : {0x11111111,0x3333,0x5555,{0x77,0x77},{0x99,0x99,0x99,0x99}},
3561 : NDR_ODJ_VERSION
3562 : },
3563 : .helpstring = NDR_ODJ_HELPSTRING,
3564 : .num_calls = 0,
3565 : .calls = ODJ_calls,
3566 : .num_public_structs = 19,
3567 : .public_structs = ODJ_public_structs,
3568 : .endpoints = &ODJ_endpoints,
3569 : .authservices = &ODJ_authservices
3570 : };
3571 :
3572 : #endif /* SKIP_NDR_TABLE_ODJ */
|
