Line data Source code
1 : /* parser auto-generated by pidl */
2 :
3 : #include "includes.h"
4 : #include "bin/default/librpc/gen_ndr/ndr_winreg.h"
5 :
6 : #include "librpc/gen_ndr/ndr_lsa.h"
7 : #include "librpc/gen_ndr/ndr_security.h"
8 : #include "librpc/gen_ndr/ndr_misc.h"
9 3319 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_AccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
10 : {
11 3319 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12 3319 : return NDR_ERR_SUCCESS;
13 : }
14 :
15 3319 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_AccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16 : {
17 : uint32_t v;
18 3319 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19 3319 : *r = v;
20 3319 : return NDR_ERR_SUCCESS;
21 : }
22 :
23 0 : _PUBLIC_ void ndr_print_winreg_AccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
24 : {
25 0 : ndr_print_uint32(ndr, name, r);
26 0 : ndr->depth++;
27 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_QUERY_VALUE", KEY_QUERY_VALUE, r);
28 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_SET_VALUE", KEY_SET_VALUE, r);
29 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_CREATE_SUB_KEY", KEY_CREATE_SUB_KEY, r);
30 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_ENUMERATE_SUB_KEYS", KEY_ENUMERATE_SUB_KEYS, r);
31 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_NOTIFY", KEY_NOTIFY, r);
32 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_CREATE_LINK", KEY_CREATE_LINK, r);
33 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_WOW64_64KEY", KEY_WOW64_64KEY, r);
34 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_WOW64_32KEY", KEY_WOW64_32KEY, r);
35 0 : ndr->depth--;
36 0 : }
37 :
38 28870 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_String(struct ndr_push *ndr, int ndr_flags, const struct winreg_String *r)
39 : {
40 28870 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
41 28870 : if (ndr_flags & NDR_SCALARS) {
42 28870 : NDR_CHECK(ndr_push_align(ndr, 5));
43 28870 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));
44 28870 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));
45 28870 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
46 28870 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
47 : }
48 28870 : if (ndr_flags & NDR_BUFFERS) {
49 28870 : if (r->name) {
50 23616 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
51 23616 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
52 23616 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
53 23616 : NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
54 : }
55 : }
56 28870 : return NDR_ERR_SUCCESS;
57 : }
58 :
59 28866 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_String(struct ndr_pull *ndr, int ndr_flags, struct winreg_String *r)
60 : {
61 : uint32_t _ptr_name;
62 28866 : uint32_t size_name_1 = 0;
63 28866 : uint32_t length_name_1 = 0;
64 28866 : TALLOC_CTX *_mem_save_name_0 = NULL;
65 28866 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
66 28866 : if (ndr_flags & NDR_SCALARS) {
67 28866 : NDR_CHECK(ndr_pull_align(ndr, 5));
68 28866 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_len));
69 28866 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_size));
70 28866 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
71 28866 : if (_ptr_name) {
72 23616 : NDR_PULL_ALLOC(ndr, r->name);
73 : } else {
74 5250 : r->name = NULL;
75 : }
76 28866 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
77 : }
78 28866 : if (ndr_flags & NDR_BUFFERS) {
79 28866 : if (r->name) {
80 23616 : _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
81 23616 : NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
82 23616 : NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
83 23616 : NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
84 23616 : NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->name, &size_name_1));
85 23616 : NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->name, &length_name_1));
86 23616 : if (length_name_1 > size_name_1) {
87 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
88 : }
89 23616 : NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
90 23616 : NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
91 23616 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
92 : }
93 : }
94 28866 : return NDR_ERR_SUCCESS;
95 : }
96 :
97 0 : static void ndr_print_flags_winreg_String(struct ndr_print *ndr, const char *name, int unused, const struct winreg_String *r)
98 : {
99 0 : ndr_print_winreg_String(ndr, name, r);
100 0 : }
101 :
102 8 : _PUBLIC_ void ndr_print_winreg_String(struct ndr_print *ndr, const char *name, const struct winreg_String *r)
103 : {
104 8 : ndr_print_struct(ndr, name, "winreg_String");
105 8 : if (r == NULL) { ndr_print_null(ndr); return; }
106 8 : ndr->depth++;
107 8 : ndr_print_uint16(ndr, "name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name) * 2:r->name_len);
108 8 : ndr_print_uint16(ndr, "name_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name) * 2:r->name_size);
109 8 : ndr_print_ptr(ndr, "name", r->name);
110 8 : ndr->depth++;
111 8 : if (r->name) {
112 0 : ndr_print_string(ndr, "name", r->name);
113 : }
114 8 : ndr->depth--;
115 8 : ndr->depth--;
116 : }
117 :
118 0 : static enum ndr_err_code ndr_push_KeySecurityData(struct ndr_push *ndr, int ndr_flags, const struct KeySecurityData *r)
119 : {
120 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
121 0 : if (ndr_flags & NDR_SCALARS) {
122 0 : NDR_CHECK(ndr_push_align(ndr, 5));
123 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
124 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
125 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
126 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
127 : }
128 0 : if (ndr_flags & NDR_BUFFERS) {
129 0 : if (r->data) {
130 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
131 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
132 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->len));
133 0 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->len));
134 : }
135 : }
136 0 : return NDR_ERR_SUCCESS;
137 : }
138 :
139 0 : static enum ndr_err_code ndr_pull_KeySecurityData(struct ndr_pull *ndr, int ndr_flags, struct KeySecurityData *r)
140 : {
141 : uint32_t _ptr_data;
142 0 : uint32_t size_data_1 = 0;
143 0 : uint32_t length_data_1 = 0;
144 0 : TALLOC_CTX *_mem_save_data_0 = NULL;
145 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
146 0 : if (ndr_flags & NDR_SCALARS) {
147 0 : NDR_CHECK(ndr_pull_align(ndr, 5));
148 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
149 0 : if (_ptr_data) {
150 0 : NDR_PULL_ALLOC(ndr, r->data);
151 : } else {
152 0 : r->data = NULL;
153 : }
154 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
155 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
156 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
157 : }
158 0 : if (ndr_flags & NDR_BUFFERS) {
159 0 : if (r->data) {
160 0 : _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
161 0 : NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
162 0 : NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
163 0 : NDR_CHECK(ndr_pull_array_length(ndr, &r->data));
164 0 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->data, &size_data_1));
165 0 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->data, &length_data_1));
166 0 : if (length_data_1 > size_data_1) {
167 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_1, length_data_1);
168 : }
169 0 : NDR_PULL_ALLOC_N(ndr, r->data, size_data_1);
170 0 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, length_data_1));
171 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
172 : }
173 0 : if (r->data) {
174 0 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->data, r->size));
175 : }
176 0 : if (r->data) {
177 0 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->data, r->len));
178 : }
179 : }
180 0 : return NDR_ERR_SUCCESS;
181 : }
182 :
183 0 : _PUBLIC_ void ndr_print_KeySecurityData(struct ndr_print *ndr, const char *name, const struct KeySecurityData *r)
184 : {
185 0 : ndr_print_struct(ndr, name, "KeySecurityData");
186 0 : if (r == NULL) { ndr_print_null(ndr); return; }
187 0 : ndr->depth++;
188 0 : ndr_print_ptr(ndr, "data", r->data);
189 0 : ndr->depth++;
190 0 : if (r->data) {
191 0 : ndr_print_array_uint8(ndr, "data", r->data, r->len);
192 : }
193 0 : ndr->depth--;
194 0 : ndr_print_uint32(ndr, "size", r->size);
195 0 : ndr_print_uint32(ndr, "len", r->len);
196 0 : ndr->depth--;
197 : }
198 :
199 0 : static enum ndr_err_code ndr_push_winreg_SecBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_SecBuf *r)
200 : {
201 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
202 0 : if (ndr_flags & NDR_SCALARS) {
203 0 : NDR_CHECK(ndr_push_align(ndr, 5));
204 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
205 0 : NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sd));
206 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));
207 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
208 : }
209 0 : if (ndr_flags & NDR_BUFFERS) {
210 0 : NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));
211 : }
212 0 : return NDR_ERR_SUCCESS;
213 : }
214 :
215 0 : static enum ndr_err_code ndr_pull_winreg_SecBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_SecBuf *r)
216 : {
217 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
218 0 : if (ndr_flags & NDR_SCALARS) {
219 0 : NDR_CHECK(ndr_pull_align(ndr, 5));
220 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
221 0 : NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sd));
222 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));
223 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
224 : }
225 0 : if (ndr_flags & NDR_BUFFERS) {
226 0 : NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));
227 : }
228 0 : return NDR_ERR_SUCCESS;
229 : }
230 :
231 0 : _PUBLIC_ void ndr_print_winreg_SecBuf(struct ndr_print *ndr, const char *name, const struct winreg_SecBuf *r)
232 : {
233 0 : ndr_print_struct(ndr, name, "winreg_SecBuf");
234 0 : if (r == NULL) { ndr_print_null(ndr); return; }
235 0 : ndr->depth++;
236 0 : ndr_print_uint32(ndr, "length", r->length);
237 0 : ndr_print_KeySecurityData(ndr, "sd", &r->sd);
238 0 : ndr_print_uint8(ndr, "inherit", r->inherit);
239 0 : ndr->depth--;
240 : }
241 :
242 2896 : static enum ndr_err_code ndr_push_winreg_KeyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
243 : {
244 2896 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
245 2896 : return NDR_ERR_SUCCESS;
246 : }
247 :
248 2896 : static enum ndr_err_code ndr_pull_winreg_KeyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
249 : {
250 : uint32_t v;
251 2896 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
252 2896 : *r = v;
253 2896 : return NDR_ERR_SUCCESS;
254 : }
255 :
256 0 : _PUBLIC_ void ndr_print_winreg_KeyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
257 : {
258 0 : ndr_print_uint32(ndr, name, r);
259 0 : ndr->depth++;
260 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_OPTION_VOLATILE", REG_OPTION_VOLATILE, r);
261 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_OPTION_CREATE_LINK", REG_OPTION_CREATE_LINK, r);
262 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_OPTION_BACKUP_RESTORE", REG_OPTION_BACKUP_RESTORE, r);
263 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_OPTION_OPEN_LINK", REG_OPTION_OPEN_LINK, r);
264 0 : ndr->depth--;
265 0 : }
266 :
267 4109 : static enum ndr_err_code ndr_push_winreg_CreateAction(struct ndr_push *ndr, int ndr_flags, enum winreg_CreateAction r)
268 : {
269 4109 : NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
270 4109 : return NDR_ERR_SUCCESS;
271 : }
272 :
273 4088 : static enum ndr_err_code ndr_pull_winreg_CreateAction(struct ndr_pull *ndr, int ndr_flags, enum winreg_CreateAction *r)
274 : {
275 : uint32_t v;
276 4088 : NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
277 4088 : *r = v;
278 4088 : return NDR_ERR_SUCCESS;
279 : }
280 :
281 42 : _PUBLIC_ void ndr_print_winreg_CreateAction(struct ndr_print *ndr, const char *name, enum winreg_CreateAction r)
282 : {
283 42 : const char *val = NULL;
284 :
285 42 : switch (r) {
286 0 : case REG_ACTION_NONE: val = "REG_ACTION_NONE"; break;
287 42 : case REG_CREATED_NEW_KEY: val = "REG_CREATED_NEW_KEY"; break;
288 0 : case REG_OPENED_EXISTING_KEY: val = "REG_OPENED_EXISTING_KEY"; break;
289 : }
290 42 : ndr_print_enum(ndr, name, "ENUM", val, r);
291 42 : }
292 :
293 1702 : static enum ndr_err_code ndr_push_winreg_StringBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_StringBuf *r)
294 : {
295 1702 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
296 1702 : if (ndr_flags & NDR_SCALARS) {
297 1702 : NDR_CHECK(ndr_push_align(ndr, 5));
298 1702 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term_null(r->name) * 2));
299 1702 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
300 1702 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
301 1702 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
302 : }
303 1702 : if (ndr_flags & NDR_BUFFERS) {
304 1702 : if (r->name) {
305 1174 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
306 1174 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
307 1174 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m_term_null(r->name) * 2 / 2));
308 1174 : NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, strlen_m_term_null(r->name) * 2 / 2, sizeof(uint16_t), CH_UTF16));
309 : }
310 : }
311 1702 : return NDR_ERR_SUCCESS;
312 : }
313 :
314 1688 : static enum ndr_err_code ndr_pull_winreg_StringBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_StringBuf *r)
315 : {
316 : uint32_t _ptr_name;
317 1688 : uint32_t size_name_1 = 0;
318 1688 : uint32_t length_name_1 = 0;
319 1688 : TALLOC_CTX *_mem_save_name_0 = NULL;
320 1688 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
321 1688 : if (ndr_flags & NDR_SCALARS) {
322 1688 : NDR_CHECK(ndr_pull_align(ndr, 5));
323 1688 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
324 1688 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
325 1688 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
326 1688 : if (_ptr_name) {
327 1164 : NDR_PULL_ALLOC(ndr, r->name);
328 : } else {
329 524 : r->name = NULL;
330 : }
331 1688 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
332 : }
333 1688 : if (ndr_flags & NDR_BUFFERS) {
334 1688 : if (r->name) {
335 1164 : _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
336 1164 : NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
337 1164 : NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
338 1164 : NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
339 1164 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->name, &size_name_1));
340 1164 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->name, &length_name_1));
341 1164 : if (length_name_1 > size_name_1) {
342 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
343 : }
344 1164 : NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
345 1164 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
346 : }
347 1688 : if (r->name) {
348 1164 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->name, r->size / 2));
349 : }
350 1688 : if (r->name) {
351 1164 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->name, r->length / 2));
352 : }
353 : }
354 1688 : return NDR_ERR_SUCCESS;
355 : }
356 :
357 28 : _PUBLIC_ void ndr_print_winreg_StringBuf(struct ndr_print *ndr, const char *name, const struct winreg_StringBuf *r)
358 : {
359 28 : ndr_print_struct(ndr, name, "winreg_StringBuf");
360 28 : if (r == NULL) { ndr_print_null(ndr); return; }
361 28 : ndr->depth++;
362 28 : ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term_null(r->name) * 2:r->length);
363 28 : ndr_print_uint16(ndr, "size", r->size);
364 28 : ndr_print_ptr(ndr, "name", r->name);
365 28 : ndr->depth++;
366 28 : if (r->name) {
367 20 : ndr_print_string(ndr, "name", r->name);
368 : }
369 28 : ndr->depth--;
370 28 : ndr->depth--;
371 : }
372 :
373 1032 : static enum ndr_err_code ndr_push_winreg_ValNameBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_ValNameBuf *r)
374 : {
375 1032 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
376 1032 : if (ndr_flags & NDR_SCALARS) {
377 1032 : NDR_CHECK(ndr_push_align(ndr, 5));
378 1032 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));
379 1032 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
380 1032 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
381 1032 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
382 : }
383 1032 : if (ndr_flags & NDR_BUFFERS) {
384 1032 : if (r->name) {
385 1032 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
386 1032 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
387 1032 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2 / 2));
388 1032 : NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, strlen_m_term(r->name) * 2 / 2, sizeof(uint16_t), CH_UTF16));
389 : }
390 : }
391 1032 : return NDR_ERR_SUCCESS;
392 : }
393 :
394 1024 : static enum ndr_err_code ndr_pull_winreg_ValNameBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_ValNameBuf *r)
395 : {
396 : uint32_t _ptr_name;
397 1024 : uint32_t size_name_1 = 0;
398 1024 : uint32_t length_name_1 = 0;
399 1024 : TALLOC_CTX *_mem_save_name_0 = NULL;
400 1024 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
401 1024 : if (ndr_flags & NDR_SCALARS) {
402 1024 : NDR_CHECK(ndr_pull_align(ndr, 5));
403 1024 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
404 1024 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
405 1024 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
406 1024 : if (_ptr_name) {
407 1024 : NDR_PULL_ALLOC(ndr, r->name);
408 : } else {
409 0 : r->name = NULL;
410 : }
411 1024 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
412 : }
413 1024 : if (ndr_flags & NDR_BUFFERS) {
414 1024 : if (r->name) {
415 1024 : _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
416 1024 : NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
417 1024 : NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
418 1024 : NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
419 1024 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->name, &size_name_1));
420 1024 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->name, &length_name_1));
421 1024 : if (length_name_1 > size_name_1) {
422 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
423 : }
424 1024 : NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
425 1024 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
426 : }
427 1024 : if (r->name) {
428 1024 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->name, r->size / 2));
429 : }
430 1024 : if (r->name) {
431 1024 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->name, r->length / 2));
432 : }
433 : }
434 1024 : return NDR_ERR_SUCCESS;
435 : }
436 :
437 16 : _PUBLIC_ void ndr_print_winreg_ValNameBuf(struct ndr_print *ndr, const char *name, const struct winreg_ValNameBuf *r)
438 : {
439 16 : ndr_print_struct(ndr, name, "winreg_ValNameBuf");
440 16 : if (r == NULL) { ndr_print_null(ndr); return; }
441 16 : ndr->depth++;
442 16 : ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name) * 2:r->length);
443 16 : ndr_print_uint16(ndr, "size", r->size);
444 16 : ndr_print_ptr(ndr, "name", r->name);
445 16 : ndr->depth++;
446 16 : if (r->name) {
447 16 : ndr_print_string(ndr, "name", r->name);
448 : }
449 16 : ndr->depth--;
450 16 : ndr->depth--;
451 : }
452 :
453 256 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_NotifyChangeType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
454 : {
455 256 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
456 256 : return NDR_ERR_SUCCESS;
457 : }
458 :
459 256 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_NotifyChangeType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
460 : {
461 : uint32_t v;
462 256 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
463 256 : *r = v;
464 256 : return NDR_ERR_SUCCESS;
465 : }
466 :
467 0 : _PUBLIC_ void ndr_print_winreg_NotifyChangeType(struct ndr_print *ndr, const char *name, uint32_t r)
468 : {
469 0 : ndr_print_uint32(ndr, name, r);
470 0 : ndr->depth++;
471 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_NOTIFY_CHANGE_NAME", REG_NOTIFY_CHANGE_NAME, r);
472 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_NOTIFY_CHANGE_ATTRIBUTES", REG_NOTIFY_CHANGE_ATTRIBUTES, r);
473 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_NOTIFY_CHANGE_LAST_SET", REG_NOTIFY_CHANGE_LAST_SET, r);
474 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_NOTIFY_CHANGE_SECURITY", REG_NOTIFY_CHANGE_SECURITY, r);
475 0 : ndr->depth--;
476 0 : }
477 :
478 0 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_RestoreKeyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
479 : {
480 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
481 0 : return NDR_ERR_SUCCESS;
482 : }
483 :
484 0 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_RestoreKeyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
485 : {
486 : uint32_t v;
487 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
488 0 : *r = v;
489 0 : return NDR_ERR_SUCCESS;
490 : }
491 :
492 0 : _PUBLIC_ void ndr_print_winreg_RestoreKeyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
493 : {
494 0 : ndr_print_uint32(ndr, name, r);
495 0 : ndr->depth++;
496 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_WHOLE_HIVE_VOLATILE", REG_WHOLE_HIVE_VOLATILE, r);
497 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_REFRESH_HIVE", REG_REFRESH_HIVE, r);
498 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_NO_LAZY_FLUSH", REG_NO_LAZY_FLUSH, r);
499 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_FORCE_RESTORE", REG_FORCE_RESTORE, r);
500 0 : ndr->depth--;
501 0 : }
502 :
503 0 : static enum ndr_err_code ndr_push_KeySecurityAttribute(struct ndr_push *ndr, int ndr_flags, const struct KeySecurityAttribute *r)
504 : {
505 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
506 0 : if (ndr_flags & NDR_SCALARS) {
507 0 : NDR_CHECK(ndr_push_align(ndr, 5));
508 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data_size));
509 0 : NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));
510 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));
511 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
512 : }
513 0 : if (ndr_flags & NDR_BUFFERS) {
514 0 : NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));
515 : }
516 0 : return NDR_ERR_SUCCESS;
517 : }
518 :
519 0 : static enum ndr_err_code ndr_pull_KeySecurityAttribute(struct ndr_pull *ndr, int ndr_flags, struct KeySecurityAttribute *r)
520 : {
521 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
522 0 : if (ndr_flags & NDR_SCALARS) {
523 0 : NDR_CHECK(ndr_pull_align(ndr, 5));
524 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_size));
525 0 : NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));
526 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));
527 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
528 : }
529 0 : if (ndr_flags & NDR_BUFFERS) {
530 0 : NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));
531 : }
532 0 : return NDR_ERR_SUCCESS;
533 : }
534 :
535 0 : _PUBLIC_ void ndr_print_KeySecurityAttribute(struct ndr_print *ndr, const char *name, const struct KeySecurityAttribute *r)
536 : {
537 0 : ndr_print_struct(ndr, name, "KeySecurityAttribute");
538 0 : if (r == NULL) { ndr_print_null(ndr); return; }
539 0 : ndr->depth++;
540 0 : ndr_print_uint32(ndr, "data_size", r->data_size);
541 0 : ndr_print_KeySecurityData(ndr, "sec_data", &r->sec_data);
542 0 : ndr_print_uint8(ndr, "inherit", r->inherit);
543 0 : ndr->depth--;
544 : }
545 :
546 0 : static enum ndr_err_code ndr_push_QueryMultipleValue(struct ndr_push *ndr, int ndr_flags, const struct QueryMultipleValue *r)
547 : {
548 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
549 0 : if (ndr_flags & NDR_SCALARS) {
550 0 : NDR_CHECK(ndr_push_align(ndr, 5));
551 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->ve_valuename));
552 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ve_valuelen));
553 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ve_valueptr));
554 0 : NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->ve_type));
555 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 5));
556 : }
557 0 : if (ndr_flags & NDR_BUFFERS) {
558 0 : if (r->ve_valuename) {
559 0 : NDR_CHECK(ndr_push_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->ve_valuename));
560 : }
561 : }
562 0 : return NDR_ERR_SUCCESS;
563 : }
564 :
565 0 : static enum ndr_err_code ndr_pull_QueryMultipleValue(struct ndr_pull *ndr, int ndr_flags, struct QueryMultipleValue *r)
566 : {
567 : uint32_t _ptr_ve_valuename;
568 0 : TALLOC_CTX *_mem_save_ve_valuename_0 = NULL;
569 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
570 0 : if (ndr_flags & NDR_SCALARS) {
571 0 : NDR_CHECK(ndr_pull_align(ndr, 5));
572 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ve_valuename));
573 0 : if (_ptr_ve_valuename) {
574 0 : NDR_PULL_ALLOC(ndr, r->ve_valuename);
575 : } else {
576 0 : r->ve_valuename = NULL;
577 : }
578 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ve_valuelen));
579 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ve_valueptr));
580 0 : NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->ve_type));
581 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
582 : }
583 0 : if (ndr_flags & NDR_BUFFERS) {
584 0 : if (r->ve_valuename) {
585 0 : _mem_save_ve_valuename_0 = NDR_PULL_GET_MEM_CTX(ndr);
586 0 : NDR_PULL_SET_MEM_CTX(ndr, r->ve_valuename, 0);
587 0 : NDR_CHECK(ndr_pull_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->ve_valuename));
588 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ve_valuename_0, 0);
589 : }
590 : }
591 0 : return NDR_ERR_SUCCESS;
592 : }
593 :
594 0 : _PUBLIC_ void ndr_print_QueryMultipleValue(struct ndr_print *ndr, const char *name, const struct QueryMultipleValue *r)
595 : {
596 0 : ndr_print_struct(ndr, name, "QueryMultipleValue");
597 0 : if (r == NULL) { ndr_print_null(ndr); return; }
598 0 : ndr->depth++;
599 0 : ndr_print_ptr(ndr, "ve_valuename", r->ve_valuename);
600 0 : ndr->depth++;
601 0 : if (r->ve_valuename) {
602 0 : ndr_print_winreg_ValNameBuf(ndr, "ve_valuename", r->ve_valuename);
603 : }
604 0 : ndr->depth--;
605 0 : ndr_print_uint32(ndr, "ve_valuelen", r->ve_valuelen);
606 0 : ndr_print_uint32(ndr, "ve_valueptr", r->ve_valueptr);
607 0 : ndr_print_winreg_Type(ndr, "ve_type", r->ve_type);
608 0 : ndr->depth--;
609 : }
610 :
611 169 : static enum ndr_err_code ndr_push_winreg_OpenHKCR(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCR *r)
612 : {
613 169 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
614 169 : if (flags & NDR_IN) {
615 84 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
616 84 : if (r->in.system_name) {
617 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
618 : }
619 84 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
620 : }
621 169 : if (flags & NDR_OUT) {
622 85 : if (r->out.handle == NULL) {
623 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
624 : }
625 85 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
626 85 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
627 : }
628 169 : return NDR_ERR_SUCCESS;
629 : }
630 :
631 168 : static enum ndr_err_code ndr_pull_winreg_OpenHKCR(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCR *r)
632 : {
633 : uint32_t _ptr_system_name;
634 168 : TALLOC_CTX *_mem_save_system_name_0 = NULL;
635 168 : TALLOC_CTX *_mem_save_handle_0 = NULL;
636 168 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
637 168 : if (flags & NDR_IN) {
638 84 : NDR_ZERO_STRUCT(r->out);
639 :
640 84 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
641 84 : if (_ptr_system_name) {
642 0 : NDR_PULL_ALLOC(ndr, r->in.system_name);
643 : } else {
644 84 : r->in.system_name = NULL;
645 : }
646 84 : if (r->in.system_name) {
647 0 : _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
648 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
649 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
650 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
651 : }
652 84 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
653 84 : NDR_PULL_ALLOC(ndr, r->out.handle);
654 84 : NDR_ZERO_STRUCTP(r->out.handle);
655 : }
656 168 : if (flags & NDR_OUT) {
657 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
658 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
659 84 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
660 1 : NDR_PULL_ALLOC(ndr, r->out.handle);
661 : }
662 84 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
663 84 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
664 84 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
665 84 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
666 84 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
667 : }
668 168 : return NDR_ERR_SUCCESS;
669 : }
670 :
671 2 : _PUBLIC_ void ndr_print_winreg_OpenHKCR(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCR *r)
672 : {
673 2 : ndr_print_struct(ndr, name, "winreg_OpenHKCR");
674 2 : if (r == NULL) { ndr_print_null(ndr); return; }
675 2 : ndr->depth++;
676 2 : if (flags & NDR_SET_VALUES) {
677 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
678 : }
679 2 : if (flags & NDR_IN) {
680 0 : ndr_print_struct(ndr, "in", "winreg_OpenHKCR");
681 0 : ndr->depth++;
682 0 : ndr_print_ptr(ndr, "system_name", r->in.system_name);
683 0 : ndr->depth++;
684 0 : if (r->in.system_name) {
685 0 : ndr_print_uint16(ndr, "system_name", *r->in.system_name);
686 : }
687 0 : ndr->depth--;
688 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
689 0 : ndr->depth--;
690 : }
691 2 : if (flags & NDR_OUT) {
692 2 : ndr_print_struct(ndr, "out", "winreg_OpenHKCR");
693 2 : ndr->depth++;
694 2 : ndr_print_ptr(ndr, "handle", r->out.handle);
695 2 : ndr->depth++;
696 2 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
697 2 : ndr->depth--;
698 2 : ndr_print_WERROR(ndr, "result", r->out.result);
699 2 : ndr->depth--;
700 : }
701 2 : ndr->depth--;
702 : }
703 :
704 169 : static enum ndr_err_code ndr_push_winreg_OpenHKCU(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCU *r)
705 : {
706 169 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
707 169 : if (flags & NDR_IN) {
708 84 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
709 84 : if (r->in.system_name) {
710 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
711 : }
712 84 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
713 : }
714 169 : if (flags & NDR_OUT) {
715 85 : if (r->out.handle == NULL) {
716 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
717 : }
718 85 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
719 85 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
720 : }
721 169 : return NDR_ERR_SUCCESS;
722 : }
723 :
724 168 : static enum ndr_err_code ndr_pull_winreg_OpenHKCU(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCU *r)
725 : {
726 : uint32_t _ptr_system_name;
727 168 : TALLOC_CTX *_mem_save_system_name_0 = NULL;
728 168 : TALLOC_CTX *_mem_save_handle_0 = NULL;
729 168 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
730 168 : if (flags & NDR_IN) {
731 84 : NDR_ZERO_STRUCT(r->out);
732 :
733 84 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
734 84 : if (_ptr_system_name) {
735 0 : NDR_PULL_ALLOC(ndr, r->in.system_name);
736 : } else {
737 84 : r->in.system_name = NULL;
738 : }
739 84 : if (r->in.system_name) {
740 0 : _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
741 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
742 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
743 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
744 : }
745 84 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
746 84 : NDR_PULL_ALLOC(ndr, r->out.handle);
747 84 : NDR_ZERO_STRUCTP(r->out.handle);
748 : }
749 168 : if (flags & NDR_OUT) {
750 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
751 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
752 84 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
753 1 : NDR_PULL_ALLOC(ndr, r->out.handle);
754 : }
755 84 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
756 84 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
757 84 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
758 84 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
759 84 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
760 : }
761 168 : return NDR_ERR_SUCCESS;
762 : }
763 :
764 2 : _PUBLIC_ void ndr_print_winreg_OpenHKCU(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCU *r)
765 : {
766 2 : ndr_print_struct(ndr, name, "winreg_OpenHKCU");
767 2 : if (r == NULL) { ndr_print_null(ndr); return; }
768 2 : ndr->depth++;
769 2 : if (flags & NDR_SET_VALUES) {
770 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
771 : }
772 2 : if (flags & NDR_IN) {
773 0 : ndr_print_struct(ndr, "in", "winreg_OpenHKCU");
774 0 : ndr->depth++;
775 0 : ndr_print_ptr(ndr, "system_name", r->in.system_name);
776 0 : ndr->depth++;
777 0 : if (r->in.system_name) {
778 0 : ndr_print_uint16(ndr, "system_name", *r->in.system_name);
779 : }
780 0 : ndr->depth--;
781 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
782 0 : ndr->depth--;
783 : }
784 2 : if (flags & NDR_OUT) {
785 2 : ndr_print_struct(ndr, "out", "winreg_OpenHKCU");
786 2 : ndr->depth++;
787 2 : ndr_print_ptr(ndr, "handle", r->out.handle);
788 2 : ndr->depth++;
789 2 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
790 2 : ndr->depth--;
791 2 : ndr_print_WERROR(ndr, "result", r->out.result);
792 2 : ndr->depth--;
793 : }
794 2 : ndr->depth--;
795 : }
796 :
797 343 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_OpenHKLM(struct ndr_push *ndr, int flags, const struct winreg_OpenHKLM *r)
798 : {
799 343 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
800 343 : if (flags & NDR_IN) {
801 171 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
802 171 : if (r->in.system_name) {
803 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
804 : }
805 171 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
806 : }
807 343 : if (flags & NDR_OUT) {
808 172 : if (r->out.handle == NULL) {
809 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
810 : }
811 172 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
812 172 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
813 : }
814 343 : return NDR_ERR_SUCCESS;
815 : }
816 :
817 342 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_OpenHKLM(struct ndr_pull *ndr, int flags, struct winreg_OpenHKLM *r)
818 : {
819 : uint32_t _ptr_system_name;
820 342 : TALLOC_CTX *_mem_save_system_name_0 = NULL;
821 342 : TALLOC_CTX *_mem_save_handle_0 = NULL;
822 342 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
823 342 : if (flags & NDR_IN) {
824 171 : NDR_ZERO_STRUCT(r->out);
825 :
826 171 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
827 171 : if (_ptr_system_name) {
828 0 : NDR_PULL_ALLOC(ndr, r->in.system_name);
829 : } else {
830 171 : r->in.system_name = NULL;
831 : }
832 171 : if (r->in.system_name) {
833 0 : _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
834 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
835 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
836 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
837 : }
838 171 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
839 171 : NDR_PULL_ALLOC(ndr, r->out.handle);
840 171 : NDR_ZERO_STRUCTP(r->out.handle);
841 : }
842 342 : if (flags & NDR_OUT) {
843 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
844 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
845 171 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
846 88 : NDR_PULL_ALLOC(ndr, r->out.handle);
847 : }
848 171 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
849 171 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
850 171 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
851 171 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
852 171 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
853 : }
854 342 : return NDR_ERR_SUCCESS;
855 : }
856 :
857 2 : _PUBLIC_ void ndr_print_winreg_OpenHKLM(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKLM *r)
858 : {
859 2 : ndr_print_struct(ndr, name, "winreg_OpenHKLM");
860 2 : if (r == NULL) { ndr_print_null(ndr); return; }
861 2 : ndr->depth++;
862 2 : if (flags & NDR_SET_VALUES) {
863 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
864 : }
865 2 : if (flags & NDR_IN) {
866 0 : ndr_print_struct(ndr, "in", "winreg_OpenHKLM");
867 0 : ndr->depth++;
868 0 : ndr_print_ptr(ndr, "system_name", r->in.system_name);
869 0 : ndr->depth++;
870 0 : if (r->in.system_name) {
871 0 : ndr_print_uint16(ndr, "system_name", *r->in.system_name);
872 : }
873 0 : ndr->depth--;
874 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
875 0 : ndr->depth--;
876 : }
877 2 : if (flags & NDR_OUT) {
878 2 : ndr_print_struct(ndr, "out", "winreg_OpenHKLM");
879 2 : ndr->depth++;
880 2 : ndr_print_ptr(ndr, "handle", r->out.handle);
881 2 : ndr->depth++;
882 2 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
883 2 : ndr->depth--;
884 2 : ndr_print_WERROR(ndr, "result", r->out.result);
885 2 : ndr->depth--;
886 : }
887 2 : ndr->depth--;
888 : }
889 :
890 0 : static enum ndr_err_code ndr_push_winreg_OpenHKPD(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPD *r)
891 : {
892 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
893 0 : if (flags & NDR_IN) {
894 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
895 0 : if (r->in.system_name) {
896 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
897 : }
898 0 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
899 : }
900 0 : if (flags & NDR_OUT) {
901 0 : if (r->out.handle == NULL) {
902 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
903 : }
904 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
905 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
906 : }
907 0 : return NDR_ERR_SUCCESS;
908 : }
909 :
910 0 : static enum ndr_err_code ndr_pull_winreg_OpenHKPD(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPD *r)
911 : {
912 : uint32_t _ptr_system_name;
913 0 : TALLOC_CTX *_mem_save_system_name_0 = NULL;
914 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
915 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
916 0 : if (flags & NDR_IN) {
917 0 : NDR_ZERO_STRUCT(r->out);
918 :
919 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
920 0 : if (_ptr_system_name) {
921 0 : NDR_PULL_ALLOC(ndr, r->in.system_name);
922 : } else {
923 0 : r->in.system_name = NULL;
924 : }
925 0 : if (r->in.system_name) {
926 0 : _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
927 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
928 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
929 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
930 : }
931 0 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
932 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
933 0 : NDR_ZERO_STRUCTP(r->out.handle);
934 : }
935 0 : if (flags & NDR_OUT) {
936 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
937 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
938 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
939 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
940 : }
941 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
942 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
943 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
944 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
945 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
946 : }
947 0 : return NDR_ERR_SUCCESS;
948 : }
949 :
950 0 : _PUBLIC_ void ndr_print_winreg_OpenHKPD(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPD *r)
951 : {
952 0 : ndr_print_struct(ndr, name, "winreg_OpenHKPD");
953 0 : if (r == NULL) { ndr_print_null(ndr); return; }
954 0 : ndr->depth++;
955 0 : if (flags & NDR_SET_VALUES) {
956 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
957 : }
958 0 : if (flags & NDR_IN) {
959 0 : ndr_print_struct(ndr, "in", "winreg_OpenHKPD");
960 0 : ndr->depth++;
961 0 : ndr_print_ptr(ndr, "system_name", r->in.system_name);
962 0 : ndr->depth++;
963 0 : if (r->in.system_name) {
964 0 : ndr_print_uint16(ndr, "system_name", *r->in.system_name);
965 : }
966 0 : ndr->depth--;
967 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
968 0 : ndr->depth--;
969 : }
970 0 : if (flags & NDR_OUT) {
971 0 : ndr_print_struct(ndr, "out", "winreg_OpenHKPD");
972 0 : ndr->depth++;
973 0 : ndr_print_ptr(ndr, "handle", r->out.handle);
974 0 : ndr->depth++;
975 0 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
976 0 : ndr->depth--;
977 0 : ndr_print_WERROR(ndr, "result", r->out.result);
978 0 : ndr->depth--;
979 : }
980 0 : ndr->depth--;
981 : }
982 :
983 169 : static enum ndr_err_code ndr_push_winreg_OpenHKU(struct ndr_push *ndr, int flags, const struct winreg_OpenHKU *r)
984 : {
985 169 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
986 169 : if (flags & NDR_IN) {
987 84 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
988 84 : if (r->in.system_name) {
989 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
990 : }
991 84 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
992 : }
993 169 : if (flags & NDR_OUT) {
994 85 : if (r->out.handle == NULL) {
995 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
996 : }
997 85 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
998 85 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
999 : }
1000 169 : return NDR_ERR_SUCCESS;
1001 : }
1002 :
1003 168 : static enum ndr_err_code ndr_pull_winreg_OpenHKU(struct ndr_pull *ndr, int flags, struct winreg_OpenHKU *r)
1004 : {
1005 : uint32_t _ptr_system_name;
1006 168 : TALLOC_CTX *_mem_save_system_name_0 = NULL;
1007 168 : TALLOC_CTX *_mem_save_handle_0 = NULL;
1008 168 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1009 168 : if (flags & NDR_IN) {
1010 84 : NDR_ZERO_STRUCT(r->out);
1011 :
1012 84 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
1013 84 : if (_ptr_system_name) {
1014 0 : NDR_PULL_ALLOC(ndr, r->in.system_name);
1015 : } else {
1016 84 : r->in.system_name = NULL;
1017 : }
1018 84 : if (r->in.system_name) {
1019 0 : _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1020 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
1021 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
1022 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
1023 : }
1024 84 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
1025 84 : NDR_PULL_ALLOC(ndr, r->out.handle);
1026 84 : NDR_ZERO_STRUCTP(r->out.handle);
1027 : }
1028 168 : if (flags & NDR_OUT) {
1029 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1030 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
1031 84 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1032 1 : NDR_PULL_ALLOC(ndr, r->out.handle);
1033 : }
1034 84 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1035 84 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1036 84 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1037 84 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1038 84 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1039 : }
1040 168 : return NDR_ERR_SUCCESS;
1041 : }
1042 :
1043 2 : _PUBLIC_ void ndr_print_winreg_OpenHKU(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKU *r)
1044 : {
1045 2 : ndr_print_struct(ndr, name, "winreg_OpenHKU");
1046 2 : if (r == NULL) { ndr_print_null(ndr); return; }
1047 2 : ndr->depth++;
1048 2 : if (flags & NDR_SET_VALUES) {
1049 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1050 : }
1051 2 : if (flags & NDR_IN) {
1052 0 : ndr_print_struct(ndr, "in", "winreg_OpenHKU");
1053 0 : ndr->depth++;
1054 0 : ndr_print_ptr(ndr, "system_name", r->in.system_name);
1055 0 : ndr->depth++;
1056 0 : if (r->in.system_name) {
1057 0 : ndr_print_uint16(ndr, "system_name", *r->in.system_name);
1058 : }
1059 0 : ndr->depth--;
1060 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
1061 0 : ndr->depth--;
1062 : }
1063 2 : if (flags & NDR_OUT) {
1064 2 : ndr_print_struct(ndr, "out", "winreg_OpenHKU");
1065 2 : ndr->depth++;
1066 2 : ndr_print_ptr(ndr, "handle", r->out.handle);
1067 2 : ndr->depth++;
1068 2 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
1069 2 : ndr->depth--;
1070 2 : ndr_print_WERROR(ndr, "result", r->out.result);
1071 2 : ndr->depth--;
1072 : }
1073 2 : ndr->depth--;
1074 : }
1075 :
1076 2095 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_CloseKey(struct ndr_push *ndr, int flags, const struct winreg_CloseKey *r)
1077 : {
1078 2095 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1079 2095 : if (flags & NDR_IN) {
1080 1043 : if (r->in.handle == NULL) {
1081 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1082 : }
1083 1043 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1084 : }
1085 2095 : if (flags & NDR_OUT) {
1086 1052 : if (r->out.handle == NULL) {
1087 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1088 : }
1089 1052 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1090 1052 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1091 : }
1092 2095 : return NDR_ERR_SUCCESS;
1093 : }
1094 :
1095 2086 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_CloseKey(struct ndr_pull *ndr, int flags, struct winreg_CloseKey *r)
1096 : {
1097 2086 : TALLOC_CTX *_mem_save_handle_0 = NULL;
1098 2086 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1099 2086 : if (flags & NDR_IN) {
1100 1043 : NDR_ZERO_STRUCT(r->out);
1101 :
1102 1043 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1103 1043 : NDR_PULL_ALLOC(ndr, r->in.handle);
1104 : }
1105 1043 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1106 1043 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1107 1043 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1108 1043 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1109 1043 : NDR_PULL_ALLOC(ndr, r->out.handle);
1110 1043 : *r->out.handle = *r->in.handle;
1111 : }
1112 2086 : if (flags & NDR_OUT) {
1113 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1114 : if (r->in.handle == NULL) {
1115 : NDR_PULL_ALLOC(ndr, r->in.handle);
1116 : NDR_ZERO_STRUCTP(r->in.handle);
1117 : }
1118 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
1119 1043 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1120 376 : NDR_PULL_ALLOC(ndr, r->out.handle);
1121 : }
1122 1043 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1123 1043 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1124 1043 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1125 1043 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1126 1043 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1127 : }
1128 2086 : return NDR_ERR_SUCCESS;
1129 : }
1130 :
1131 18 : _PUBLIC_ void ndr_print_winreg_CloseKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_CloseKey *r)
1132 : {
1133 18 : ndr_print_struct(ndr, name, "winreg_CloseKey");
1134 18 : if (r == NULL) { ndr_print_null(ndr); return; }
1135 18 : ndr->depth++;
1136 18 : if (flags & NDR_SET_VALUES) {
1137 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1138 : }
1139 18 : if (flags & NDR_IN) {
1140 0 : ndr_print_struct(ndr, "in", "winreg_CloseKey");
1141 0 : ndr->depth++;
1142 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
1143 0 : ndr->depth++;
1144 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
1145 0 : ndr->depth--;
1146 0 : ndr->depth--;
1147 : }
1148 18 : if (flags & NDR_OUT) {
1149 18 : ndr_print_struct(ndr, "out", "winreg_CloseKey");
1150 18 : ndr->depth++;
1151 18 : ndr_print_ptr(ndr, "handle", r->out.handle);
1152 18 : ndr->depth++;
1153 18 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
1154 18 : ndr->depth--;
1155 18 : ndr_print_WERROR(ndr, "result", r->out.result);
1156 18 : ndr->depth--;
1157 : }
1158 18 : ndr->depth--;
1159 : }
1160 :
1161 4109 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_CreateKey(struct ndr_push *ndr, int flags, const struct winreg_CreateKey *r)
1162 : {
1163 4109 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1164 4109 : if (flags & NDR_IN) {
1165 2044 : if (r->in.handle == NULL) {
1166 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1167 : }
1168 2044 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1169 2044 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
1170 2044 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyclass));
1171 2044 : NDR_CHECK(ndr_push_winreg_KeyOptions(ndr, NDR_SCALARS, r->in.options));
1172 2044 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
1173 2044 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.secdesc));
1174 2044 : if (r->in.secdesc) {
1175 0 : NDR_CHECK(ndr_push_winreg_SecBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
1176 : }
1177 2044 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.action_taken));
1178 2044 : if (r->in.action_taken) {
1179 2044 : NDR_CHECK(ndr_push_winreg_CreateAction(ndr, NDR_SCALARS, *r->in.action_taken));
1180 : }
1181 : }
1182 4109 : if (flags & NDR_OUT) {
1183 2065 : if (r->out.new_handle == NULL) {
1184 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1185 : }
1186 2065 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.new_handle));
1187 2065 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.action_taken));
1188 2065 : if (r->out.action_taken) {
1189 2065 : NDR_CHECK(ndr_push_winreg_CreateAction(ndr, NDR_SCALARS, *r->out.action_taken));
1190 : }
1191 2065 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1192 : }
1193 4109 : return NDR_ERR_SUCCESS;
1194 : }
1195 :
1196 4088 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_CreateKey(struct ndr_pull *ndr, int flags, struct winreg_CreateKey *r)
1197 : {
1198 : uint32_t _ptr_secdesc;
1199 : uint32_t _ptr_action_taken;
1200 4088 : TALLOC_CTX *_mem_save_handle_0 = NULL;
1201 4088 : TALLOC_CTX *_mem_save_secdesc_0 = NULL;
1202 4088 : TALLOC_CTX *_mem_save_new_handle_0 = NULL;
1203 4088 : TALLOC_CTX *_mem_save_action_taken_0 = NULL;
1204 4088 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1205 4088 : if (flags & NDR_IN) {
1206 2044 : NDR_ZERO_STRUCT(r->out);
1207 :
1208 2044 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1209 2044 : NDR_PULL_ALLOC(ndr, r->in.handle);
1210 : }
1211 2044 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1212 2044 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1213 2044 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1214 2044 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1215 2044 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
1216 2044 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyclass));
1217 2044 : NDR_CHECK(ndr_pull_winreg_KeyOptions(ndr, NDR_SCALARS, &r->in.options));
1218 2044 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
1219 2044 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1220 2044 : if (_ptr_secdesc) {
1221 0 : NDR_PULL_ALLOC(ndr, r->in.secdesc);
1222 : } else {
1223 2044 : r->in.secdesc = NULL;
1224 : }
1225 2044 : if (r->in.secdesc) {
1226 0 : _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1227 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc, 0);
1228 0 : NDR_CHECK(ndr_pull_winreg_SecBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
1229 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1230 : }
1231 2044 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_action_taken));
1232 2044 : if (_ptr_action_taken) {
1233 2044 : NDR_PULL_ALLOC(ndr, r->in.action_taken);
1234 : } else {
1235 0 : r->in.action_taken = NULL;
1236 : }
1237 2044 : if (r->in.action_taken) {
1238 2044 : _mem_save_action_taken_0 = NDR_PULL_GET_MEM_CTX(ndr);
1239 2044 : NDR_PULL_SET_MEM_CTX(ndr, r->in.action_taken, 0);
1240 2044 : NDR_CHECK(ndr_pull_winreg_CreateAction(ndr, NDR_SCALARS, r->in.action_taken));
1241 2044 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_action_taken_0, 0);
1242 : }
1243 2044 : NDR_PULL_ALLOC(ndr, r->out.new_handle);
1244 2044 : NDR_ZERO_STRUCTP(r->out.new_handle);
1245 : }
1246 4088 : if (flags & NDR_OUT) {
1247 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1248 : if (r->in.handle == NULL) {
1249 : NDR_PULL_ALLOC(ndr, r->in.handle);
1250 : NDR_ZERO_STRUCTP(r->in.handle);
1251 : }
1252 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
1253 2044 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1254 301 : NDR_PULL_ALLOC(ndr, r->out.new_handle);
1255 : }
1256 2044 : _mem_save_new_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1257 2044 : NDR_PULL_SET_MEM_CTX(ndr, r->out.new_handle, LIBNDR_FLAG_REF_ALLOC);
1258 2044 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.new_handle));
1259 2044 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_handle_0, LIBNDR_FLAG_REF_ALLOC);
1260 2044 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_action_taken));
1261 2044 : if (_ptr_action_taken) {
1262 2044 : NDR_PULL_ALLOC(ndr, r->out.action_taken);
1263 : } else {
1264 0 : r->out.action_taken = NULL;
1265 : }
1266 2044 : if (r->out.action_taken) {
1267 2044 : _mem_save_action_taken_0 = NDR_PULL_GET_MEM_CTX(ndr);
1268 2044 : NDR_PULL_SET_MEM_CTX(ndr, r->out.action_taken, 0);
1269 2044 : NDR_CHECK(ndr_pull_winreg_CreateAction(ndr, NDR_SCALARS, r->out.action_taken));
1270 2044 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_action_taken_0, 0);
1271 : }
1272 2044 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1273 : }
1274 4088 : return NDR_ERR_SUCCESS;
1275 : }
1276 :
1277 42 : _PUBLIC_ void ndr_print_winreg_CreateKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_CreateKey *r)
1278 : {
1279 42 : ndr_print_struct(ndr, name, "winreg_CreateKey");
1280 42 : if (r == NULL) { ndr_print_null(ndr); return; }
1281 42 : ndr->depth++;
1282 42 : if (flags & NDR_SET_VALUES) {
1283 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1284 : }
1285 42 : if (flags & NDR_IN) {
1286 0 : ndr_print_struct(ndr, "in", "winreg_CreateKey");
1287 0 : ndr->depth++;
1288 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
1289 0 : ndr->depth++;
1290 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
1291 0 : ndr->depth--;
1292 0 : ndr_print_winreg_String(ndr, "name", &r->in.name);
1293 0 : ndr_print_winreg_String(ndr, "keyclass", &r->in.keyclass);
1294 0 : ndr_print_winreg_KeyOptions(ndr, "options", r->in.options);
1295 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
1296 0 : ndr_print_ptr(ndr, "secdesc", r->in.secdesc);
1297 0 : ndr->depth++;
1298 0 : if (r->in.secdesc) {
1299 0 : ndr_print_winreg_SecBuf(ndr, "secdesc", r->in.secdesc);
1300 : }
1301 0 : ndr->depth--;
1302 0 : ndr_print_ptr(ndr, "action_taken", r->in.action_taken);
1303 0 : ndr->depth++;
1304 0 : if (r->in.action_taken) {
1305 0 : ndr_print_winreg_CreateAction(ndr, "action_taken", *r->in.action_taken);
1306 : }
1307 0 : ndr->depth--;
1308 0 : ndr->depth--;
1309 : }
1310 42 : if (flags & NDR_OUT) {
1311 42 : ndr_print_struct(ndr, "out", "winreg_CreateKey");
1312 42 : ndr->depth++;
1313 42 : ndr_print_ptr(ndr, "new_handle", r->out.new_handle);
1314 42 : ndr->depth++;
1315 42 : ndr_print_policy_handle(ndr, "new_handle", r->out.new_handle);
1316 42 : ndr->depth--;
1317 42 : ndr_print_ptr(ndr, "action_taken", r->out.action_taken);
1318 42 : ndr->depth++;
1319 42 : if (r->out.action_taken) {
1320 42 : ndr_print_winreg_CreateAction(ndr, "action_taken", *r->out.action_taken);
1321 : }
1322 42 : ndr->depth--;
1323 42 : ndr_print_WERROR(ndr, "result", r->out.result);
1324 42 : ndr->depth--;
1325 : }
1326 42 : ndr->depth--;
1327 : }
1328 :
1329 5408 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_DeleteKey(struct ndr_push *ndr, int flags, const struct winreg_DeleteKey *r)
1330 : {
1331 5408 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1332 5408 : if (flags & NDR_IN) {
1333 2688 : if (r->in.handle == NULL) {
1334 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1335 : }
1336 2688 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1337 2688 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));
1338 : }
1339 5408 : if (flags & NDR_OUT) {
1340 2720 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1341 : }
1342 5408 : return NDR_ERR_SUCCESS;
1343 : }
1344 :
1345 5376 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_DeleteKey(struct ndr_pull *ndr, int flags, struct winreg_DeleteKey *r)
1346 : {
1347 5376 : TALLOC_CTX *_mem_save_handle_0 = NULL;
1348 5376 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1349 5376 : if (flags & NDR_IN) {
1350 2688 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1351 2688 : NDR_PULL_ALLOC(ndr, r->in.handle);
1352 : }
1353 2688 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1354 2688 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1355 2688 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1356 2688 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1357 2688 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));
1358 : }
1359 5376 : if (flags & NDR_OUT) {
1360 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1361 : if (r->in.handle == NULL) {
1362 : NDR_PULL_ALLOC(ndr, r->in.handle);
1363 : NDR_ZERO_STRUCTP(r->in.handle);
1364 : }
1365 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
1366 2688 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1367 : }
1368 5376 : return NDR_ERR_SUCCESS;
1369 : }
1370 :
1371 64 : _PUBLIC_ void ndr_print_winreg_DeleteKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_DeleteKey *r)
1372 : {
1373 64 : ndr_print_struct(ndr, name, "winreg_DeleteKey");
1374 64 : if (r == NULL) { ndr_print_null(ndr); return; }
1375 64 : ndr->depth++;
1376 64 : if (flags & NDR_SET_VALUES) {
1377 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1378 : }
1379 64 : if (flags & NDR_IN) {
1380 0 : ndr_print_struct(ndr, "in", "winreg_DeleteKey");
1381 0 : ndr->depth++;
1382 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
1383 0 : ndr->depth++;
1384 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
1385 0 : ndr->depth--;
1386 0 : ndr_print_winreg_String(ndr, "key", &r->in.key);
1387 0 : ndr->depth--;
1388 : }
1389 64 : if (flags & NDR_OUT) {
1390 64 : ndr_print_struct(ndr, "out", "winreg_DeleteKey");
1391 64 : ndr->depth++;
1392 64 : ndr_print_WERROR(ndr, "result", r->out.result);
1393 64 : ndr->depth--;
1394 : }
1395 64 : ndr->depth--;
1396 : }
1397 :
1398 3042 : static enum ndr_err_code ndr_push_winreg_DeleteValue(struct ndr_push *ndr, int flags, const struct winreg_DeleteValue *r)
1399 : {
1400 3042 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1401 3042 : if (flags & NDR_IN) {
1402 1512 : if (r->in.handle == NULL) {
1403 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1404 : }
1405 1512 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1406 1512 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value));
1407 : }
1408 3042 : if (flags & NDR_OUT) {
1409 1530 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1410 : }
1411 3042 : return NDR_ERR_SUCCESS;
1412 : }
1413 :
1414 3024 : static enum ndr_err_code ndr_pull_winreg_DeleteValue(struct ndr_pull *ndr, int flags, struct winreg_DeleteValue *r)
1415 : {
1416 3024 : TALLOC_CTX *_mem_save_handle_0 = NULL;
1417 3024 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1418 3024 : if (flags & NDR_IN) {
1419 1512 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1420 1512 : NDR_PULL_ALLOC(ndr, r->in.handle);
1421 : }
1422 1512 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1423 1512 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1424 1512 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1425 1512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1426 1512 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value));
1427 : }
1428 3024 : if (flags & NDR_OUT) {
1429 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1430 : if (r->in.handle == NULL) {
1431 : NDR_PULL_ALLOC(ndr, r->in.handle);
1432 : NDR_ZERO_STRUCTP(r->in.handle);
1433 : }
1434 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
1435 1512 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1436 : }
1437 3024 : return NDR_ERR_SUCCESS;
1438 : }
1439 :
1440 36 : _PUBLIC_ void ndr_print_winreg_DeleteValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_DeleteValue *r)
1441 : {
1442 36 : ndr_print_struct(ndr, name, "winreg_DeleteValue");
1443 36 : if (r == NULL) { ndr_print_null(ndr); return; }
1444 36 : ndr->depth++;
1445 36 : if (flags & NDR_SET_VALUES) {
1446 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1447 : }
1448 36 : if (flags & NDR_IN) {
1449 0 : ndr_print_struct(ndr, "in", "winreg_DeleteValue");
1450 0 : ndr->depth++;
1451 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
1452 0 : ndr->depth++;
1453 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
1454 0 : ndr->depth--;
1455 0 : ndr_print_winreg_String(ndr, "value", &r->in.value);
1456 0 : ndr->depth--;
1457 : }
1458 36 : if (flags & NDR_OUT) {
1459 36 : ndr_print_struct(ndr, "out", "winreg_DeleteValue");
1460 36 : ndr->depth++;
1461 36 : ndr_print_WERROR(ndr, "result", r->out.result);
1462 36 : ndr->depth--;
1463 : }
1464 36 : ndr->depth--;
1465 : }
1466 :
1467 851 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_EnumKey(struct ndr_push *ndr, int flags, const struct winreg_EnumKey *r)
1468 : {
1469 851 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1470 851 : if (flags & NDR_IN) {
1471 422 : if (r->in.handle == NULL) {
1472 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1473 : }
1474 422 : if (r->in.name == NULL) {
1475 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1476 : }
1477 422 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1478 422 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
1479 422 : NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1480 422 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.keyclass));
1481 422 : if (r->in.keyclass) {
1482 422 : NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyclass));
1483 : }
1484 422 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.last_changed_time));
1485 422 : if (r->in.last_changed_time) {
1486 422 : NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->in.last_changed_time));
1487 : }
1488 : }
1489 851 : if (flags & NDR_OUT) {
1490 429 : if (r->out.name == NULL) {
1491 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1492 : }
1493 429 : NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1494 429 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.keyclass));
1495 429 : if (r->out.keyclass) {
1496 429 : NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.keyclass));
1497 : }
1498 429 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.last_changed_time));
1499 429 : if (r->out.last_changed_time) {
1500 429 : NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));
1501 : }
1502 429 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1503 : }
1504 851 : return NDR_ERR_SUCCESS;
1505 : }
1506 :
1507 844 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_EnumKey(struct ndr_pull *ndr, int flags, struct winreg_EnumKey *r)
1508 : {
1509 : uint32_t _ptr_keyclass;
1510 : uint32_t _ptr_last_changed_time;
1511 844 : TALLOC_CTX *_mem_save_handle_0 = NULL;
1512 844 : TALLOC_CTX *_mem_save_name_0 = NULL;
1513 844 : TALLOC_CTX *_mem_save_keyclass_0 = NULL;
1514 844 : TALLOC_CTX *_mem_save_last_changed_time_0 = NULL;
1515 844 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1516 844 : if (flags & NDR_IN) {
1517 422 : NDR_ZERO_STRUCT(r->out);
1518 :
1519 422 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1520 422 : NDR_PULL_ALLOC(ndr, r->in.handle);
1521 : }
1522 422 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1523 422 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1524 422 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1525 422 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1526 422 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
1527 422 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1528 422 : NDR_PULL_ALLOC(ndr, r->in.name);
1529 : }
1530 422 : _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1531 422 : NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
1532 422 : NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1533 422 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1534 422 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyclass));
1535 422 : if (_ptr_keyclass) {
1536 422 : NDR_PULL_ALLOC(ndr, r->in.keyclass);
1537 : } else {
1538 0 : r->in.keyclass = NULL;
1539 : }
1540 422 : if (r->in.keyclass) {
1541 422 : _mem_save_keyclass_0 = NDR_PULL_GET_MEM_CTX(ndr);
1542 422 : NDR_PULL_SET_MEM_CTX(ndr, r->in.keyclass, 0);
1543 422 : NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyclass));
1544 422 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyclass_0, 0);
1545 : }
1546 422 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_last_changed_time));
1547 422 : if (_ptr_last_changed_time) {
1548 422 : NDR_PULL_ALLOC(ndr, r->in.last_changed_time);
1549 : } else {
1550 0 : r->in.last_changed_time = NULL;
1551 : }
1552 422 : if (r->in.last_changed_time) {
1553 422 : _mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
1554 422 : NDR_PULL_SET_MEM_CTX(ndr, r->in.last_changed_time, 0);
1555 422 : NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->in.last_changed_time));
1556 422 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, 0);
1557 : }
1558 422 : NDR_PULL_ALLOC(ndr, r->out.name);
1559 422 : *r->out.name = *r->in.name;
1560 : }
1561 844 : if (flags & NDR_OUT) {
1562 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1563 : if (r->in.handle == NULL) {
1564 : NDR_PULL_ALLOC(ndr, r->in.handle);
1565 : NDR_ZERO_STRUCTP(r->in.handle);
1566 : }
1567 : if (r->in.name == NULL) {
1568 : NDR_PULL_ALLOC(ndr, r->in.name);
1569 : NDR_ZERO_STRUCTP(r->in.name);
1570 : }
1571 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
1572 422 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1573 161 : NDR_PULL_ALLOC(ndr, r->out.name);
1574 : }
1575 422 : _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1576 422 : NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
1577 422 : NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1578 422 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1579 422 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyclass));
1580 422 : if (_ptr_keyclass) {
1581 422 : NDR_PULL_ALLOC(ndr, r->out.keyclass);
1582 : } else {
1583 0 : r->out.keyclass = NULL;
1584 : }
1585 422 : if (r->out.keyclass) {
1586 422 : _mem_save_keyclass_0 = NDR_PULL_GET_MEM_CTX(ndr);
1587 422 : NDR_PULL_SET_MEM_CTX(ndr, r->out.keyclass, 0);
1588 422 : NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.keyclass));
1589 422 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyclass_0, 0);
1590 : }
1591 422 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_last_changed_time));
1592 422 : if (_ptr_last_changed_time) {
1593 422 : NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
1594 : } else {
1595 0 : r->out.last_changed_time = NULL;
1596 : }
1597 422 : if (r->out.last_changed_time) {
1598 422 : _mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
1599 422 : NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, 0);
1600 422 : NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));
1601 422 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, 0);
1602 : }
1603 422 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1604 : }
1605 844 : return NDR_ERR_SUCCESS;
1606 : }
1607 :
1608 14 : _PUBLIC_ void ndr_print_winreg_EnumKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_EnumKey *r)
1609 : {
1610 14 : ndr_print_struct(ndr, name, "winreg_EnumKey");
1611 14 : if (r == NULL) { ndr_print_null(ndr); return; }
1612 14 : ndr->depth++;
1613 14 : if (flags & NDR_SET_VALUES) {
1614 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1615 : }
1616 14 : if (flags & NDR_IN) {
1617 0 : ndr_print_struct(ndr, "in", "winreg_EnumKey");
1618 0 : ndr->depth++;
1619 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
1620 0 : ndr->depth++;
1621 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
1622 0 : ndr->depth--;
1623 0 : ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
1624 0 : ndr_print_ptr(ndr, "name", r->in.name);
1625 0 : ndr->depth++;
1626 0 : ndr_print_winreg_StringBuf(ndr, "name", r->in.name);
1627 0 : ndr->depth--;
1628 0 : ndr_print_ptr(ndr, "keyclass", r->in.keyclass);
1629 0 : ndr->depth++;
1630 0 : if (r->in.keyclass) {
1631 0 : ndr_print_winreg_StringBuf(ndr, "keyclass", r->in.keyclass);
1632 : }
1633 0 : ndr->depth--;
1634 0 : ndr_print_ptr(ndr, "last_changed_time", r->in.last_changed_time);
1635 0 : ndr->depth++;
1636 0 : if (r->in.last_changed_time) {
1637 0 : ndr_print_NTTIME(ndr, "last_changed_time", *r->in.last_changed_time);
1638 : }
1639 0 : ndr->depth--;
1640 0 : ndr->depth--;
1641 : }
1642 14 : if (flags & NDR_OUT) {
1643 14 : ndr_print_struct(ndr, "out", "winreg_EnumKey");
1644 14 : ndr->depth++;
1645 14 : ndr_print_ptr(ndr, "name", r->out.name);
1646 14 : ndr->depth++;
1647 14 : ndr_print_winreg_StringBuf(ndr, "name", r->out.name);
1648 14 : ndr->depth--;
1649 14 : ndr_print_ptr(ndr, "keyclass", r->out.keyclass);
1650 14 : ndr->depth++;
1651 14 : if (r->out.keyclass) {
1652 14 : ndr_print_winreg_StringBuf(ndr, "keyclass", r->out.keyclass);
1653 : }
1654 14 : ndr->depth--;
1655 14 : ndr_print_ptr(ndr, "last_changed_time", r->out.last_changed_time);
1656 14 : ndr->depth++;
1657 14 : if (r->out.last_changed_time) {
1658 14 : ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);
1659 : }
1660 14 : ndr->depth--;
1661 14 : ndr_print_WERROR(ndr, "result", r->out.result);
1662 14 : ndr->depth--;
1663 : }
1664 14 : ndr->depth--;
1665 : }
1666 :
1667 1032 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_EnumValue(struct ndr_push *ndr, int flags, const struct winreg_EnumValue *r)
1668 : {
1669 1032 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1670 1032 : if (flags & NDR_IN) {
1671 512 : if (r->in.handle == NULL) {
1672 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1673 : }
1674 512 : if (r->in.name == NULL) {
1675 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1676 : }
1677 512 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1678 512 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
1679 512 : NDR_CHECK(ndr_push_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1680 512 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.type));
1681 512 : if (r->in.type) {
1682 512 : NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->in.type));
1683 : }
1684 512 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.value));
1685 512 : if (r->in.value) {
1686 256 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.size?*r->in.size:0));
1687 256 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1688 256 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.length?*r->in.length:0));
1689 256 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.value, r->in.length?*r->in.length:0));
1690 : }
1691 512 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.size));
1692 512 : if (r->in.size) {
1693 512 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.size));
1694 : }
1695 512 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.length));
1696 512 : if (r->in.length) {
1697 512 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.length));
1698 : }
1699 : }
1700 1032 : if (flags & NDR_OUT) {
1701 520 : if (r->out.name == NULL) {
1702 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1703 : }
1704 520 : NDR_CHECK(ndr_push_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1705 520 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.type));
1706 520 : if (r->out.type) {
1707 520 : NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
1708 : }
1709 520 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.value));
1710 520 : if (r->out.value) {
1711 260 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->out.size?*r->out.size:0));
1712 260 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1713 260 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->out.length?*r->out.length:0));
1714 260 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.value, r->out.length?*r->out.length:0));
1715 : }
1716 520 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.size));
1717 520 : if (r->out.size) {
1718 520 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.size));
1719 : }
1720 520 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.length));
1721 520 : if (r->out.length) {
1722 520 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.length));
1723 : }
1724 520 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1725 : }
1726 1032 : return NDR_ERR_SUCCESS;
1727 : }
1728 :
1729 1024 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_EnumValue(struct ndr_pull *ndr, int flags, struct winreg_EnumValue *r)
1730 : {
1731 : uint32_t _ptr_type;
1732 : uint32_t _ptr_value;
1733 1024 : uint32_t size_value_1 = 0;
1734 1024 : uint32_t length_value_1 = 0;
1735 : uint32_t _ptr_size;
1736 : uint32_t _ptr_length;
1737 1024 : TALLOC_CTX *_mem_save_handle_0 = NULL;
1738 1024 : TALLOC_CTX *_mem_save_name_0 = NULL;
1739 1024 : TALLOC_CTX *_mem_save_type_0 = NULL;
1740 1024 : TALLOC_CTX *_mem_save_value_0 = NULL;
1741 1024 : TALLOC_CTX *_mem_save_size_0 = NULL;
1742 1024 : TALLOC_CTX *_mem_save_length_0 = NULL;
1743 1024 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1744 1024 : if (flags & NDR_IN) {
1745 512 : NDR_ZERO_STRUCT(r->out);
1746 :
1747 512 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1748 512 : NDR_PULL_ALLOC(ndr, r->in.handle);
1749 : }
1750 512 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1751 512 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1752 512 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1753 512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1754 512 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
1755 512 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1756 512 : NDR_PULL_ALLOC(ndr, r->in.name);
1757 : }
1758 512 : _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1759 512 : NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
1760 512 : NDR_CHECK(ndr_pull_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1761 512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1762 512 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
1763 512 : if (_ptr_type) {
1764 512 : NDR_PULL_ALLOC(ndr, r->in.type);
1765 : } else {
1766 0 : r->in.type = NULL;
1767 : }
1768 512 : if (r->in.type) {
1769 512 : _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
1770 512 : NDR_PULL_SET_MEM_CTX(ndr, r->in.type, 0);
1771 512 : NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->in.type));
1772 512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
1773 : }
1774 512 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
1775 512 : if (_ptr_value) {
1776 256 : NDR_PULL_ALLOC(ndr, r->in.value);
1777 : } else {
1778 256 : r->in.value = NULL;
1779 : }
1780 512 : if (r->in.value) {
1781 256 : _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
1782 256 : NDR_PULL_SET_MEM_CTX(ndr, r->in.value, 0);
1783 256 : NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value));
1784 256 : NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value));
1785 256 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.value, &size_value_1));
1786 256 : if (size_value_1 > 67108864) {
1787 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1788 : }
1789 256 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->in.value, &length_value_1));
1790 256 : if (length_value_1 > 67108864) {
1791 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1792 : }
1793 256 : if (length_value_1 > size_value_1) {
1794 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_value_1, length_value_1);
1795 : }
1796 256 : NDR_PULL_ALLOC_N(ndr, r->in.value, size_value_1);
1797 256 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.value, length_value_1));
1798 256 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
1799 : }
1800 512 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_size));
1801 512 : if (_ptr_size) {
1802 512 : NDR_PULL_ALLOC(ndr, r->in.size);
1803 : } else {
1804 0 : r->in.size = NULL;
1805 : }
1806 512 : if (r->in.size) {
1807 512 : _mem_save_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1808 512 : NDR_PULL_SET_MEM_CTX(ndr, r->in.size, 0);
1809 512 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.size));
1810 512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_size_0, 0);
1811 : }
1812 512 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_length));
1813 512 : if (_ptr_length) {
1814 512 : NDR_PULL_ALLOC(ndr, r->in.length);
1815 : } else {
1816 0 : r->in.length = NULL;
1817 : }
1818 512 : if (r->in.length) {
1819 512 : _mem_save_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
1820 512 : NDR_PULL_SET_MEM_CTX(ndr, r->in.length, 0);
1821 512 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.length));
1822 512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_length_0, 0);
1823 : }
1824 512 : NDR_PULL_ALLOC(ndr, r->out.name);
1825 512 : *r->out.name = *r->in.name;
1826 512 : if (r->in.value) {
1827 256 : if (r->in.size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");
1828 256 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->in.value, r->in.size?*r->in.size:0));
1829 : }
1830 512 : if (r->in.value) {
1831 256 : if (r->in.length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");
1832 256 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->in.value, r->in.length?*r->in.length:0));
1833 : }
1834 : }
1835 1024 : if (flags & NDR_OUT) {
1836 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1837 : if (r->in.handle == NULL) {
1838 : NDR_PULL_ALLOC(ndr, r->in.handle);
1839 : NDR_ZERO_STRUCTP(r->in.handle);
1840 : }
1841 : if (r->in.name == NULL) {
1842 : NDR_PULL_ALLOC(ndr, r->in.name);
1843 : NDR_ZERO_STRUCTP(r->in.name);
1844 : }
1845 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
1846 512 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1847 8 : NDR_PULL_ALLOC(ndr, r->out.name);
1848 : }
1849 512 : _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1850 512 : NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
1851 512 : NDR_CHECK(ndr_pull_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1852 512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1853 512 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
1854 512 : if (_ptr_type) {
1855 512 : NDR_PULL_ALLOC(ndr, r->out.type);
1856 : } else {
1857 0 : r->out.type = NULL;
1858 : }
1859 512 : if (r->out.type) {
1860 512 : _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
1861 512 : NDR_PULL_SET_MEM_CTX(ndr, r->out.type, 0);
1862 512 : NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
1863 512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
1864 : }
1865 512 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
1866 512 : if (_ptr_value) {
1867 256 : NDR_PULL_ALLOC(ndr, r->out.value);
1868 : } else {
1869 256 : r->out.value = NULL;
1870 : }
1871 512 : if (r->out.value) {
1872 256 : _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
1873 256 : NDR_PULL_SET_MEM_CTX(ndr, r->out.value, 0);
1874 256 : NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value));
1875 256 : NDR_CHECK(ndr_pull_array_length(ndr, &r->out.value));
1876 256 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.value, &size_value_1));
1877 256 : if (size_value_1 > 67108864) {
1878 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1879 : }
1880 256 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.value, &length_value_1));
1881 256 : if (length_value_1 > 67108864) {
1882 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1883 : }
1884 256 : if (length_value_1 > size_value_1) {
1885 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_value_1, length_value_1);
1886 : }
1887 256 : NDR_PULL_ALLOC_N(ndr, r->out.value, size_value_1);
1888 256 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.value, length_value_1));
1889 256 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
1890 : }
1891 512 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_size));
1892 512 : if (_ptr_size) {
1893 512 : NDR_PULL_ALLOC(ndr, r->out.size);
1894 : } else {
1895 0 : r->out.size = NULL;
1896 : }
1897 512 : if (r->out.size) {
1898 512 : _mem_save_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1899 512 : NDR_PULL_SET_MEM_CTX(ndr, r->out.size, 0);
1900 512 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.size));
1901 512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_size_0, 0);
1902 : }
1903 512 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_length));
1904 512 : if (_ptr_length) {
1905 512 : NDR_PULL_ALLOC(ndr, r->out.length);
1906 : } else {
1907 0 : r->out.length = NULL;
1908 : }
1909 512 : if (r->out.length) {
1910 512 : _mem_save_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
1911 512 : NDR_PULL_SET_MEM_CTX(ndr, r->out.length, 0);
1912 512 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.length));
1913 512 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_length_0, 0);
1914 : }
1915 512 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1916 512 : if (r->out.value) {
1917 256 : if (r->out.size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");
1918 256 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.value, r->out.size?*r->out.size:0));
1919 : }
1920 512 : if (r->out.value) {
1921 256 : if (r->out.length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");
1922 256 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.value, r->out.length?*r->out.length:0));
1923 : }
1924 : }
1925 1024 : return NDR_ERR_SUCCESS;
1926 : }
1927 :
1928 16 : _PUBLIC_ void ndr_print_winreg_EnumValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_EnumValue *r)
1929 : {
1930 16 : ndr_print_struct(ndr, name, "winreg_EnumValue");
1931 16 : if (r == NULL) { ndr_print_null(ndr); return; }
1932 16 : ndr->depth++;
1933 16 : if (flags & NDR_SET_VALUES) {
1934 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1935 : }
1936 16 : if (flags & NDR_IN) {
1937 0 : ndr_print_struct(ndr, "in", "winreg_EnumValue");
1938 0 : ndr->depth++;
1939 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
1940 0 : ndr->depth++;
1941 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
1942 0 : ndr->depth--;
1943 0 : ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
1944 0 : ndr_print_ptr(ndr, "name", r->in.name);
1945 0 : ndr->depth++;
1946 0 : ndr_print_winreg_ValNameBuf(ndr, "name", r->in.name);
1947 0 : ndr->depth--;
1948 0 : ndr_print_ptr(ndr, "type", r->in.type);
1949 0 : ndr->depth++;
1950 0 : if (r->in.type) {
1951 0 : ndr_print_winreg_Type(ndr, "type", *r->in.type);
1952 : }
1953 0 : ndr->depth--;
1954 0 : ndr_print_ptr(ndr, "value", r->in.value);
1955 0 : ndr->depth++;
1956 0 : if (r->in.value) {
1957 0 : if (r->in.length == NULL) return;
1958 0 : ndr_print_array_uint8(ndr, "value", r->in.value, r->in.length?*r->in.length:0);
1959 : }
1960 0 : ndr->depth--;
1961 0 : ndr_print_ptr(ndr, "size", r->in.size);
1962 0 : ndr->depth++;
1963 0 : if (r->in.size) {
1964 0 : ndr_print_uint32(ndr, "size", *r->in.size);
1965 : }
1966 0 : ndr->depth--;
1967 0 : ndr_print_ptr(ndr, "length", r->in.length);
1968 0 : ndr->depth++;
1969 0 : if (r->in.length) {
1970 0 : ndr_print_uint32(ndr, "length", *r->in.length);
1971 : }
1972 0 : ndr->depth--;
1973 0 : ndr->depth--;
1974 : }
1975 16 : if (flags & NDR_OUT) {
1976 16 : ndr_print_struct(ndr, "out", "winreg_EnumValue");
1977 16 : ndr->depth++;
1978 16 : ndr_print_ptr(ndr, "name", r->out.name);
1979 16 : ndr->depth++;
1980 16 : ndr_print_winreg_ValNameBuf(ndr, "name", r->out.name);
1981 16 : ndr->depth--;
1982 16 : ndr_print_ptr(ndr, "type", r->out.type);
1983 16 : ndr->depth++;
1984 16 : if (r->out.type) {
1985 16 : ndr_print_winreg_Type(ndr, "type", *r->out.type);
1986 : }
1987 16 : ndr->depth--;
1988 16 : ndr_print_ptr(ndr, "value", r->out.value);
1989 16 : ndr->depth++;
1990 16 : if (r->out.value) {
1991 8 : if (r->out.length == NULL) return;
1992 8 : ndr_print_array_uint8(ndr, "value", r->out.value, r->out.length?*r->out.length:0);
1993 : }
1994 16 : ndr->depth--;
1995 16 : ndr_print_ptr(ndr, "size", r->out.size);
1996 16 : ndr->depth++;
1997 16 : if (r->out.size) {
1998 16 : ndr_print_uint32(ndr, "size", *r->out.size);
1999 : }
2000 16 : ndr->depth--;
2001 16 : ndr_print_ptr(ndr, "length", r->out.length);
2002 16 : ndr->depth++;
2003 16 : if (r->out.length) {
2004 16 : ndr_print_uint32(ndr, "length", *r->out.length);
2005 : }
2006 16 : ndr->depth--;
2007 16 : ndr_print_WERROR(ndr, "result", r->out.result);
2008 16 : ndr->depth--;
2009 : }
2010 16 : ndr->depth--;
2011 : }
2012 :
2013 1352 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_FlushKey(struct ndr_push *ndr, int flags, const struct winreg_FlushKey *r)
2014 : {
2015 1352 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2016 1352 : if (flags & NDR_IN) {
2017 672 : if (r->in.handle == NULL) {
2018 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2019 : }
2020 672 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2021 : }
2022 1352 : if (flags & NDR_OUT) {
2023 680 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2024 : }
2025 1352 : return NDR_ERR_SUCCESS;
2026 : }
2027 :
2028 1344 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_FlushKey(struct ndr_pull *ndr, int flags, struct winreg_FlushKey *r)
2029 : {
2030 1344 : TALLOC_CTX *_mem_save_handle_0 = NULL;
2031 1344 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2032 1344 : if (flags & NDR_IN) {
2033 672 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2034 672 : NDR_PULL_ALLOC(ndr, r->in.handle);
2035 : }
2036 672 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2037 672 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2038 672 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2039 672 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2040 : }
2041 1344 : if (flags & NDR_OUT) {
2042 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2043 : if (r->in.handle == NULL) {
2044 : NDR_PULL_ALLOC(ndr, r->in.handle);
2045 : NDR_ZERO_STRUCTP(r->in.handle);
2046 : }
2047 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
2048 672 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2049 : }
2050 1344 : return NDR_ERR_SUCCESS;
2051 : }
2052 :
2053 16 : _PUBLIC_ void ndr_print_winreg_FlushKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_FlushKey *r)
2054 : {
2055 16 : ndr_print_struct(ndr, name, "winreg_FlushKey");
2056 16 : if (r == NULL) { ndr_print_null(ndr); return; }
2057 16 : ndr->depth++;
2058 16 : if (flags & NDR_SET_VALUES) {
2059 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2060 : }
2061 16 : if (flags & NDR_IN) {
2062 0 : ndr_print_struct(ndr, "in", "winreg_FlushKey");
2063 0 : ndr->depth++;
2064 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
2065 0 : ndr->depth++;
2066 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
2067 0 : ndr->depth--;
2068 0 : ndr->depth--;
2069 : }
2070 16 : if (flags & NDR_OUT) {
2071 16 : ndr_print_struct(ndr, "out", "winreg_FlushKey");
2072 16 : ndr->depth++;
2073 16 : ndr_print_WERROR(ndr, "result", r->out.result);
2074 16 : ndr->depth--;
2075 : }
2076 16 : ndr->depth--;
2077 : }
2078 :
2079 0 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_GetKeySecurity(struct ndr_push *ndr, int flags, const struct winreg_GetKeySecurity *r)
2080 : {
2081 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2082 0 : if (flags & NDR_IN) {
2083 0 : if (r->in.handle == NULL) {
2084 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2085 : }
2086 0 : if (r->in.sd == NULL) {
2087 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2088 : }
2089 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2090 0 : NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
2091 0 : NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
2092 : }
2093 0 : if (flags & NDR_OUT) {
2094 0 : if (r->out.sd == NULL) {
2095 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2096 : }
2097 0 : NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));
2098 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2099 : }
2100 0 : return NDR_ERR_SUCCESS;
2101 : }
2102 :
2103 0 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_GetKeySecurity(struct ndr_pull *ndr, int flags, struct winreg_GetKeySecurity *r)
2104 : {
2105 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
2106 0 : TALLOC_CTX *_mem_save_sd_0 = NULL;
2107 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2108 0 : if (flags & NDR_IN) {
2109 0 : NDR_ZERO_STRUCT(r->out);
2110 :
2111 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2112 0 : NDR_PULL_ALLOC(ndr, r->in.handle);
2113 : }
2114 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2115 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2116 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2117 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2118 0 : NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
2119 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2120 0 : NDR_PULL_ALLOC(ndr, r->in.sd);
2121 : }
2122 0 : _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
2123 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.sd, LIBNDR_FLAG_REF_ALLOC);
2124 0 : NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
2125 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
2126 0 : NDR_PULL_ALLOC(ndr, r->out.sd);
2127 0 : *r->out.sd = *r->in.sd;
2128 : }
2129 0 : if (flags & NDR_OUT) {
2130 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2131 : if (r->in.handle == NULL) {
2132 : NDR_PULL_ALLOC(ndr, r->in.handle);
2133 : NDR_ZERO_STRUCTP(r->in.handle);
2134 : }
2135 : if (r->in.sd == NULL) {
2136 : NDR_PULL_ALLOC(ndr, r->in.sd);
2137 : NDR_ZERO_STRUCTP(r->in.sd);
2138 : }
2139 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
2140 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2141 0 : NDR_PULL_ALLOC(ndr, r->out.sd);
2142 : }
2143 0 : _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
2144 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.sd, LIBNDR_FLAG_REF_ALLOC);
2145 0 : NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));
2146 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
2147 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2148 : }
2149 0 : return NDR_ERR_SUCCESS;
2150 : }
2151 :
2152 0 : _PUBLIC_ void ndr_print_winreg_GetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct winreg_GetKeySecurity *r)
2153 : {
2154 0 : ndr_print_struct(ndr, name, "winreg_GetKeySecurity");
2155 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2156 0 : ndr->depth++;
2157 0 : if (flags & NDR_SET_VALUES) {
2158 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2159 : }
2160 0 : if (flags & NDR_IN) {
2161 0 : ndr_print_struct(ndr, "in", "winreg_GetKeySecurity");
2162 0 : ndr->depth++;
2163 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
2164 0 : ndr->depth++;
2165 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
2166 0 : ndr->depth--;
2167 0 : ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
2168 0 : ndr_print_ptr(ndr, "sd", r->in.sd);
2169 0 : ndr->depth++;
2170 0 : ndr_print_KeySecurityData(ndr, "sd", r->in.sd);
2171 0 : ndr->depth--;
2172 0 : ndr->depth--;
2173 : }
2174 0 : if (flags & NDR_OUT) {
2175 0 : ndr_print_struct(ndr, "out", "winreg_GetKeySecurity");
2176 0 : ndr->depth++;
2177 0 : ndr_print_ptr(ndr, "sd", r->out.sd);
2178 0 : ndr->depth++;
2179 0 : ndr_print_KeySecurityData(ndr, "sd", r->out.sd);
2180 0 : ndr->depth--;
2181 0 : ndr_print_WERROR(ndr, "result", r->out.result);
2182 0 : ndr->depth--;
2183 : }
2184 0 : ndr->depth--;
2185 : }
2186 :
2187 0 : static enum ndr_err_code ndr_push_winreg_LoadKey(struct ndr_push *ndr, int flags, const struct winreg_LoadKey *r)
2188 : {
2189 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2190 0 : if (flags & NDR_IN) {
2191 0 : if (r->in.handle == NULL) {
2192 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2193 : }
2194 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2195 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.keyname));
2196 0 : if (r->in.keyname) {
2197 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyname));
2198 : }
2199 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.filename));
2200 0 : if (r->in.filename) {
2201 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2202 : }
2203 : }
2204 0 : if (flags & NDR_OUT) {
2205 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2206 : }
2207 0 : return NDR_ERR_SUCCESS;
2208 : }
2209 :
2210 0 : static enum ndr_err_code ndr_pull_winreg_LoadKey(struct ndr_pull *ndr, int flags, struct winreg_LoadKey *r)
2211 : {
2212 : uint32_t _ptr_keyname;
2213 : uint32_t _ptr_filename;
2214 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
2215 0 : TALLOC_CTX *_mem_save_keyname_0 = NULL;
2216 0 : TALLOC_CTX *_mem_save_filename_0 = NULL;
2217 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2218 0 : if (flags & NDR_IN) {
2219 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2220 0 : NDR_PULL_ALLOC(ndr, r->in.handle);
2221 : }
2222 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2223 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2224 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2225 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2226 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyname));
2227 0 : if (_ptr_keyname) {
2228 0 : NDR_PULL_ALLOC(ndr, r->in.keyname);
2229 : } else {
2230 0 : r->in.keyname = NULL;
2231 : }
2232 0 : if (r->in.keyname) {
2233 0 : _mem_save_keyname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2234 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.keyname, 0);
2235 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyname));
2236 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyname_0, 0);
2237 : }
2238 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_filename));
2239 0 : if (_ptr_filename) {
2240 0 : NDR_PULL_ALLOC(ndr, r->in.filename);
2241 : } else {
2242 0 : r->in.filename = NULL;
2243 : }
2244 0 : if (r->in.filename) {
2245 0 : _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
2246 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, 0);
2247 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2248 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, 0);
2249 : }
2250 : }
2251 0 : if (flags & NDR_OUT) {
2252 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2253 : if (r->in.handle == NULL) {
2254 : NDR_PULL_ALLOC(ndr, r->in.handle);
2255 : NDR_ZERO_STRUCTP(r->in.handle);
2256 : }
2257 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
2258 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2259 : }
2260 0 : return NDR_ERR_SUCCESS;
2261 : }
2262 :
2263 0 : _PUBLIC_ void ndr_print_winreg_LoadKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_LoadKey *r)
2264 : {
2265 0 : ndr_print_struct(ndr, name, "winreg_LoadKey");
2266 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2267 0 : ndr->depth++;
2268 0 : if (flags & NDR_SET_VALUES) {
2269 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2270 : }
2271 0 : if (flags & NDR_IN) {
2272 0 : ndr_print_struct(ndr, "in", "winreg_LoadKey");
2273 0 : ndr->depth++;
2274 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
2275 0 : ndr->depth++;
2276 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
2277 0 : ndr->depth--;
2278 0 : ndr_print_ptr(ndr, "keyname", r->in.keyname);
2279 0 : ndr->depth++;
2280 0 : if (r->in.keyname) {
2281 0 : ndr_print_winreg_String(ndr, "keyname", r->in.keyname);
2282 : }
2283 0 : ndr->depth--;
2284 0 : ndr_print_ptr(ndr, "filename", r->in.filename);
2285 0 : ndr->depth++;
2286 0 : if (r->in.filename) {
2287 0 : ndr_print_winreg_String(ndr, "filename", r->in.filename);
2288 : }
2289 0 : ndr->depth--;
2290 0 : ndr->depth--;
2291 : }
2292 0 : if (flags & NDR_OUT) {
2293 0 : ndr_print_struct(ndr, "out", "winreg_LoadKey");
2294 0 : ndr->depth++;
2295 0 : ndr_print_WERROR(ndr, "result", r->out.result);
2296 0 : ndr->depth--;
2297 : }
2298 0 : ndr->depth--;
2299 : }
2300 :
2301 516 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_NotifyChangeKeyValue(struct ndr_push *ndr, int flags, const struct winreg_NotifyChangeKeyValue *r)
2302 : {
2303 516 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2304 516 : if (flags & NDR_IN) {
2305 256 : if (r->in.handle == NULL) {
2306 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2307 : }
2308 256 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2309 256 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.watch_subtree));
2310 256 : NDR_CHECK(ndr_push_winreg_NotifyChangeType(ndr, NDR_SCALARS, r->in.notify_filter));
2311 256 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
2312 256 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string1));
2313 256 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string2));
2314 256 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
2315 : }
2316 516 : if (flags & NDR_OUT) {
2317 260 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2318 : }
2319 516 : return NDR_ERR_SUCCESS;
2320 : }
2321 :
2322 512 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_NotifyChangeKeyValue(struct ndr_pull *ndr, int flags, struct winreg_NotifyChangeKeyValue *r)
2323 : {
2324 512 : TALLOC_CTX *_mem_save_handle_0 = NULL;
2325 512 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2326 512 : if (flags & NDR_IN) {
2327 256 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2328 256 : NDR_PULL_ALLOC(ndr, r->in.handle);
2329 : }
2330 256 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2331 256 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2332 256 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2333 256 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2334 256 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.watch_subtree));
2335 256 : NDR_CHECK(ndr_pull_winreg_NotifyChangeType(ndr, NDR_SCALARS, &r->in.notify_filter));
2336 256 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
2337 256 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string1));
2338 256 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string2));
2339 256 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
2340 : }
2341 512 : if (flags & NDR_OUT) {
2342 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2343 : if (r->in.handle == NULL) {
2344 : NDR_PULL_ALLOC(ndr, r->in.handle);
2345 : NDR_ZERO_STRUCTP(r->in.handle);
2346 : }
2347 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
2348 256 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2349 : }
2350 512 : return NDR_ERR_SUCCESS;
2351 : }
2352 :
2353 8 : _PUBLIC_ void ndr_print_winreg_NotifyChangeKeyValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_NotifyChangeKeyValue *r)
2354 : {
2355 8 : ndr_print_struct(ndr, name, "winreg_NotifyChangeKeyValue");
2356 8 : if (r == NULL) { ndr_print_null(ndr); return; }
2357 8 : ndr->depth++;
2358 8 : if (flags & NDR_SET_VALUES) {
2359 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2360 : }
2361 8 : if (flags & NDR_IN) {
2362 0 : ndr_print_struct(ndr, "in", "winreg_NotifyChangeKeyValue");
2363 0 : ndr->depth++;
2364 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
2365 0 : ndr->depth++;
2366 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
2367 0 : ndr->depth--;
2368 0 : ndr_print_uint8(ndr, "watch_subtree", r->in.watch_subtree);
2369 0 : ndr_print_winreg_NotifyChangeType(ndr, "notify_filter", r->in.notify_filter);
2370 0 : ndr_print_uint32(ndr, "unknown", r->in.unknown);
2371 0 : ndr_print_winreg_String(ndr, "string1", &r->in.string1);
2372 0 : ndr_print_winreg_String(ndr, "string2", &r->in.string2);
2373 0 : ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
2374 0 : ndr->depth--;
2375 : }
2376 8 : if (flags & NDR_OUT) {
2377 8 : ndr_print_struct(ndr, "out", "winreg_NotifyChangeKeyValue");
2378 8 : ndr->depth++;
2379 8 : ndr_print_WERROR(ndr, "result", r->out.result);
2380 8 : ndr->depth--;
2381 : }
2382 8 : ndr->depth--;
2383 : }
2384 :
2385 1716 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_OpenKey(struct ndr_push *ndr, int flags, const struct winreg_OpenKey *r)
2386 : {
2387 1716 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2388 1716 : if (flags & NDR_IN) {
2389 852 : if (r->in.parent_handle == NULL) {
2390 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2391 : }
2392 852 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.parent_handle));
2393 852 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyname));
2394 852 : NDR_CHECK(ndr_push_winreg_KeyOptions(ndr, NDR_SCALARS, r->in.options));
2395 852 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
2396 : }
2397 1716 : if (flags & NDR_OUT) {
2398 864 : if (r->out.handle == NULL) {
2399 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2400 : }
2401 864 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
2402 864 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2403 : }
2404 1716 : return NDR_ERR_SUCCESS;
2405 : }
2406 :
2407 1704 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_OpenKey(struct ndr_pull *ndr, int flags, struct winreg_OpenKey *r)
2408 : {
2409 1704 : TALLOC_CTX *_mem_save_parent_handle_0 = NULL;
2410 1704 : TALLOC_CTX *_mem_save_handle_0 = NULL;
2411 1704 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2412 1704 : if (flags & NDR_IN) {
2413 852 : NDR_ZERO_STRUCT(r->out);
2414 :
2415 852 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2416 852 : NDR_PULL_ALLOC(ndr, r->in.parent_handle);
2417 : }
2418 852 : _mem_save_parent_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2419 852 : NDR_PULL_SET_MEM_CTX(ndr, r->in.parent_handle, LIBNDR_FLAG_REF_ALLOC);
2420 852 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.parent_handle));
2421 852 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_handle_0, LIBNDR_FLAG_REF_ALLOC);
2422 852 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyname));
2423 852 : NDR_CHECK(ndr_pull_winreg_KeyOptions(ndr, NDR_SCALARS, &r->in.options));
2424 852 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
2425 852 : NDR_PULL_ALLOC(ndr, r->out.handle);
2426 852 : NDR_ZERO_STRUCTP(r->out.handle);
2427 : }
2428 1704 : if (flags & NDR_OUT) {
2429 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2430 : if (r->in.parent_handle == NULL) {
2431 : NDR_PULL_ALLOC(ndr, r->in.parent_handle);
2432 : NDR_ZERO_STRUCTP(r->in.parent_handle);
2433 : }
2434 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
2435 852 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2436 96 : NDR_PULL_ALLOC(ndr, r->out.handle);
2437 : }
2438 852 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2439 852 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
2440 852 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
2441 852 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2442 852 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2443 : }
2444 1704 : return NDR_ERR_SUCCESS;
2445 : }
2446 :
2447 24 : _PUBLIC_ void ndr_print_winreg_OpenKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenKey *r)
2448 : {
2449 24 : ndr_print_struct(ndr, name, "winreg_OpenKey");
2450 24 : if (r == NULL) { ndr_print_null(ndr); return; }
2451 24 : ndr->depth++;
2452 24 : if (flags & NDR_SET_VALUES) {
2453 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2454 : }
2455 24 : if (flags & NDR_IN) {
2456 0 : ndr_print_struct(ndr, "in", "winreg_OpenKey");
2457 0 : ndr->depth++;
2458 0 : ndr_print_ptr(ndr, "parent_handle", r->in.parent_handle);
2459 0 : ndr->depth++;
2460 0 : ndr_print_policy_handle(ndr, "parent_handle", r->in.parent_handle);
2461 0 : ndr->depth--;
2462 0 : ndr_print_winreg_String(ndr, "keyname", &r->in.keyname);
2463 0 : ndr_print_winreg_KeyOptions(ndr, "options", r->in.options);
2464 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
2465 0 : ndr->depth--;
2466 : }
2467 24 : if (flags & NDR_OUT) {
2468 24 : ndr_print_struct(ndr, "out", "winreg_OpenKey");
2469 24 : ndr->depth++;
2470 24 : ndr_print_ptr(ndr, "handle", r->out.handle);
2471 24 : ndr->depth++;
2472 24 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
2473 24 : ndr->depth--;
2474 24 : ndr_print_WERROR(ndr, "result", r->out.result);
2475 24 : ndr->depth--;
2476 : }
2477 24 : ndr->depth--;
2478 : }
2479 :
2480 626 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryInfoKey(struct ndr_push *ndr, int flags, const struct winreg_QueryInfoKey *r)
2481 : {
2482 626 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2483 626 : if (flags & NDR_IN) {
2484 311 : if (r->in.handle == NULL) {
2485 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2486 : }
2487 311 : if (r->in.classname == NULL) {
2488 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2489 : }
2490 311 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2491 311 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.classname));
2492 : }
2493 626 : if (flags & NDR_OUT) {
2494 315 : if (r->out.classname == NULL) {
2495 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2496 : }
2497 315 : if (r->out.num_subkeys == NULL) {
2498 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2499 : }
2500 315 : if (r->out.max_subkeylen == NULL) {
2501 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2502 : }
2503 315 : if (r->out.max_classlen == NULL) {
2504 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2505 : }
2506 315 : if (r->out.num_values == NULL) {
2507 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2508 : }
2509 315 : if (r->out.max_valnamelen == NULL) {
2510 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2511 : }
2512 315 : if (r->out.max_valbufsize == NULL) {
2513 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2514 : }
2515 315 : if (r->out.secdescsize == NULL) {
2516 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2517 : }
2518 315 : if (r->out.last_changed_time == NULL) {
2519 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2520 : }
2521 315 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.classname));
2522 315 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_subkeys));
2523 315 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeylen));
2524 315 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_classlen));
2525 315 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_values));
2526 315 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valnamelen));
2527 315 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valbufsize));
2528 315 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.secdescsize));
2529 315 : NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));
2530 315 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2531 : }
2532 626 : return NDR_ERR_SUCCESS;
2533 : }
2534 :
2535 622 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryInfoKey(struct ndr_pull *ndr, int flags, struct winreg_QueryInfoKey *r)
2536 : {
2537 622 : TALLOC_CTX *_mem_save_handle_0 = NULL;
2538 622 : TALLOC_CTX *_mem_save_classname_0 = NULL;
2539 622 : TALLOC_CTX *_mem_save_num_subkeys_0 = NULL;
2540 622 : TALLOC_CTX *_mem_save_max_subkeylen_0 = NULL;
2541 622 : TALLOC_CTX *_mem_save_max_classlen_0 = NULL;
2542 622 : TALLOC_CTX *_mem_save_num_values_0 = NULL;
2543 622 : TALLOC_CTX *_mem_save_max_valnamelen_0 = NULL;
2544 622 : TALLOC_CTX *_mem_save_max_valbufsize_0 = NULL;
2545 622 : TALLOC_CTX *_mem_save_secdescsize_0 = NULL;
2546 622 : TALLOC_CTX *_mem_save_last_changed_time_0 = NULL;
2547 622 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2548 622 : if (flags & NDR_IN) {
2549 311 : NDR_ZERO_STRUCT(r->out);
2550 :
2551 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2552 311 : NDR_PULL_ALLOC(ndr, r->in.handle);
2553 : }
2554 311 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2555 311 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2556 311 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2557 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2558 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2559 311 : NDR_PULL_ALLOC(ndr, r->in.classname);
2560 : }
2561 311 : _mem_save_classname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2562 311 : NDR_PULL_SET_MEM_CTX(ndr, r->in.classname, LIBNDR_FLAG_REF_ALLOC);
2563 311 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.classname));
2564 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_classname_0, LIBNDR_FLAG_REF_ALLOC);
2565 311 : NDR_PULL_ALLOC(ndr, r->out.classname);
2566 311 : *r->out.classname = *r->in.classname;
2567 311 : NDR_PULL_ALLOC(ndr, r->out.num_subkeys);
2568 311 : NDR_ZERO_STRUCTP(r->out.num_subkeys);
2569 311 : NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);
2570 311 : NDR_ZERO_STRUCTP(r->out.max_subkeylen);
2571 311 : NDR_PULL_ALLOC(ndr, r->out.max_classlen);
2572 311 : NDR_ZERO_STRUCTP(r->out.max_classlen);
2573 311 : NDR_PULL_ALLOC(ndr, r->out.num_values);
2574 311 : NDR_ZERO_STRUCTP(r->out.num_values);
2575 311 : NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);
2576 311 : NDR_ZERO_STRUCTP(r->out.max_valnamelen);
2577 311 : NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);
2578 311 : NDR_ZERO_STRUCTP(r->out.max_valbufsize);
2579 311 : NDR_PULL_ALLOC(ndr, r->out.secdescsize);
2580 311 : NDR_ZERO_STRUCTP(r->out.secdescsize);
2581 311 : NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
2582 311 : NDR_ZERO_STRUCTP(r->out.last_changed_time);
2583 : }
2584 622 : if (flags & NDR_OUT) {
2585 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2586 : if (r->in.handle == NULL) {
2587 : NDR_PULL_ALLOC(ndr, r->in.handle);
2588 : NDR_ZERO_STRUCTP(r->in.handle);
2589 : }
2590 : if (r->in.classname == NULL) {
2591 : NDR_PULL_ALLOC(ndr, r->in.classname);
2592 : NDR_ZERO_STRUCTP(r->in.classname);
2593 : }
2594 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
2595 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2596 59 : NDR_PULL_ALLOC(ndr, r->out.classname);
2597 : }
2598 311 : _mem_save_classname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2599 311 : NDR_PULL_SET_MEM_CTX(ndr, r->out.classname, LIBNDR_FLAG_REF_ALLOC);
2600 311 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.classname));
2601 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_classname_0, LIBNDR_FLAG_REF_ALLOC);
2602 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2603 59 : NDR_PULL_ALLOC(ndr, r->out.num_subkeys);
2604 : }
2605 311 : _mem_save_num_subkeys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2606 311 : NDR_PULL_SET_MEM_CTX(ndr, r->out.num_subkeys, LIBNDR_FLAG_REF_ALLOC);
2607 311 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_subkeys));
2608 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_subkeys_0, LIBNDR_FLAG_REF_ALLOC);
2609 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2610 59 : NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);
2611 : }
2612 311 : _mem_save_max_subkeylen_0 = NDR_PULL_GET_MEM_CTX(ndr);
2613 311 : NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeylen, LIBNDR_FLAG_REF_ALLOC);
2614 311 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeylen));
2615 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeylen_0, LIBNDR_FLAG_REF_ALLOC);
2616 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2617 59 : NDR_PULL_ALLOC(ndr, r->out.max_classlen);
2618 : }
2619 311 : _mem_save_max_classlen_0 = NDR_PULL_GET_MEM_CTX(ndr);
2620 311 : NDR_PULL_SET_MEM_CTX(ndr, r->out.max_classlen, LIBNDR_FLAG_REF_ALLOC);
2621 311 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_classlen));
2622 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_classlen_0, LIBNDR_FLAG_REF_ALLOC);
2623 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2624 59 : NDR_PULL_ALLOC(ndr, r->out.num_values);
2625 : }
2626 311 : _mem_save_num_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2627 311 : NDR_PULL_SET_MEM_CTX(ndr, r->out.num_values, LIBNDR_FLAG_REF_ALLOC);
2628 311 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_values));
2629 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_values_0, LIBNDR_FLAG_REF_ALLOC);
2630 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2631 59 : NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);
2632 : }
2633 311 : _mem_save_max_valnamelen_0 = NDR_PULL_GET_MEM_CTX(ndr);
2634 311 : NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valnamelen, LIBNDR_FLAG_REF_ALLOC);
2635 311 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valnamelen));
2636 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valnamelen_0, LIBNDR_FLAG_REF_ALLOC);
2637 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2638 59 : NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);
2639 : }
2640 311 : _mem_save_max_valbufsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
2641 311 : NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valbufsize, LIBNDR_FLAG_REF_ALLOC);
2642 311 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valbufsize));
2643 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valbufsize_0, LIBNDR_FLAG_REF_ALLOC);
2644 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2645 59 : NDR_PULL_ALLOC(ndr, r->out.secdescsize);
2646 : }
2647 311 : _mem_save_secdescsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
2648 311 : NDR_PULL_SET_MEM_CTX(ndr, r->out.secdescsize, LIBNDR_FLAG_REF_ALLOC);
2649 311 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.secdescsize));
2650 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdescsize_0, LIBNDR_FLAG_REF_ALLOC);
2651 311 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2652 59 : NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
2653 : }
2654 311 : _mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
2655 311 : NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, LIBNDR_FLAG_REF_ALLOC);
2656 311 : NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));
2657 311 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, LIBNDR_FLAG_REF_ALLOC);
2658 311 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2659 : }
2660 622 : return NDR_ERR_SUCCESS;
2661 : }
2662 :
2663 8 : _PUBLIC_ void ndr_print_winreg_QueryInfoKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryInfoKey *r)
2664 : {
2665 8 : ndr_print_struct(ndr, name, "winreg_QueryInfoKey");
2666 8 : if (r == NULL) { ndr_print_null(ndr); return; }
2667 8 : ndr->depth++;
2668 8 : if (flags & NDR_SET_VALUES) {
2669 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2670 : }
2671 8 : if (flags & NDR_IN) {
2672 0 : ndr_print_struct(ndr, "in", "winreg_QueryInfoKey");
2673 0 : ndr->depth++;
2674 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
2675 0 : ndr->depth++;
2676 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
2677 0 : ndr->depth--;
2678 0 : ndr_print_ptr(ndr, "classname", r->in.classname);
2679 0 : ndr->depth++;
2680 0 : ndr_print_winreg_String(ndr, "classname", r->in.classname);
2681 0 : ndr->depth--;
2682 0 : ndr->depth--;
2683 : }
2684 8 : if (flags & NDR_OUT) {
2685 8 : ndr_print_struct(ndr, "out", "winreg_QueryInfoKey");
2686 8 : ndr->depth++;
2687 8 : ndr_print_ptr(ndr, "classname", r->out.classname);
2688 8 : ndr->depth++;
2689 8 : ndr_print_winreg_String(ndr, "classname", r->out.classname);
2690 8 : ndr->depth--;
2691 8 : ndr_print_ptr(ndr, "num_subkeys", r->out.num_subkeys);
2692 8 : ndr->depth++;
2693 8 : ndr_print_uint32(ndr, "num_subkeys", *r->out.num_subkeys);
2694 8 : ndr->depth--;
2695 8 : ndr_print_ptr(ndr, "max_subkeylen", r->out.max_subkeylen);
2696 8 : ndr->depth++;
2697 8 : ndr_print_uint32(ndr, "max_subkeylen", *r->out.max_subkeylen);
2698 8 : ndr->depth--;
2699 8 : ndr_print_ptr(ndr, "max_classlen", r->out.max_classlen);
2700 8 : ndr->depth++;
2701 8 : ndr_print_uint32(ndr, "max_classlen", *r->out.max_classlen);
2702 8 : ndr->depth--;
2703 8 : ndr_print_ptr(ndr, "num_values", r->out.num_values);
2704 8 : ndr->depth++;
2705 8 : ndr_print_uint32(ndr, "num_values", *r->out.num_values);
2706 8 : ndr->depth--;
2707 8 : ndr_print_ptr(ndr, "max_valnamelen", r->out.max_valnamelen);
2708 8 : ndr->depth++;
2709 8 : ndr_print_uint32(ndr, "max_valnamelen", *r->out.max_valnamelen);
2710 8 : ndr->depth--;
2711 8 : ndr_print_ptr(ndr, "max_valbufsize", r->out.max_valbufsize);
2712 8 : ndr->depth++;
2713 8 : ndr_print_uint32(ndr, "max_valbufsize", *r->out.max_valbufsize);
2714 8 : ndr->depth--;
2715 8 : ndr_print_ptr(ndr, "secdescsize", r->out.secdescsize);
2716 8 : ndr->depth++;
2717 8 : ndr_print_uint32(ndr, "secdescsize", *r->out.secdescsize);
2718 8 : ndr->depth--;
2719 8 : ndr_print_ptr(ndr, "last_changed_time", r->out.last_changed_time);
2720 8 : ndr->depth++;
2721 8 : ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);
2722 8 : ndr->depth--;
2723 8 : ndr_print_WERROR(ndr, "result", r->out.result);
2724 8 : ndr->depth--;
2725 : }
2726 8 : ndr->depth--;
2727 : }
2728 :
2729 32174 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryValue(struct ndr_push *ndr, int flags, const struct winreg_QueryValue *r)
2730 : {
2731 32174 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2732 32174 : if (flags & NDR_IN) {
2733 15992 : if (r->in.handle == NULL) {
2734 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2735 : }
2736 15992 : if (r->in.value_name == NULL) {
2737 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2738 : }
2739 15992 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2740 15992 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.value_name));
2741 15992 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.type));
2742 15992 : if (r->in.type) {
2743 12296 : NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->in.type));
2744 : }
2745 15992 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
2746 15992 : if (r->in.data) {
2747 6720 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size?*r->in.data_size:0));
2748 6720 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2749 6720 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_length?*r->in.data_length:0));
2750 6720 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_length?*r->in.data_length:0));
2751 : }
2752 15992 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_size));
2753 15992 : if (r->in.data_size) {
2754 8600 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_size));
2755 : }
2756 15992 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_length));
2757 15992 : if (r->in.data_length) {
2758 10448 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_length));
2759 : }
2760 : }
2761 32174 : if (flags & NDR_OUT) {
2762 16182 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.type));
2763 16182 : if (r->out.type) {
2764 8922 : NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
2765 : }
2766 16182 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data));
2767 16182 : if (r->out.data) {
2768 8320 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->out.data_size?*r->out.data_size:0));
2769 8320 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2770 8320 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->out.data_length?*r->out.data_length:0));
2771 8320 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->out.data_length?*r->out.data_length:0));
2772 : }
2773 16182 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data_size));
2774 16182 : if (r->out.data_size) {
2775 8702 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_size));
2776 : }
2777 16182 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data_length));
2778 16182 : if (r->out.data_length) {
2779 8812 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_length));
2780 : }
2781 16182 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2782 : }
2783 32174 : return NDR_ERR_SUCCESS;
2784 : }
2785 :
2786 31984 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryValue(struct ndr_pull *ndr, int flags, struct winreg_QueryValue *r)
2787 : {
2788 : uint32_t _ptr_type;
2789 : uint32_t _ptr_data;
2790 31984 : uint32_t size_data_1 = 0;
2791 31984 : uint32_t length_data_1 = 0;
2792 : uint32_t _ptr_data_size;
2793 : uint32_t _ptr_data_length;
2794 31984 : TALLOC_CTX *_mem_save_handle_0 = NULL;
2795 31984 : TALLOC_CTX *_mem_save_value_name_0 = NULL;
2796 31984 : TALLOC_CTX *_mem_save_type_0 = NULL;
2797 31984 : TALLOC_CTX *_mem_save_data_0 = NULL;
2798 31984 : TALLOC_CTX *_mem_save_data_size_0 = NULL;
2799 31984 : TALLOC_CTX *_mem_save_data_length_0 = NULL;
2800 31984 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2801 31984 : if (flags & NDR_IN) {
2802 15992 : NDR_ZERO_STRUCT(r->out);
2803 :
2804 15992 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2805 15992 : NDR_PULL_ALLOC(ndr, r->in.handle);
2806 : }
2807 15992 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2808 15992 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2809 15992 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2810 15992 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2811 15992 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2812 15992 : NDR_PULL_ALLOC(ndr, r->in.value_name);
2813 : }
2814 15992 : _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2815 15992 : NDR_PULL_SET_MEM_CTX(ndr, r->in.value_name, LIBNDR_FLAG_REF_ALLOC);
2816 15992 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.value_name));
2817 15992 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, LIBNDR_FLAG_REF_ALLOC);
2818 15992 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
2819 15992 : if (_ptr_type) {
2820 12296 : NDR_PULL_ALLOC(ndr, r->in.type);
2821 : } else {
2822 3696 : r->in.type = NULL;
2823 : }
2824 15992 : if (r->in.type) {
2825 12296 : _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2826 12296 : NDR_PULL_SET_MEM_CTX(ndr, r->in.type, 0);
2827 12296 : NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->in.type));
2828 12296 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
2829 : }
2830 15992 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2831 15992 : if (_ptr_data) {
2832 6720 : NDR_PULL_ALLOC(ndr, r->in.data);
2833 : } else {
2834 9272 : r->in.data = NULL;
2835 : }
2836 15992 : if (r->in.data) {
2837 6720 : _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2838 6720 : NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
2839 6720 : NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
2840 6720 : NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data));
2841 6720 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.data, &size_data_1));
2842 6720 : if (size_data_1 > 67108864) {
2843 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2844 : }
2845 6720 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->in.data, &length_data_1));
2846 6720 : if (length_data_1 > 67108864) {
2847 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2848 : }
2849 6720 : if (length_data_1 > size_data_1) {
2850 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_1, length_data_1);
2851 : }
2852 6720 : NDR_PULL_ALLOC_N(ndr, r->in.data, size_data_1);
2853 6720 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, length_data_1));
2854 6720 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2855 : }
2856 15992 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));
2857 15992 : if (_ptr_data_size) {
2858 8600 : NDR_PULL_ALLOC(ndr, r->in.data_size);
2859 : } else {
2860 7392 : r->in.data_size = NULL;
2861 : }
2862 15992 : if (r->in.data_size) {
2863 8600 : _mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
2864 8600 : NDR_PULL_SET_MEM_CTX(ndr, r->in.data_size, 0);
2865 8600 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.data_size));
2866 8600 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);
2867 : }
2868 15992 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_length));
2869 15992 : if (_ptr_data_length) {
2870 10448 : NDR_PULL_ALLOC(ndr, r->in.data_length);
2871 : } else {
2872 5544 : r->in.data_length = NULL;
2873 : }
2874 15992 : if (r->in.data_length) {
2875 10448 : _mem_save_data_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2876 10448 : NDR_PULL_SET_MEM_CTX(ndr, r->in.data_length, 0);
2877 10448 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.data_length));
2878 10448 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_length_0, 0);
2879 : }
2880 15992 : if (r->in.data) {
2881 6720 : if (r->in.data_size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");
2882 6720 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->in.data, r->in.data_size?*r->in.data_size:0));
2883 : }
2884 15992 : if (r->in.data) {
2885 6720 : if (r->in.data_length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");
2886 6720 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->in.data, r->in.data_length?*r->in.data_length:0));
2887 : }
2888 : }
2889 31984 : if (flags & NDR_OUT) {
2890 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2891 : if (r->in.handle == NULL) {
2892 : NDR_PULL_ALLOC(ndr, r->in.handle);
2893 : NDR_ZERO_STRUCTP(r->in.handle);
2894 : }
2895 : if (r->in.value_name == NULL) {
2896 : NDR_PULL_ALLOC(ndr, r->in.value_name);
2897 : NDR_ZERO_STRUCTP(r->in.value_name);
2898 : }
2899 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
2900 15992 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
2901 15992 : if (_ptr_type) {
2902 8776 : NDR_PULL_ALLOC(ndr, r->out.type);
2903 : } else {
2904 7216 : r->out.type = NULL;
2905 : }
2906 15992 : if (r->out.type) {
2907 8776 : _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2908 8776 : NDR_PULL_SET_MEM_CTX(ndr, r->out.type, 0);
2909 8776 : NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
2910 8776 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
2911 : }
2912 15992 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2913 15992 : if (_ptr_data) {
2914 8240 : NDR_PULL_ALLOC(ndr, r->out.data);
2915 : } else {
2916 7752 : r->out.data = NULL;
2917 : }
2918 15992 : if (r->out.data) {
2919 8240 : _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2920 8240 : NDR_PULL_SET_MEM_CTX(ndr, r->out.data, 0);
2921 8240 : NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
2922 8240 : NDR_CHECK(ndr_pull_array_length(ndr, &r->out.data));
2923 8240 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.data, &size_data_1));
2924 8240 : if (size_data_1 > 67108864) {
2925 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2926 : }
2927 8240 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.data, &length_data_1));
2928 8240 : if (length_data_1 > 67108864) {
2929 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2930 : }
2931 8240 : if (length_data_1 > size_data_1) {
2932 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_1, length_data_1);
2933 : }
2934 8240 : NDR_PULL_ALLOC_N(ndr, r->out.data, size_data_1);
2935 8240 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, length_data_1));
2936 8240 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2937 : }
2938 15992 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));
2939 15992 : if (_ptr_data_size) {
2940 8600 : NDR_PULL_ALLOC(ndr, r->out.data_size);
2941 : } else {
2942 7392 : r->out.data_size = NULL;
2943 : }
2944 15992 : if (r->out.data_size) {
2945 8600 : _mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
2946 8600 : NDR_PULL_SET_MEM_CTX(ndr, r->out.data_size, 0);
2947 8600 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_size));
2948 8600 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);
2949 : }
2950 15992 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_length));
2951 15992 : if (_ptr_data_length) {
2952 8688 : NDR_PULL_ALLOC(ndr, r->out.data_length);
2953 : } else {
2954 7304 : r->out.data_length = NULL;
2955 : }
2956 15992 : if (r->out.data_length) {
2957 8688 : _mem_save_data_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2958 8688 : NDR_PULL_SET_MEM_CTX(ndr, r->out.data_length, 0);
2959 8688 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_length));
2960 8688 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_length_0, 0);
2961 : }
2962 15992 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2963 15992 : if (r->out.data) {
2964 8240 : if (r->out.data_size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");
2965 8240 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.data, r->out.data_size?*r->out.data_size:0));
2966 : }
2967 15992 : if (r->out.data) {
2968 8240 : if (r->out.data_length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");
2969 8240 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.data, r->out.data_length?*r->out.data_length:0));
2970 : }
2971 : }
2972 31984 : return NDR_ERR_SUCCESS;
2973 : }
2974 :
2975 380 : _PUBLIC_ void ndr_print_winreg_QueryValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryValue *r)
2976 : {
2977 380 : ndr_print_struct(ndr, name, "winreg_QueryValue");
2978 380 : if (r == NULL) { ndr_print_null(ndr); return; }
2979 380 : ndr->depth++;
2980 380 : if (flags & NDR_SET_VALUES) {
2981 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2982 : }
2983 380 : if (flags & NDR_IN) {
2984 0 : ndr_print_struct(ndr, "in", "winreg_QueryValue");
2985 0 : ndr->depth++;
2986 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
2987 0 : ndr->depth++;
2988 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
2989 0 : ndr->depth--;
2990 0 : ndr_print_ptr(ndr, "value_name", r->in.value_name);
2991 0 : ndr->depth++;
2992 0 : ndr_print_winreg_String(ndr, "value_name", r->in.value_name);
2993 0 : ndr->depth--;
2994 0 : ndr_print_ptr(ndr, "type", r->in.type);
2995 0 : ndr->depth++;
2996 0 : if (r->in.type) {
2997 0 : ndr_print_winreg_Type(ndr, "type", *r->in.type);
2998 : }
2999 0 : ndr->depth--;
3000 0 : ndr_print_ptr(ndr, "data", r->in.data);
3001 0 : ndr->depth++;
3002 0 : if (r->in.data) {
3003 0 : if (r->in.data_length == NULL) return;
3004 0 : ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_length?*r->in.data_length:0);
3005 : }
3006 0 : ndr->depth--;
3007 0 : ndr_print_ptr(ndr, "data_size", r->in.data_size);
3008 0 : ndr->depth++;
3009 0 : if (r->in.data_size) {
3010 0 : ndr_print_uint32(ndr, "data_size", *r->in.data_size);
3011 : }
3012 0 : ndr->depth--;
3013 0 : ndr_print_ptr(ndr, "data_length", r->in.data_length);
3014 0 : ndr->depth++;
3015 0 : if (r->in.data_length) {
3016 0 : ndr_print_uint32(ndr, "data_length", *r->in.data_length);
3017 : }
3018 0 : ndr->depth--;
3019 0 : ndr->depth--;
3020 : }
3021 380 : if (flags & NDR_OUT) {
3022 380 : ndr_print_struct(ndr, "out", "winreg_QueryValue");
3023 380 : ndr->depth++;
3024 380 : ndr_print_ptr(ndr, "type", r->out.type);
3025 380 : ndr->depth++;
3026 380 : if (r->out.type) {
3027 292 : ndr_print_winreg_Type(ndr, "type", *r->out.type);
3028 : }
3029 380 : ndr->depth--;
3030 380 : ndr_print_ptr(ndr, "data", r->out.data);
3031 380 : ndr->depth++;
3032 380 : if (r->out.data) {
3033 160 : if (r->out.data_length == NULL) return;
3034 160 : ndr_print_array_uint8(ndr, "data", r->out.data, r->out.data_length?*r->out.data_length:0);
3035 : }
3036 380 : ndr->depth--;
3037 380 : ndr_print_ptr(ndr, "data_size", r->out.data_size);
3038 380 : ndr->depth++;
3039 380 : if (r->out.data_size) {
3040 204 : ndr_print_uint32(ndr, "data_size", *r->out.data_size);
3041 : }
3042 380 : ndr->depth--;
3043 380 : ndr_print_ptr(ndr, "data_length", r->out.data_length);
3044 380 : ndr->depth++;
3045 380 : if (r->out.data_length) {
3046 248 : ndr_print_uint32(ndr, "data_length", *r->out.data_length);
3047 : }
3048 380 : ndr->depth--;
3049 380 : ndr_print_WERROR(ndr, "result", r->out.result);
3050 380 : ndr->depth--;
3051 : }
3052 380 : ndr->depth--;
3053 : }
3054 :
3055 0 : static enum ndr_err_code ndr_push_winreg_ReplaceKey(struct ndr_push *ndr, int flags, const struct winreg_ReplaceKey *r)
3056 : {
3057 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3058 0 : if (flags & NDR_IN) {
3059 0 : if (r->in.handle == NULL) {
3060 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3061 : }
3062 0 : if (r->in.subkey == NULL) {
3063 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3064 : }
3065 0 : if (r->in.new_file == NULL) {
3066 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3067 : }
3068 0 : if (r->in.old_file == NULL) {
3069 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3070 : }
3071 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3072 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.subkey));
3073 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_file));
3074 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_file));
3075 : }
3076 0 : if (flags & NDR_OUT) {
3077 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3078 : }
3079 0 : return NDR_ERR_SUCCESS;
3080 : }
3081 :
3082 0 : static enum ndr_err_code ndr_pull_winreg_ReplaceKey(struct ndr_pull *ndr, int flags, struct winreg_ReplaceKey *r)
3083 : {
3084 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
3085 0 : TALLOC_CTX *_mem_save_subkey_0 = NULL;
3086 0 : TALLOC_CTX *_mem_save_new_file_0 = NULL;
3087 0 : TALLOC_CTX *_mem_save_old_file_0 = NULL;
3088 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3089 0 : if (flags & NDR_IN) {
3090 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3091 0 : NDR_PULL_ALLOC(ndr, r->in.handle);
3092 : }
3093 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3094 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3095 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3096 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3097 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3098 0 : NDR_PULL_ALLOC(ndr, r->in.subkey);
3099 : }
3100 0 : _mem_save_subkey_0 = NDR_PULL_GET_MEM_CTX(ndr);
3101 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.subkey, LIBNDR_FLAG_REF_ALLOC);
3102 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.subkey));
3103 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_subkey_0, LIBNDR_FLAG_REF_ALLOC);
3104 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3105 0 : NDR_PULL_ALLOC(ndr, r->in.new_file);
3106 : }
3107 0 : _mem_save_new_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
3108 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.new_file, LIBNDR_FLAG_REF_ALLOC);
3109 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_file));
3110 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_file_0, LIBNDR_FLAG_REF_ALLOC);
3111 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3112 0 : NDR_PULL_ALLOC(ndr, r->in.old_file);
3113 : }
3114 0 : _mem_save_old_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
3115 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.old_file, LIBNDR_FLAG_REF_ALLOC);
3116 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_file));
3117 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_file_0, LIBNDR_FLAG_REF_ALLOC);
3118 : }
3119 0 : if (flags & NDR_OUT) {
3120 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3121 : if (r->in.handle == NULL) {
3122 : NDR_PULL_ALLOC(ndr, r->in.handle);
3123 : NDR_ZERO_STRUCTP(r->in.handle);
3124 : }
3125 : if (r->in.subkey == NULL) {
3126 : NDR_PULL_ALLOC(ndr, r->in.subkey);
3127 : NDR_ZERO_STRUCTP(r->in.subkey);
3128 : }
3129 : if (r->in.new_file == NULL) {
3130 : NDR_PULL_ALLOC(ndr, r->in.new_file);
3131 : NDR_ZERO_STRUCTP(r->in.new_file);
3132 : }
3133 : if (r->in.old_file == NULL) {
3134 : NDR_PULL_ALLOC(ndr, r->in.old_file);
3135 : NDR_ZERO_STRUCTP(r->in.old_file);
3136 : }
3137 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3138 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3139 : }
3140 0 : return NDR_ERR_SUCCESS;
3141 : }
3142 :
3143 0 : _PUBLIC_ void ndr_print_winreg_ReplaceKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_ReplaceKey *r)
3144 : {
3145 0 : ndr_print_struct(ndr, name, "winreg_ReplaceKey");
3146 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3147 0 : ndr->depth++;
3148 0 : if (flags & NDR_SET_VALUES) {
3149 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3150 : }
3151 0 : if (flags & NDR_IN) {
3152 0 : ndr_print_struct(ndr, "in", "winreg_ReplaceKey");
3153 0 : ndr->depth++;
3154 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
3155 0 : ndr->depth++;
3156 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
3157 0 : ndr->depth--;
3158 0 : ndr_print_ptr(ndr, "subkey", r->in.subkey);
3159 0 : ndr->depth++;
3160 0 : ndr_print_winreg_String(ndr, "subkey", r->in.subkey);
3161 0 : ndr->depth--;
3162 0 : ndr_print_ptr(ndr, "new_file", r->in.new_file);
3163 0 : ndr->depth++;
3164 0 : ndr_print_winreg_String(ndr, "new_file", r->in.new_file);
3165 0 : ndr->depth--;
3166 0 : ndr_print_ptr(ndr, "old_file", r->in.old_file);
3167 0 : ndr->depth++;
3168 0 : ndr_print_winreg_String(ndr, "old_file", r->in.old_file);
3169 0 : ndr->depth--;
3170 0 : ndr->depth--;
3171 : }
3172 0 : if (flags & NDR_OUT) {
3173 0 : ndr_print_struct(ndr, "out", "winreg_ReplaceKey");
3174 0 : ndr->depth++;
3175 0 : ndr_print_WERROR(ndr, "result", r->out.result);
3176 0 : ndr->depth--;
3177 : }
3178 0 : ndr->depth--;
3179 : }
3180 :
3181 0 : static enum ndr_err_code ndr_push_winreg_RestoreKey(struct ndr_push *ndr, int flags, const struct winreg_RestoreKey *r)
3182 : {
3183 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3184 0 : if (flags & NDR_IN) {
3185 0 : if (r->in.handle == NULL) {
3186 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3187 : }
3188 0 : if (r->in.filename == NULL) {
3189 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3190 : }
3191 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3192 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
3193 0 : NDR_CHECK(ndr_push_winreg_RestoreKeyFlags(ndr, NDR_SCALARS, r->in.flags));
3194 : }
3195 0 : if (flags & NDR_OUT) {
3196 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3197 : }
3198 0 : return NDR_ERR_SUCCESS;
3199 : }
3200 :
3201 0 : static enum ndr_err_code ndr_pull_winreg_RestoreKey(struct ndr_pull *ndr, int flags, struct winreg_RestoreKey *r)
3202 : {
3203 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
3204 0 : TALLOC_CTX *_mem_save_filename_0 = NULL;
3205 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3206 0 : if (flags & NDR_IN) {
3207 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3208 0 : NDR_PULL_ALLOC(ndr, r->in.handle);
3209 : }
3210 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3211 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3212 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3213 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3214 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3215 0 : NDR_PULL_ALLOC(ndr, r->in.filename);
3216 : }
3217 0 : _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3218 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, LIBNDR_FLAG_REF_ALLOC);
3219 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
3220 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, LIBNDR_FLAG_REF_ALLOC);
3221 0 : NDR_CHECK(ndr_pull_winreg_RestoreKeyFlags(ndr, NDR_SCALARS, &r->in.flags));
3222 : }
3223 0 : if (flags & NDR_OUT) {
3224 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3225 : if (r->in.handle == NULL) {
3226 : NDR_PULL_ALLOC(ndr, r->in.handle);
3227 : NDR_ZERO_STRUCTP(r->in.handle);
3228 : }
3229 : if (r->in.filename == NULL) {
3230 : NDR_PULL_ALLOC(ndr, r->in.filename);
3231 : NDR_ZERO_STRUCTP(r->in.filename);
3232 : }
3233 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3234 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3235 : }
3236 0 : return NDR_ERR_SUCCESS;
3237 : }
3238 :
3239 0 : _PUBLIC_ void ndr_print_winreg_RestoreKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_RestoreKey *r)
3240 : {
3241 0 : ndr_print_struct(ndr, name, "winreg_RestoreKey");
3242 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3243 0 : ndr->depth++;
3244 0 : if (flags & NDR_SET_VALUES) {
3245 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3246 : }
3247 0 : if (flags & NDR_IN) {
3248 0 : ndr_print_struct(ndr, "in", "winreg_RestoreKey");
3249 0 : ndr->depth++;
3250 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
3251 0 : ndr->depth++;
3252 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
3253 0 : ndr->depth--;
3254 0 : ndr_print_ptr(ndr, "filename", r->in.filename);
3255 0 : ndr->depth++;
3256 0 : ndr_print_winreg_String(ndr, "filename", r->in.filename);
3257 0 : ndr->depth--;
3258 0 : ndr_print_winreg_RestoreKeyFlags(ndr, "flags", r->in.flags);
3259 0 : ndr->depth--;
3260 : }
3261 0 : if (flags & NDR_OUT) {
3262 0 : ndr_print_struct(ndr, "out", "winreg_RestoreKey");
3263 0 : ndr->depth++;
3264 0 : ndr_print_WERROR(ndr, "result", r->out.result);
3265 0 : ndr->depth--;
3266 : }
3267 0 : ndr->depth--;
3268 : }
3269 :
3270 0 : static enum ndr_err_code ndr_push_winreg_SaveKey(struct ndr_push *ndr, int flags, const struct winreg_SaveKey *r)
3271 : {
3272 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3273 0 : if (flags & NDR_IN) {
3274 0 : if (r->in.handle == NULL) {
3275 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3276 : }
3277 0 : if (r->in.filename == NULL) {
3278 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3279 : }
3280 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3281 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
3282 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.sec_attrib));
3283 0 : if (r->in.sec_attrib) {
3284 0 : NDR_CHECK(ndr_push_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));
3285 : }
3286 : }
3287 0 : if (flags & NDR_OUT) {
3288 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3289 : }
3290 0 : return NDR_ERR_SUCCESS;
3291 : }
3292 :
3293 0 : static enum ndr_err_code ndr_pull_winreg_SaveKey(struct ndr_pull *ndr, int flags, struct winreg_SaveKey *r)
3294 : {
3295 : uint32_t _ptr_sec_attrib;
3296 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
3297 0 : TALLOC_CTX *_mem_save_filename_0 = NULL;
3298 0 : TALLOC_CTX *_mem_save_sec_attrib_0 = NULL;
3299 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3300 0 : if (flags & NDR_IN) {
3301 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3302 0 : NDR_PULL_ALLOC(ndr, r->in.handle);
3303 : }
3304 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3305 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3306 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3307 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3308 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3309 0 : NDR_PULL_ALLOC(ndr, r->in.filename);
3310 : }
3311 0 : _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3312 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, LIBNDR_FLAG_REF_ALLOC);
3313 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
3314 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, LIBNDR_FLAG_REF_ALLOC);
3315 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_attrib));
3316 0 : if (_ptr_sec_attrib) {
3317 0 : NDR_PULL_ALLOC(ndr, r->in.sec_attrib);
3318 : } else {
3319 0 : r->in.sec_attrib = NULL;
3320 : }
3321 0 : if (r->in.sec_attrib) {
3322 0 : _mem_save_sec_attrib_0 = NDR_PULL_GET_MEM_CTX(ndr);
3323 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_attrib, 0);
3324 0 : NDR_CHECK(ndr_pull_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));
3325 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_attrib_0, 0);
3326 : }
3327 : }
3328 0 : if (flags & NDR_OUT) {
3329 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3330 : if (r->in.handle == NULL) {
3331 : NDR_PULL_ALLOC(ndr, r->in.handle);
3332 : NDR_ZERO_STRUCTP(r->in.handle);
3333 : }
3334 : if (r->in.filename == NULL) {
3335 : NDR_PULL_ALLOC(ndr, r->in.filename);
3336 : NDR_ZERO_STRUCTP(r->in.filename);
3337 : }
3338 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3339 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3340 : }
3341 0 : return NDR_ERR_SUCCESS;
3342 : }
3343 :
3344 0 : _PUBLIC_ void ndr_print_winreg_SaveKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SaveKey *r)
3345 : {
3346 0 : ndr_print_struct(ndr, name, "winreg_SaveKey");
3347 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3348 0 : ndr->depth++;
3349 0 : if (flags & NDR_SET_VALUES) {
3350 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3351 : }
3352 0 : if (flags & NDR_IN) {
3353 0 : ndr_print_struct(ndr, "in", "winreg_SaveKey");
3354 0 : ndr->depth++;
3355 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
3356 0 : ndr->depth++;
3357 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
3358 0 : ndr->depth--;
3359 0 : ndr_print_ptr(ndr, "filename", r->in.filename);
3360 0 : ndr->depth++;
3361 0 : ndr_print_winreg_String(ndr, "filename", r->in.filename);
3362 0 : ndr->depth--;
3363 0 : ndr_print_ptr(ndr, "sec_attrib", r->in.sec_attrib);
3364 0 : ndr->depth++;
3365 0 : if (r->in.sec_attrib) {
3366 0 : ndr_print_KeySecurityAttribute(ndr, "sec_attrib", r->in.sec_attrib);
3367 : }
3368 0 : ndr->depth--;
3369 0 : ndr->depth--;
3370 : }
3371 0 : if (flags & NDR_OUT) {
3372 0 : ndr_print_struct(ndr, "out", "winreg_SaveKey");
3373 0 : ndr->depth++;
3374 0 : ndr_print_WERROR(ndr, "result", r->out.result);
3375 0 : ndr->depth--;
3376 : }
3377 0 : ndr->depth--;
3378 : }
3379 :
3380 0 : static enum ndr_err_code ndr_push_winreg_SetKeySecurity(struct ndr_push *ndr, int flags, const struct winreg_SetKeySecurity *r)
3381 : {
3382 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3383 0 : if (flags & NDR_IN) {
3384 0 : if (r->in.handle == NULL) {
3385 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3386 : }
3387 0 : if (r->in.sd == NULL) {
3388 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3389 : }
3390 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3391 0 : NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
3392 0 : NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
3393 : }
3394 0 : if (flags & NDR_OUT) {
3395 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3396 : }
3397 0 : return NDR_ERR_SUCCESS;
3398 : }
3399 :
3400 0 : static enum ndr_err_code ndr_pull_winreg_SetKeySecurity(struct ndr_pull *ndr, int flags, struct winreg_SetKeySecurity *r)
3401 : {
3402 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
3403 0 : TALLOC_CTX *_mem_save_sd_0 = NULL;
3404 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3405 0 : if (flags & NDR_IN) {
3406 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3407 0 : NDR_PULL_ALLOC(ndr, r->in.handle);
3408 : }
3409 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3410 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3411 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3412 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3413 0 : NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
3414 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3415 0 : NDR_PULL_ALLOC(ndr, r->in.sd);
3416 : }
3417 0 : _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
3418 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.sd, LIBNDR_FLAG_REF_ALLOC);
3419 0 : NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
3420 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
3421 : }
3422 0 : if (flags & NDR_OUT) {
3423 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3424 : if (r->in.handle == NULL) {
3425 : NDR_PULL_ALLOC(ndr, r->in.handle);
3426 : NDR_ZERO_STRUCTP(r->in.handle);
3427 : }
3428 : if (r->in.sd == NULL) {
3429 : NDR_PULL_ALLOC(ndr, r->in.sd);
3430 : NDR_ZERO_STRUCTP(r->in.sd);
3431 : }
3432 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3433 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3434 : }
3435 0 : return NDR_ERR_SUCCESS;
3436 : }
3437 :
3438 0 : _PUBLIC_ void ndr_print_winreg_SetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SetKeySecurity *r)
3439 : {
3440 0 : ndr_print_struct(ndr, name, "winreg_SetKeySecurity");
3441 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3442 0 : ndr->depth++;
3443 0 : if (flags & NDR_SET_VALUES) {
3444 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3445 : }
3446 0 : if (flags & NDR_IN) {
3447 0 : ndr_print_struct(ndr, "in", "winreg_SetKeySecurity");
3448 0 : ndr->depth++;
3449 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
3450 0 : ndr->depth++;
3451 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
3452 0 : ndr->depth--;
3453 0 : ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
3454 0 : ndr_print_ptr(ndr, "sd", r->in.sd);
3455 0 : ndr->depth++;
3456 0 : ndr_print_KeySecurityData(ndr, "sd", r->in.sd);
3457 0 : ndr->depth--;
3458 0 : ndr->depth--;
3459 : }
3460 0 : if (flags & NDR_OUT) {
3461 0 : ndr_print_struct(ndr, "out", "winreg_SetKeySecurity");
3462 0 : ndr->depth++;
3463 0 : ndr_print_WERROR(ndr, "result", r->out.result);
3464 0 : ndr->depth--;
3465 : }
3466 0 : ndr->depth--;
3467 : }
3468 :
3469 5218 : static enum ndr_err_code ndr_push_winreg_SetValue(struct ndr_push *ndr, int flags, const struct winreg_SetValue *r)
3470 : {
3471 5218 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3472 5218 : if (flags & NDR_IN) {
3473 2600 : if (r->in.handle == NULL) {
3474 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3475 : }
3476 2600 : if (r->in.data == NULL) {
3477 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3478 : }
3479 2600 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3480 2600 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
3481 2600 : NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
3482 2600 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.size));
3483 2600 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.size));
3484 2600 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.size));
3485 : }
3486 5218 : if (flags & NDR_OUT) {
3487 2618 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3488 : }
3489 5218 : return NDR_ERR_SUCCESS;
3490 : }
3491 :
3492 5200 : static enum ndr_err_code ndr_pull_winreg_SetValue(struct ndr_pull *ndr, int flags, struct winreg_SetValue *r)
3493 : {
3494 5200 : uint32_t size_data_1 = 0;
3495 5200 : TALLOC_CTX *_mem_save_handle_0 = NULL;
3496 5200 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3497 5200 : if (flags & NDR_IN) {
3498 2600 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3499 2600 : NDR_PULL_ALLOC(ndr, r->in.handle);
3500 : }
3501 2600 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3502 2600 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3503 2600 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3504 2600 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3505 2600 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
3506 2600 : NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
3507 2600 : NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
3508 2600 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.data, &size_data_1));
3509 2600 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3510 2600 : NDR_PULL_ALLOC_N(ndr, r->in.data, size_data_1);
3511 : }
3512 2600 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, size_data_1));
3513 2600 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.size));
3514 2600 : if (r->in.data) {
3515 2600 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->in.data, r->in.size));
3516 : }
3517 : }
3518 5200 : if (flags & NDR_OUT) {
3519 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3520 : if (r->in.handle == NULL) {
3521 : NDR_PULL_ALLOC(ndr, r->in.handle);
3522 : NDR_ZERO_STRUCTP(r->in.handle);
3523 : }
3524 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3525 2600 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3526 : }
3527 5200 : return NDR_ERR_SUCCESS;
3528 : }
3529 :
3530 36 : _PUBLIC_ void ndr_print_winreg_SetValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SetValue *r)
3531 : {
3532 36 : ndr_print_struct(ndr, name, "winreg_SetValue");
3533 36 : if (r == NULL) { ndr_print_null(ndr); return; }
3534 36 : ndr->depth++;
3535 36 : if (flags & NDR_SET_VALUES) {
3536 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3537 : }
3538 36 : if (flags & NDR_IN) {
3539 0 : ndr_print_struct(ndr, "in", "winreg_SetValue");
3540 0 : ndr->depth++;
3541 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
3542 0 : ndr->depth++;
3543 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
3544 0 : ndr->depth--;
3545 0 : ndr_print_winreg_String(ndr, "name", &r->in.name);
3546 0 : ndr_print_winreg_Type(ndr, "type", r->in.type);
3547 0 : ndr_print_ptr(ndr, "data", r->in.data);
3548 0 : ndr->depth++;
3549 0 : ndr_print_array_uint8(ndr, "data", r->in.data, r->in.size);
3550 0 : ndr->depth--;
3551 0 : ndr_print_uint32(ndr, "size", r->in.size);
3552 0 : ndr->depth--;
3553 : }
3554 36 : if (flags & NDR_OUT) {
3555 36 : ndr_print_struct(ndr, "out", "winreg_SetValue");
3556 36 : ndr->depth++;
3557 36 : ndr_print_WERROR(ndr, "result", r->out.result);
3558 36 : ndr->depth--;
3559 : }
3560 36 : ndr->depth--;
3561 : }
3562 :
3563 0 : static enum ndr_err_code ndr_push_winreg_UnLoadKey(struct ndr_push *ndr, int flags, const struct winreg_UnLoadKey *r)
3564 : {
3565 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3566 0 : if (flags & NDR_IN) {
3567 0 : if (r->in.handle == NULL) {
3568 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3569 : }
3570 0 : if (r->in.subkey == NULL) {
3571 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3572 : }
3573 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3574 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.subkey));
3575 : }
3576 0 : if (flags & NDR_OUT) {
3577 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3578 : }
3579 0 : return NDR_ERR_SUCCESS;
3580 : }
3581 :
3582 0 : static enum ndr_err_code ndr_pull_winreg_UnLoadKey(struct ndr_pull *ndr, int flags, struct winreg_UnLoadKey *r)
3583 : {
3584 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
3585 0 : TALLOC_CTX *_mem_save_subkey_0 = NULL;
3586 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3587 0 : if (flags & NDR_IN) {
3588 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3589 0 : NDR_PULL_ALLOC(ndr, r->in.handle);
3590 : }
3591 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3592 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3593 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3594 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3595 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3596 0 : NDR_PULL_ALLOC(ndr, r->in.subkey);
3597 : }
3598 0 : _mem_save_subkey_0 = NDR_PULL_GET_MEM_CTX(ndr);
3599 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.subkey, LIBNDR_FLAG_REF_ALLOC);
3600 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.subkey));
3601 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_subkey_0, LIBNDR_FLAG_REF_ALLOC);
3602 : }
3603 0 : if (flags & NDR_OUT) {
3604 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3605 : if (r->in.handle == NULL) {
3606 : NDR_PULL_ALLOC(ndr, r->in.handle);
3607 : NDR_ZERO_STRUCTP(r->in.handle);
3608 : }
3609 : if (r->in.subkey == NULL) {
3610 : NDR_PULL_ALLOC(ndr, r->in.subkey);
3611 : NDR_ZERO_STRUCTP(r->in.subkey);
3612 : }
3613 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3614 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3615 : }
3616 0 : return NDR_ERR_SUCCESS;
3617 : }
3618 :
3619 0 : _PUBLIC_ void ndr_print_winreg_UnLoadKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_UnLoadKey *r)
3620 : {
3621 0 : ndr_print_struct(ndr, name, "winreg_UnLoadKey");
3622 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3623 0 : ndr->depth++;
3624 0 : if (flags & NDR_SET_VALUES) {
3625 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3626 : }
3627 0 : if (flags & NDR_IN) {
3628 0 : ndr_print_struct(ndr, "in", "winreg_UnLoadKey");
3629 0 : ndr->depth++;
3630 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
3631 0 : ndr->depth++;
3632 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
3633 0 : ndr->depth--;
3634 0 : ndr_print_ptr(ndr, "subkey", r->in.subkey);
3635 0 : ndr->depth++;
3636 0 : ndr_print_winreg_String(ndr, "subkey", r->in.subkey);
3637 0 : ndr->depth--;
3638 0 : ndr->depth--;
3639 : }
3640 0 : if (flags & NDR_OUT) {
3641 0 : ndr_print_struct(ndr, "out", "winreg_UnLoadKey");
3642 0 : ndr->depth++;
3643 0 : ndr_print_WERROR(ndr, "result", r->out.result);
3644 0 : ndr->depth--;
3645 : }
3646 0 : ndr->depth--;
3647 : }
3648 :
3649 0 : static enum ndr_err_code ndr_push_winreg_InitiateSystemShutdown(struct ndr_push *ndr, int flags, const struct winreg_InitiateSystemShutdown *r)
3650 : {
3651 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3652 0 : if (flags & NDR_IN) {
3653 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hostname));
3654 0 : if (r->in.hostname) {
3655 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.hostname));
3656 : }
3657 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message));
3658 0 : if (r->in.message) {
3659 0 : NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3660 : }
3661 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeout));
3662 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.force_apps));
3663 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.do_reboot));
3664 : }
3665 0 : if (flags & NDR_OUT) {
3666 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3667 : }
3668 0 : return NDR_ERR_SUCCESS;
3669 : }
3670 :
3671 0 : static enum ndr_err_code ndr_pull_winreg_InitiateSystemShutdown(struct ndr_pull *ndr, int flags, struct winreg_InitiateSystemShutdown *r)
3672 : {
3673 : uint32_t _ptr_hostname;
3674 : uint32_t _ptr_message;
3675 0 : TALLOC_CTX *_mem_save_hostname_0 = NULL;
3676 0 : TALLOC_CTX *_mem_save_message_0 = NULL;
3677 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3678 0 : if (flags & NDR_IN) {
3679 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hostname));
3680 0 : if (_ptr_hostname) {
3681 0 : NDR_PULL_ALLOC(ndr, r->in.hostname);
3682 : } else {
3683 0 : r->in.hostname = NULL;
3684 : }
3685 0 : if (r->in.hostname) {
3686 0 : _mem_save_hostname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3687 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.hostname, 0);
3688 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.hostname));
3689 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hostname_0, 0);
3690 : }
3691 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message));
3692 0 : if (_ptr_message) {
3693 0 : NDR_PULL_ALLOC(ndr, r->in.message);
3694 : } else {
3695 0 : r->in.message = NULL;
3696 : }
3697 0 : if (r->in.message) {
3698 0 : _mem_save_message_0 = NDR_PULL_GET_MEM_CTX(ndr);
3699 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.message, 0);
3700 0 : NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3701 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_0, 0);
3702 : }
3703 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeout));
3704 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.force_apps));
3705 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.do_reboot));
3706 : }
3707 0 : if (flags & NDR_OUT) {
3708 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3709 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3710 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3711 : }
3712 0 : return NDR_ERR_SUCCESS;
3713 : }
3714 :
3715 0 : _PUBLIC_ void ndr_print_winreg_InitiateSystemShutdown(struct ndr_print *ndr, const char *name, int flags, const struct winreg_InitiateSystemShutdown *r)
3716 : {
3717 0 : ndr_print_struct(ndr, name, "winreg_InitiateSystemShutdown");
3718 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3719 0 : ndr->depth++;
3720 0 : if (flags & NDR_SET_VALUES) {
3721 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3722 : }
3723 0 : if (flags & NDR_IN) {
3724 0 : ndr_print_struct(ndr, "in", "winreg_InitiateSystemShutdown");
3725 0 : ndr->depth++;
3726 0 : ndr_print_ptr(ndr, "hostname", r->in.hostname);
3727 0 : ndr->depth++;
3728 0 : if (r->in.hostname) {
3729 0 : ndr_print_uint16(ndr, "hostname", *r->in.hostname);
3730 : }
3731 0 : ndr->depth--;
3732 0 : ndr_print_ptr(ndr, "message", r->in.message);
3733 0 : ndr->depth++;
3734 0 : if (r->in.message) {
3735 0 : ndr_print_lsa_StringLarge(ndr, "message", r->in.message);
3736 : }
3737 0 : ndr->depth--;
3738 0 : ndr_print_uint32(ndr, "timeout", r->in.timeout);
3739 0 : ndr_print_uint8(ndr, "force_apps", r->in.force_apps);
3740 0 : ndr_print_uint8(ndr, "do_reboot", r->in.do_reboot);
3741 0 : ndr->depth--;
3742 : }
3743 0 : if (flags & NDR_OUT) {
3744 0 : ndr_print_struct(ndr, "out", "winreg_InitiateSystemShutdown");
3745 0 : ndr->depth++;
3746 0 : ndr_print_WERROR(ndr, "result", r->out.result);
3747 0 : ndr->depth--;
3748 : }
3749 0 : ndr->depth--;
3750 : }
3751 :
3752 0 : static enum ndr_err_code ndr_push_winreg_AbortSystemShutdown(struct ndr_push *ndr, int flags, const struct winreg_AbortSystemShutdown *r)
3753 : {
3754 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3755 0 : if (flags & NDR_IN) {
3756 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
3757 0 : if (r->in.server) {
3758 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.server));
3759 : }
3760 : }
3761 0 : if (flags & NDR_OUT) {
3762 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3763 : }
3764 0 : return NDR_ERR_SUCCESS;
3765 : }
3766 :
3767 0 : static enum ndr_err_code ndr_pull_winreg_AbortSystemShutdown(struct ndr_pull *ndr, int flags, struct winreg_AbortSystemShutdown *r)
3768 : {
3769 : uint32_t _ptr_server;
3770 0 : TALLOC_CTX *_mem_save_server_0 = NULL;
3771 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3772 0 : if (flags & NDR_IN) {
3773 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
3774 0 : if (_ptr_server) {
3775 0 : NDR_PULL_ALLOC(ndr, r->in.server);
3776 : } else {
3777 0 : r->in.server = NULL;
3778 : }
3779 0 : if (r->in.server) {
3780 0 : _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
3781 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
3782 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.server));
3783 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
3784 : }
3785 : }
3786 0 : if (flags & NDR_OUT) {
3787 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3788 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3789 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3790 : }
3791 0 : return NDR_ERR_SUCCESS;
3792 : }
3793 :
3794 0 : _PUBLIC_ void ndr_print_winreg_AbortSystemShutdown(struct ndr_print *ndr, const char *name, int flags, const struct winreg_AbortSystemShutdown *r)
3795 : {
3796 0 : ndr_print_struct(ndr, name, "winreg_AbortSystemShutdown");
3797 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3798 0 : ndr->depth++;
3799 0 : if (flags & NDR_SET_VALUES) {
3800 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3801 : }
3802 0 : if (flags & NDR_IN) {
3803 0 : ndr_print_struct(ndr, "in", "winreg_AbortSystemShutdown");
3804 0 : ndr->depth++;
3805 0 : ndr_print_ptr(ndr, "server", r->in.server);
3806 0 : ndr->depth++;
3807 0 : if (r->in.server) {
3808 0 : ndr_print_uint16(ndr, "server", *r->in.server);
3809 : }
3810 0 : ndr->depth--;
3811 0 : ndr->depth--;
3812 : }
3813 0 : if (flags & NDR_OUT) {
3814 0 : ndr_print_struct(ndr, "out", "winreg_AbortSystemShutdown");
3815 0 : ndr->depth++;
3816 0 : ndr_print_WERROR(ndr, "result", r->out.result);
3817 0 : ndr->depth--;
3818 : }
3819 0 : ndr->depth--;
3820 : }
3821 :
3822 678 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_GetVersion(struct ndr_push *ndr, int flags, const struct winreg_GetVersion *r)
3823 : {
3824 678 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3825 678 : if (flags & NDR_IN) {
3826 337 : if (r->in.handle == NULL) {
3827 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3828 : }
3829 337 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3830 : }
3831 678 : if (flags & NDR_OUT) {
3832 341 : if (r->out.version == NULL) {
3833 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3834 : }
3835 341 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.version));
3836 341 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3837 : }
3838 678 : return NDR_ERR_SUCCESS;
3839 : }
3840 :
3841 674 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_GetVersion(struct ndr_pull *ndr, int flags, struct winreg_GetVersion *r)
3842 : {
3843 674 : TALLOC_CTX *_mem_save_handle_0 = NULL;
3844 674 : TALLOC_CTX *_mem_save_version_0 = NULL;
3845 674 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3846 674 : if (flags & NDR_IN) {
3847 337 : NDR_ZERO_STRUCT(r->out);
3848 :
3849 337 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3850 337 : NDR_PULL_ALLOC(ndr, r->in.handle);
3851 : }
3852 337 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3853 337 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3854 337 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3855 337 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3856 337 : NDR_PULL_ALLOC(ndr, r->out.version);
3857 337 : NDR_ZERO_STRUCTP(r->out.version);
3858 : }
3859 674 : if (flags & NDR_OUT) {
3860 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3861 : if (r->in.handle == NULL) {
3862 : NDR_PULL_ALLOC(ndr, r->in.handle);
3863 : NDR_ZERO_STRUCTP(r->in.handle);
3864 : }
3865 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3866 337 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3867 5 : NDR_PULL_ALLOC(ndr, r->out.version);
3868 : }
3869 337 : _mem_save_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
3870 337 : NDR_PULL_SET_MEM_CTX(ndr, r->out.version, LIBNDR_FLAG_REF_ALLOC);
3871 337 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.version));
3872 337 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_0, LIBNDR_FLAG_REF_ALLOC);
3873 337 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3874 : }
3875 674 : return NDR_ERR_SUCCESS;
3876 : }
3877 :
3878 8 : _PUBLIC_ void ndr_print_winreg_GetVersion(struct ndr_print *ndr, const char *name, int flags, const struct winreg_GetVersion *r)
3879 : {
3880 8 : ndr_print_struct(ndr, name, "winreg_GetVersion");
3881 8 : if (r == NULL) { ndr_print_null(ndr); return; }
3882 8 : ndr->depth++;
3883 8 : if (flags & NDR_SET_VALUES) {
3884 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3885 : }
3886 8 : if (flags & NDR_IN) {
3887 0 : ndr_print_struct(ndr, "in", "winreg_GetVersion");
3888 0 : ndr->depth++;
3889 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
3890 0 : ndr->depth++;
3891 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
3892 0 : ndr->depth--;
3893 0 : ndr->depth--;
3894 : }
3895 8 : if (flags & NDR_OUT) {
3896 8 : ndr_print_struct(ndr, "out", "winreg_GetVersion");
3897 8 : ndr->depth++;
3898 8 : ndr_print_ptr(ndr, "version", r->out.version);
3899 8 : ndr->depth++;
3900 8 : ndr_print_uint32(ndr, "version", *r->out.version);
3901 8 : ndr->depth--;
3902 8 : ndr_print_WERROR(ndr, "result", r->out.result);
3903 8 : ndr->depth--;
3904 : }
3905 8 : ndr->depth--;
3906 : }
3907 :
3908 0 : static enum ndr_err_code ndr_push_winreg_OpenHKCC(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCC *r)
3909 : {
3910 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3911 0 : if (flags & NDR_IN) {
3912 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
3913 0 : if (r->in.system_name) {
3914 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
3915 : }
3916 0 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3917 : }
3918 0 : if (flags & NDR_OUT) {
3919 0 : if (r->out.handle == NULL) {
3920 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3921 : }
3922 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3923 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3924 : }
3925 0 : return NDR_ERR_SUCCESS;
3926 : }
3927 :
3928 0 : static enum ndr_err_code ndr_pull_winreg_OpenHKCC(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCC *r)
3929 : {
3930 : uint32_t _ptr_system_name;
3931 0 : TALLOC_CTX *_mem_save_system_name_0 = NULL;
3932 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
3933 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3934 0 : if (flags & NDR_IN) {
3935 0 : NDR_ZERO_STRUCT(r->out);
3936 :
3937 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
3938 0 : if (_ptr_system_name) {
3939 0 : NDR_PULL_ALLOC(ndr, r->in.system_name);
3940 : } else {
3941 0 : r->in.system_name = NULL;
3942 : }
3943 0 : if (r->in.system_name) {
3944 0 : _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3945 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
3946 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
3947 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
3948 : }
3949 0 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3950 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
3951 0 : NDR_ZERO_STRUCTP(r->out.handle);
3952 : }
3953 0 : if (flags & NDR_OUT) {
3954 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
3955 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
3956 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3957 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
3958 : }
3959 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3960 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3961 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3962 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3963 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3964 : }
3965 0 : return NDR_ERR_SUCCESS;
3966 : }
3967 :
3968 0 : _PUBLIC_ void ndr_print_winreg_OpenHKCC(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCC *r)
3969 : {
3970 0 : ndr_print_struct(ndr, name, "winreg_OpenHKCC");
3971 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3972 0 : ndr->depth++;
3973 0 : if (flags & NDR_SET_VALUES) {
3974 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3975 : }
3976 0 : if (flags & NDR_IN) {
3977 0 : ndr_print_struct(ndr, "in", "winreg_OpenHKCC");
3978 0 : ndr->depth++;
3979 0 : ndr_print_ptr(ndr, "system_name", r->in.system_name);
3980 0 : ndr->depth++;
3981 0 : if (r->in.system_name) {
3982 0 : ndr_print_uint16(ndr, "system_name", *r->in.system_name);
3983 : }
3984 0 : ndr->depth--;
3985 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
3986 0 : ndr->depth--;
3987 : }
3988 0 : if (flags & NDR_OUT) {
3989 0 : ndr_print_struct(ndr, "out", "winreg_OpenHKCC");
3990 0 : ndr->depth++;
3991 0 : ndr_print_ptr(ndr, "handle", r->out.handle);
3992 0 : ndr->depth++;
3993 0 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
3994 0 : ndr->depth--;
3995 0 : ndr_print_WERROR(ndr, "result", r->out.result);
3996 0 : ndr->depth--;
3997 : }
3998 0 : ndr->depth--;
3999 : }
4000 :
4001 0 : static enum ndr_err_code ndr_push_winreg_OpenHKDD(struct ndr_push *ndr, int flags, const struct winreg_OpenHKDD *r)
4002 : {
4003 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4004 0 : if (flags & NDR_IN) {
4005 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
4006 0 : if (r->in.system_name) {
4007 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
4008 : }
4009 0 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
4010 : }
4011 0 : if (flags & NDR_OUT) {
4012 0 : if (r->out.handle == NULL) {
4013 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4014 : }
4015 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4016 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4017 : }
4018 0 : return NDR_ERR_SUCCESS;
4019 : }
4020 :
4021 0 : static enum ndr_err_code ndr_pull_winreg_OpenHKDD(struct ndr_pull *ndr, int flags, struct winreg_OpenHKDD *r)
4022 : {
4023 : uint32_t _ptr_system_name;
4024 0 : TALLOC_CTX *_mem_save_system_name_0 = NULL;
4025 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
4026 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4027 0 : if (flags & NDR_IN) {
4028 0 : NDR_ZERO_STRUCT(r->out);
4029 :
4030 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
4031 0 : if (_ptr_system_name) {
4032 0 : NDR_PULL_ALLOC(ndr, r->in.system_name);
4033 : } else {
4034 0 : r->in.system_name = NULL;
4035 : }
4036 0 : if (r->in.system_name) {
4037 0 : _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4038 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
4039 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
4040 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
4041 : }
4042 0 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
4043 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
4044 0 : NDR_ZERO_STRUCTP(r->out.handle);
4045 : }
4046 0 : if (flags & NDR_OUT) {
4047 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
4048 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
4049 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4050 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
4051 : }
4052 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4053 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4054 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4055 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4056 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4057 : }
4058 0 : return NDR_ERR_SUCCESS;
4059 : }
4060 :
4061 0 : _PUBLIC_ void ndr_print_winreg_OpenHKDD(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKDD *r)
4062 : {
4063 0 : ndr_print_struct(ndr, name, "winreg_OpenHKDD");
4064 0 : if (r == NULL) { ndr_print_null(ndr); return; }
4065 0 : ndr->depth++;
4066 0 : if (flags & NDR_SET_VALUES) {
4067 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4068 : }
4069 0 : if (flags & NDR_IN) {
4070 0 : ndr_print_struct(ndr, "in", "winreg_OpenHKDD");
4071 0 : ndr->depth++;
4072 0 : ndr_print_ptr(ndr, "system_name", r->in.system_name);
4073 0 : ndr->depth++;
4074 0 : if (r->in.system_name) {
4075 0 : ndr_print_uint16(ndr, "system_name", *r->in.system_name);
4076 : }
4077 0 : ndr->depth--;
4078 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
4079 0 : ndr->depth--;
4080 : }
4081 0 : if (flags & NDR_OUT) {
4082 0 : ndr_print_struct(ndr, "out", "winreg_OpenHKDD");
4083 0 : ndr->depth++;
4084 0 : ndr_print_ptr(ndr, "handle", r->out.handle);
4085 0 : ndr->depth++;
4086 0 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
4087 0 : ndr->depth--;
4088 0 : ndr_print_WERROR(ndr, "result", r->out.result);
4089 0 : ndr->depth--;
4090 : }
4091 0 : ndr->depth--;
4092 : }
4093 :
4094 0 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryMultipleValues(struct ndr_push *ndr, int flags, const struct winreg_QueryMultipleValues *r)
4095 : {
4096 : uint32_t cntr_values_in_1;
4097 : uint32_t cntr_values_out_1;
4098 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4099 0 : if (flags & NDR_IN) {
4100 0 : if (r->in.key_handle == NULL) {
4101 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4102 : }
4103 0 : if (r->in.values_in == NULL) {
4104 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4105 : }
4106 0 : if (r->in.buffer_size == NULL) {
4107 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4108 : }
4109 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.key_handle));
4110 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
4111 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4112 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
4113 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (r->in.num_values); cntr_values_in_1++) {
4114 0 : NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values_in[cntr_values_in_1]));
4115 : }
4116 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (r->in.num_values); cntr_values_in_1++) {
4117 0 : NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values_in[cntr_values_in_1]));
4118 : }
4119 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));
4120 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
4121 0 : if (r->in.buffer) {
4122 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.buffer_size));
4123 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4124 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.buffer_size));
4125 0 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, *r->in.buffer_size));
4126 : }
4127 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.buffer_size));
4128 : }
4129 0 : if (flags & NDR_OUT) {
4130 0 : if (r->out.values_out == NULL) {
4131 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4132 : }
4133 0 : if (r->out.buffer_size == NULL) {
4134 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4135 : }
4136 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
4137 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4138 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
4139 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (r->in.num_values); cntr_values_out_1++) {
4140 0 : NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values_out[cntr_values_out_1]));
4141 : }
4142 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (r->in.num_values); cntr_values_out_1++) {
4143 0 : NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values_out[cntr_values_out_1]));
4144 : }
4145 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
4146 0 : if (r->out.buffer) {
4147 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.buffer_size));
4148 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4149 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.buffer_size));
4150 0 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, *r->out.buffer_size));
4151 : }
4152 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.buffer_size));
4153 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4154 : }
4155 0 : return NDR_ERR_SUCCESS;
4156 : }
4157 :
4158 0 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryMultipleValues(struct ndr_pull *ndr, int flags, struct winreg_QueryMultipleValues *r)
4159 : {
4160 0 : uint32_t size_values_in_1 = 0;
4161 0 : uint32_t length_values_in_1 = 0;
4162 : uint32_t cntr_values_in_1;
4163 0 : uint32_t size_values_out_1 = 0;
4164 0 : uint32_t length_values_out_1 = 0;
4165 : uint32_t cntr_values_out_1;
4166 : uint32_t _ptr_buffer;
4167 0 : uint32_t size_buffer_1 = 0;
4168 0 : uint32_t length_buffer_1 = 0;
4169 0 : TALLOC_CTX *_mem_save_key_handle_0 = NULL;
4170 0 : TALLOC_CTX *_mem_save_values_in_1 = NULL;
4171 0 : TALLOC_CTX *_mem_save_values_out_1 = NULL;
4172 0 : TALLOC_CTX *_mem_save_buffer_0 = NULL;
4173 0 : TALLOC_CTX *_mem_save_buffer_size_0 = NULL;
4174 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4175 0 : if (flags & NDR_IN) {
4176 0 : NDR_ZERO_STRUCT(r->out);
4177 :
4178 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4179 0 : NDR_PULL_ALLOC(ndr, r->in.key_handle);
4180 : }
4181 0 : _mem_save_key_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4182 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.key_handle, LIBNDR_FLAG_REF_ALLOC);
4183 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.key_handle));
4184 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_handle_0, LIBNDR_FLAG_REF_ALLOC);
4185 0 : NDR_CHECK(ndr_pull_array_size(ndr, &r->in.values_in));
4186 0 : NDR_CHECK(ndr_pull_array_length(ndr, &r->in.values_in));
4187 0 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.values_in, &size_values_in_1));
4188 0 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->in.values_in, &length_values_in_1));
4189 0 : if (length_values_in_1 > size_values_in_1) {
4190 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_values_in_1, length_values_in_1);
4191 : }
4192 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4193 0 : NDR_PULL_ALLOC_N(ndr, r->in.values_in, size_values_in_1);
4194 : }
4195 0 : _mem_save_values_in_1 = NDR_PULL_GET_MEM_CTX(ndr);
4196 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.values_in, 0);
4197 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (length_values_in_1); cntr_values_in_1++) {
4198 0 : NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values_in[cntr_values_in_1]));
4199 : }
4200 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (length_values_in_1); cntr_values_in_1++) {
4201 0 : NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values_in[cntr_values_in_1]));
4202 : }
4203 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_in_1, 0);
4204 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_values));
4205 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
4206 0 : if (_ptr_buffer) {
4207 0 : NDR_PULL_ALLOC(ndr, r->in.buffer);
4208 : } else {
4209 0 : r->in.buffer = NULL;
4210 : }
4211 0 : if (r->in.buffer) {
4212 0 : _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
4213 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
4214 0 : NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
4215 0 : NDR_CHECK(ndr_pull_array_length(ndr, &r->in.buffer));
4216 0 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.buffer, &size_buffer_1));
4217 0 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->in.buffer, &length_buffer_1));
4218 0 : if (length_buffer_1 > size_buffer_1) {
4219 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_buffer_1, length_buffer_1);
4220 : }
4221 0 : NDR_PULL_ALLOC_N(ndr, r->in.buffer, size_buffer_1);
4222 0 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, length_buffer_1));
4223 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
4224 : }
4225 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4226 0 : NDR_PULL_ALLOC(ndr, r->in.buffer_size);
4227 : }
4228 0 : _mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
4229 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer_size, LIBNDR_FLAG_REF_ALLOC);
4230 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.buffer_size));
4231 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);
4232 0 : NDR_PULL_ALLOC_N(ndr, r->out.values_out, r->in.num_values);
4233 0 : memset(r->out.values_out, 0, (r->in.num_values) * sizeof(*r->out.values_out));
4234 0 : NDR_PULL_ALLOC(ndr, r->out.buffer_size);
4235 0 : *r->out.buffer_size = *r->in.buffer_size;
4236 0 : if (r->in.values_in) {
4237 0 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.values_in, r->in.num_values));
4238 : }
4239 0 : if (r->in.values_in) {
4240 0 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->in.values_in, r->in.num_values));
4241 : }
4242 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (length_values_in_1); cntr_values_in_1++) {
4243 : }
4244 0 : if (r->in.buffer) {
4245 0 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->in.buffer, *r->in.buffer_size));
4246 : }
4247 0 : if (r->in.buffer) {
4248 0 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->in.buffer, *r->in.buffer_size));
4249 : }
4250 : }
4251 0 : if (flags & NDR_OUT) {
4252 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
4253 : if (r->in.key_handle == NULL) {
4254 : NDR_PULL_ALLOC(ndr, r->in.key_handle);
4255 : NDR_ZERO_STRUCTP(r->in.key_handle);
4256 : }
4257 : if (r->in.buffer_size == NULL) {
4258 : NDR_PULL_ALLOC(ndr, r->in.buffer_size);
4259 : NDR_ZERO_STRUCTP(r->in.buffer_size);
4260 : }
4261 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
4262 0 : NDR_CHECK(ndr_pull_array_size(ndr, &r->out.values_out));
4263 0 : NDR_CHECK(ndr_pull_array_length(ndr, &r->out.values_out));
4264 0 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.values_out, &size_values_out_1));
4265 0 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.values_out, &length_values_out_1));
4266 0 : if (length_values_out_1 > size_values_out_1) {
4267 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_values_out_1, length_values_out_1);
4268 : }
4269 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4270 0 : NDR_PULL_ALLOC_N(ndr, r->out.values_out, size_values_out_1);
4271 : }
4272 0 : _mem_save_values_out_1 = NDR_PULL_GET_MEM_CTX(ndr);
4273 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.values_out, 0);
4274 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (length_values_out_1); cntr_values_out_1++) {
4275 0 : NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values_out[cntr_values_out_1]));
4276 : }
4277 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (length_values_out_1); cntr_values_out_1++) {
4278 0 : NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values_out[cntr_values_out_1]));
4279 : }
4280 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_out_1, 0);
4281 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
4282 0 : if (_ptr_buffer) {
4283 0 : NDR_PULL_ALLOC(ndr, r->out.buffer);
4284 : } else {
4285 0 : r->out.buffer = NULL;
4286 : }
4287 0 : if (r->out.buffer) {
4288 0 : _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
4289 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
4290 0 : NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
4291 0 : NDR_CHECK(ndr_pull_array_length(ndr, &r->out.buffer));
4292 0 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.buffer, &size_buffer_1));
4293 0 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.buffer, &length_buffer_1));
4294 0 : if (length_buffer_1 > size_buffer_1) {
4295 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_buffer_1, length_buffer_1);
4296 : }
4297 0 : NDR_PULL_ALLOC_N(ndr, r->out.buffer, size_buffer_1);
4298 0 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, length_buffer_1));
4299 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
4300 : }
4301 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4302 0 : NDR_PULL_ALLOC(ndr, r->out.buffer_size);
4303 : }
4304 0 : _mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
4305 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer_size, LIBNDR_FLAG_REF_ALLOC);
4306 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.buffer_size));
4307 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);
4308 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4309 0 : if (r->out.values_out) {
4310 0 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.values_out, r->in.num_values));
4311 : }
4312 0 : if (r->out.values_out) {
4313 0 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.values_out, r->in.num_values));
4314 : }
4315 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (length_values_out_1); cntr_values_out_1++) {
4316 : }
4317 0 : if (r->out.buffer) {
4318 0 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.buffer, *r->out.buffer_size));
4319 : }
4320 0 : if (r->out.buffer) {
4321 0 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.buffer, *r->out.buffer_size));
4322 : }
4323 : }
4324 0 : return NDR_ERR_SUCCESS;
4325 : }
4326 :
4327 0 : _PUBLIC_ void ndr_print_winreg_QueryMultipleValues(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryMultipleValues *r)
4328 : {
4329 : uint32_t cntr_values_in_1;
4330 : uint32_t cntr_values_out_1;
4331 0 : ndr_print_struct(ndr, name, "winreg_QueryMultipleValues");
4332 0 : if (r == NULL) { ndr_print_null(ndr); return; }
4333 0 : ndr->depth++;
4334 0 : if (flags & NDR_SET_VALUES) {
4335 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4336 : }
4337 0 : if (flags & NDR_IN) {
4338 0 : ndr_print_struct(ndr, "in", "winreg_QueryMultipleValues");
4339 0 : ndr->depth++;
4340 0 : ndr_print_ptr(ndr, "key_handle", r->in.key_handle);
4341 0 : ndr->depth++;
4342 0 : ndr_print_policy_handle(ndr, "key_handle", r->in.key_handle);
4343 0 : ndr->depth--;
4344 0 : ndr_print_ptr(ndr, "values_in", r->in.values_in);
4345 0 : ndr->depth++;
4346 0 : ndr->print(ndr, "%s: ARRAY(%d)", "values_in", (int)r->in.num_values);
4347 0 : ndr->depth++;
4348 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (r->in.num_values); cntr_values_in_1++) {
4349 0 : ndr_print_QueryMultipleValue(ndr, "values_in", &r->in.values_in[cntr_values_in_1]);
4350 : }
4351 0 : ndr->depth--;
4352 0 : ndr->depth--;
4353 0 : ndr_print_uint32(ndr, "num_values", r->in.num_values);
4354 0 : ndr_print_ptr(ndr, "buffer", r->in.buffer);
4355 0 : ndr->depth++;
4356 0 : if (r->in.buffer) {
4357 0 : ndr_print_array_uint8(ndr, "buffer", r->in.buffer, *r->in.buffer_size);
4358 : }
4359 0 : ndr->depth--;
4360 0 : ndr_print_ptr(ndr, "buffer_size", r->in.buffer_size);
4361 0 : ndr->depth++;
4362 0 : ndr_print_uint32(ndr, "buffer_size", *r->in.buffer_size);
4363 0 : ndr->depth--;
4364 0 : ndr->depth--;
4365 : }
4366 0 : if (flags & NDR_OUT) {
4367 0 : ndr_print_struct(ndr, "out", "winreg_QueryMultipleValues");
4368 0 : ndr->depth++;
4369 0 : ndr_print_ptr(ndr, "values_out", r->out.values_out);
4370 0 : ndr->depth++;
4371 0 : ndr->print(ndr, "%s: ARRAY(%d)", "values_out", (int)r->in.num_values);
4372 0 : ndr->depth++;
4373 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (r->in.num_values); cntr_values_out_1++) {
4374 0 : ndr_print_QueryMultipleValue(ndr, "values_out", &r->out.values_out[cntr_values_out_1]);
4375 : }
4376 0 : ndr->depth--;
4377 0 : ndr->depth--;
4378 0 : ndr_print_ptr(ndr, "buffer", r->out.buffer);
4379 0 : ndr->depth++;
4380 0 : if (r->out.buffer) {
4381 0 : ndr_print_array_uint8(ndr, "buffer", r->out.buffer, *r->out.buffer_size);
4382 : }
4383 0 : ndr->depth--;
4384 0 : ndr_print_ptr(ndr, "buffer_size", r->out.buffer_size);
4385 0 : ndr->depth++;
4386 0 : ndr_print_uint32(ndr, "buffer_size", *r->out.buffer_size);
4387 0 : ndr->depth--;
4388 0 : ndr_print_WERROR(ndr, "result", r->out.result);
4389 0 : ndr->depth--;
4390 : }
4391 0 : ndr->depth--;
4392 : }
4393 :
4394 0 : static enum ndr_err_code ndr_push_winreg_InitiateSystemShutdownEx(struct ndr_push *ndr, int flags, const struct winreg_InitiateSystemShutdownEx *r)
4395 : {
4396 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4397 0 : if (flags & NDR_IN) {
4398 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hostname));
4399 0 : if (r->in.hostname) {
4400 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.hostname));
4401 : }
4402 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message));
4403 0 : if (r->in.message) {
4404 0 : NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
4405 : }
4406 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeout));
4407 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.force_apps));
4408 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.do_reboot));
4409 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reason));
4410 : }
4411 0 : if (flags & NDR_OUT) {
4412 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4413 : }
4414 0 : return NDR_ERR_SUCCESS;
4415 : }
4416 :
4417 0 : static enum ndr_err_code ndr_pull_winreg_InitiateSystemShutdownEx(struct ndr_pull *ndr, int flags, struct winreg_InitiateSystemShutdownEx *r)
4418 : {
4419 : uint32_t _ptr_hostname;
4420 : uint32_t _ptr_message;
4421 0 : TALLOC_CTX *_mem_save_hostname_0 = NULL;
4422 0 : TALLOC_CTX *_mem_save_message_0 = NULL;
4423 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4424 0 : if (flags & NDR_IN) {
4425 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hostname));
4426 0 : if (_ptr_hostname) {
4427 0 : NDR_PULL_ALLOC(ndr, r->in.hostname);
4428 : } else {
4429 0 : r->in.hostname = NULL;
4430 : }
4431 0 : if (r->in.hostname) {
4432 0 : _mem_save_hostname_0 = NDR_PULL_GET_MEM_CTX(ndr);
4433 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.hostname, 0);
4434 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.hostname));
4435 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hostname_0, 0);
4436 : }
4437 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message));
4438 0 : if (_ptr_message) {
4439 0 : NDR_PULL_ALLOC(ndr, r->in.message);
4440 : } else {
4441 0 : r->in.message = NULL;
4442 : }
4443 0 : if (r->in.message) {
4444 0 : _mem_save_message_0 = NDR_PULL_GET_MEM_CTX(ndr);
4445 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.message, 0);
4446 0 : NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
4447 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_0, 0);
4448 : }
4449 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeout));
4450 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.force_apps));
4451 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.do_reboot));
4452 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reason));
4453 : }
4454 0 : if (flags & NDR_OUT) {
4455 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
4456 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
4457 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4458 : }
4459 0 : return NDR_ERR_SUCCESS;
4460 : }
4461 :
4462 0 : _PUBLIC_ void ndr_print_winreg_InitiateSystemShutdownEx(struct ndr_print *ndr, const char *name, int flags, const struct winreg_InitiateSystemShutdownEx *r)
4463 : {
4464 0 : ndr_print_struct(ndr, name, "winreg_InitiateSystemShutdownEx");
4465 0 : if (r == NULL) { ndr_print_null(ndr); return; }
4466 0 : ndr->depth++;
4467 0 : if (flags & NDR_SET_VALUES) {
4468 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4469 : }
4470 0 : if (flags & NDR_IN) {
4471 0 : ndr_print_struct(ndr, "in", "winreg_InitiateSystemShutdownEx");
4472 0 : ndr->depth++;
4473 0 : ndr_print_ptr(ndr, "hostname", r->in.hostname);
4474 0 : ndr->depth++;
4475 0 : if (r->in.hostname) {
4476 0 : ndr_print_uint16(ndr, "hostname", *r->in.hostname);
4477 : }
4478 0 : ndr->depth--;
4479 0 : ndr_print_ptr(ndr, "message", r->in.message);
4480 0 : ndr->depth++;
4481 0 : if (r->in.message) {
4482 0 : ndr_print_lsa_StringLarge(ndr, "message", r->in.message);
4483 : }
4484 0 : ndr->depth--;
4485 0 : ndr_print_uint32(ndr, "timeout", r->in.timeout);
4486 0 : ndr_print_uint8(ndr, "force_apps", r->in.force_apps);
4487 0 : ndr_print_uint8(ndr, "do_reboot", r->in.do_reboot);
4488 0 : ndr_print_uint32(ndr, "reason", r->in.reason);
4489 0 : ndr->depth--;
4490 : }
4491 0 : if (flags & NDR_OUT) {
4492 0 : ndr_print_struct(ndr, "out", "winreg_InitiateSystemShutdownEx");
4493 0 : ndr->depth++;
4494 0 : ndr_print_WERROR(ndr, "result", r->out.result);
4495 0 : ndr->depth--;
4496 : }
4497 0 : ndr->depth--;
4498 : }
4499 :
4500 0 : static enum ndr_err_code ndr_push_winreg_SaveKeyEx(struct ndr_push *ndr, int flags, const struct winreg_SaveKeyEx *r)
4501 : {
4502 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4503 0 : if (flags & NDR_IN) {
4504 0 : if (r->in.handle == NULL) {
4505 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4506 : }
4507 0 : if (r->in.filename == NULL) {
4508 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4509 : }
4510 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4511 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
4512 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.sec_attrib));
4513 0 : if (r->in.sec_attrib) {
4514 0 : NDR_CHECK(ndr_push_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));
4515 : }
4516 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
4517 : }
4518 0 : if (flags & NDR_OUT) {
4519 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4520 : }
4521 0 : return NDR_ERR_SUCCESS;
4522 : }
4523 :
4524 0 : static enum ndr_err_code ndr_pull_winreg_SaveKeyEx(struct ndr_pull *ndr, int flags, struct winreg_SaveKeyEx *r)
4525 : {
4526 : uint32_t _ptr_sec_attrib;
4527 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
4528 0 : TALLOC_CTX *_mem_save_filename_0 = NULL;
4529 0 : TALLOC_CTX *_mem_save_sec_attrib_0 = NULL;
4530 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4531 0 : if (flags & NDR_IN) {
4532 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4533 0 : NDR_PULL_ALLOC(ndr, r->in.handle);
4534 : }
4535 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4536 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4537 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4538 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4539 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4540 0 : NDR_PULL_ALLOC(ndr, r->in.filename);
4541 : }
4542 0 : _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
4543 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, LIBNDR_FLAG_REF_ALLOC);
4544 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
4545 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, LIBNDR_FLAG_REF_ALLOC);
4546 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_attrib));
4547 0 : if (_ptr_sec_attrib) {
4548 0 : NDR_PULL_ALLOC(ndr, r->in.sec_attrib);
4549 : } else {
4550 0 : r->in.sec_attrib = NULL;
4551 : }
4552 0 : if (r->in.sec_attrib) {
4553 0 : _mem_save_sec_attrib_0 = NDR_PULL_GET_MEM_CTX(ndr);
4554 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_attrib, 0);
4555 0 : NDR_CHECK(ndr_pull_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));
4556 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_attrib_0, 0);
4557 : }
4558 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
4559 : }
4560 0 : if (flags & NDR_OUT) {
4561 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
4562 : if (r->in.handle == NULL) {
4563 : NDR_PULL_ALLOC(ndr, r->in.handle);
4564 : NDR_ZERO_STRUCTP(r->in.handle);
4565 : }
4566 : if (r->in.filename == NULL) {
4567 : NDR_PULL_ALLOC(ndr, r->in.filename);
4568 : NDR_ZERO_STRUCTP(r->in.filename);
4569 : }
4570 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
4571 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4572 : }
4573 0 : return NDR_ERR_SUCCESS;
4574 : }
4575 :
4576 0 : _PUBLIC_ void ndr_print_winreg_SaveKeyEx(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SaveKeyEx *r)
4577 : {
4578 0 : ndr_print_struct(ndr, name, "winreg_SaveKeyEx");
4579 0 : if (r == NULL) { ndr_print_null(ndr); return; }
4580 0 : ndr->depth++;
4581 0 : if (flags & NDR_SET_VALUES) {
4582 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4583 : }
4584 0 : if (flags & NDR_IN) {
4585 0 : ndr_print_struct(ndr, "in", "winreg_SaveKeyEx");
4586 0 : ndr->depth++;
4587 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
4588 0 : ndr->depth++;
4589 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
4590 0 : ndr->depth--;
4591 0 : ndr_print_ptr(ndr, "filename", r->in.filename);
4592 0 : ndr->depth++;
4593 0 : ndr_print_winreg_String(ndr, "filename", r->in.filename);
4594 0 : ndr->depth--;
4595 0 : ndr_print_ptr(ndr, "sec_attrib", r->in.sec_attrib);
4596 0 : ndr->depth++;
4597 0 : if (r->in.sec_attrib) {
4598 0 : ndr_print_KeySecurityAttribute(ndr, "sec_attrib", r->in.sec_attrib);
4599 : }
4600 0 : ndr->depth--;
4601 0 : ndr_print_uint32(ndr, "flags", r->in.flags);
4602 0 : ndr->depth--;
4603 : }
4604 0 : if (flags & NDR_OUT) {
4605 0 : ndr_print_struct(ndr, "out", "winreg_SaveKeyEx");
4606 0 : ndr->depth++;
4607 0 : ndr_print_WERROR(ndr, "result", r->out.result);
4608 0 : ndr->depth--;
4609 : }
4610 0 : ndr->depth--;
4611 : }
4612 :
4613 0 : static enum ndr_err_code ndr_push_winreg_OpenHKPT(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPT *r)
4614 : {
4615 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4616 0 : if (flags & NDR_IN) {
4617 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
4618 0 : if (r->in.system_name) {
4619 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
4620 : }
4621 0 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
4622 : }
4623 0 : if (flags & NDR_OUT) {
4624 0 : if (r->out.handle == NULL) {
4625 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4626 : }
4627 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4628 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4629 : }
4630 0 : return NDR_ERR_SUCCESS;
4631 : }
4632 :
4633 0 : static enum ndr_err_code ndr_pull_winreg_OpenHKPT(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPT *r)
4634 : {
4635 : uint32_t _ptr_system_name;
4636 0 : TALLOC_CTX *_mem_save_system_name_0 = NULL;
4637 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
4638 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4639 0 : if (flags & NDR_IN) {
4640 0 : NDR_ZERO_STRUCT(r->out);
4641 :
4642 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
4643 0 : if (_ptr_system_name) {
4644 0 : NDR_PULL_ALLOC(ndr, r->in.system_name);
4645 : } else {
4646 0 : r->in.system_name = NULL;
4647 : }
4648 0 : if (r->in.system_name) {
4649 0 : _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4650 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
4651 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
4652 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
4653 : }
4654 0 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
4655 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
4656 0 : NDR_ZERO_STRUCTP(r->out.handle);
4657 : }
4658 0 : if (flags & NDR_OUT) {
4659 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
4660 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
4661 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4662 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
4663 : }
4664 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4665 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4666 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4667 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4668 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4669 : }
4670 0 : return NDR_ERR_SUCCESS;
4671 : }
4672 :
4673 0 : _PUBLIC_ void ndr_print_winreg_OpenHKPT(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPT *r)
4674 : {
4675 0 : ndr_print_struct(ndr, name, "winreg_OpenHKPT");
4676 0 : if (r == NULL) { ndr_print_null(ndr); return; }
4677 0 : ndr->depth++;
4678 0 : if (flags & NDR_SET_VALUES) {
4679 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4680 : }
4681 0 : if (flags & NDR_IN) {
4682 0 : ndr_print_struct(ndr, "in", "winreg_OpenHKPT");
4683 0 : ndr->depth++;
4684 0 : ndr_print_ptr(ndr, "system_name", r->in.system_name);
4685 0 : ndr->depth++;
4686 0 : if (r->in.system_name) {
4687 0 : ndr_print_uint16(ndr, "system_name", *r->in.system_name);
4688 : }
4689 0 : ndr->depth--;
4690 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
4691 0 : ndr->depth--;
4692 : }
4693 0 : if (flags & NDR_OUT) {
4694 0 : ndr_print_struct(ndr, "out", "winreg_OpenHKPT");
4695 0 : ndr->depth++;
4696 0 : ndr_print_ptr(ndr, "handle", r->out.handle);
4697 0 : ndr->depth++;
4698 0 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
4699 0 : ndr->depth--;
4700 0 : ndr_print_WERROR(ndr, "result", r->out.result);
4701 0 : ndr->depth--;
4702 : }
4703 0 : ndr->depth--;
4704 : }
4705 :
4706 0 : static enum ndr_err_code ndr_push_winreg_OpenHKPN(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPN *r)
4707 : {
4708 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4709 0 : if (flags & NDR_IN) {
4710 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
4711 0 : if (r->in.system_name) {
4712 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
4713 : }
4714 0 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
4715 : }
4716 0 : if (flags & NDR_OUT) {
4717 0 : if (r->out.handle == NULL) {
4718 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4719 : }
4720 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4721 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4722 : }
4723 0 : return NDR_ERR_SUCCESS;
4724 : }
4725 :
4726 0 : static enum ndr_err_code ndr_pull_winreg_OpenHKPN(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPN *r)
4727 : {
4728 : uint32_t _ptr_system_name;
4729 0 : TALLOC_CTX *_mem_save_system_name_0 = NULL;
4730 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
4731 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4732 0 : if (flags & NDR_IN) {
4733 0 : NDR_ZERO_STRUCT(r->out);
4734 :
4735 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
4736 0 : if (_ptr_system_name) {
4737 0 : NDR_PULL_ALLOC(ndr, r->in.system_name);
4738 : } else {
4739 0 : r->in.system_name = NULL;
4740 : }
4741 0 : if (r->in.system_name) {
4742 0 : _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4743 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
4744 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
4745 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
4746 : }
4747 0 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
4748 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
4749 0 : NDR_ZERO_STRUCTP(r->out.handle);
4750 : }
4751 0 : if (flags & NDR_OUT) {
4752 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
4753 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
4754 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4755 0 : NDR_PULL_ALLOC(ndr, r->out.handle);
4756 : }
4757 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4758 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4759 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4760 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4761 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4762 : }
4763 0 : return NDR_ERR_SUCCESS;
4764 : }
4765 :
4766 0 : _PUBLIC_ void ndr_print_winreg_OpenHKPN(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPN *r)
4767 : {
4768 0 : ndr_print_struct(ndr, name, "winreg_OpenHKPN");
4769 0 : if (r == NULL) { ndr_print_null(ndr); return; }
4770 0 : ndr->depth++;
4771 0 : if (flags & NDR_SET_VALUES) {
4772 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4773 : }
4774 0 : if (flags & NDR_IN) {
4775 0 : ndr_print_struct(ndr, "in", "winreg_OpenHKPN");
4776 0 : ndr->depth++;
4777 0 : ndr_print_ptr(ndr, "system_name", r->in.system_name);
4778 0 : ndr->depth++;
4779 0 : if (r->in.system_name) {
4780 0 : ndr_print_uint16(ndr, "system_name", *r->in.system_name);
4781 : }
4782 0 : ndr->depth--;
4783 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
4784 0 : ndr->depth--;
4785 : }
4786 0 : if (flags & NDR_OUT) {
4787 0 : ndr_print_struct(ndr, "out", "winreg_OpenHKPN");
4788 0 : ndr->depth++;
4789 0 : ndr_print_ptr(ndr, "handle", r->out.handle);
4790 0 : ndr->depth++;
4791 0 : ndr_print_policy_handle(ndr, "handle", r->out.handle);
4792 0 : ndr->depth--;
4793 0 : ndr_print_WERROR(ndr, "result", r->out.result);
4794 0 : ndr->depth--;
4795 : }
4796 0 : ndr->depth--;
4797 : }
4798 :
4799 0 : _PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryMultipleValues2(struct ndr_push *ndr, int flags, const struct winreg_QueryMultipleValues2 *r)
4800 : {
4801 : uint32_t cntr_values_in_1;
4802 : uint32_t cntr_values_out_1;
4803 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4804 0 : if (flags & NDR_IN) {
4805 0 : if (r->in.key_handle == NULL) {
4806 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4807 : }
4808 0 : if (r->in.values_in == NULL) {
4809 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4810 : }
4811 0 : if (r->in.offered == NULL) {
4812 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4813 : }
4814 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.key_handle));
4815 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
4816 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4817 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
4818 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (r->in.num_values); cntr_values_in_1++) {
4819 0 : NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values_in[cntr_values_in_1]));
4820 : }
4821 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (r->in.num_values); cntr_values_in_1++) {
4822 0 : NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values_in[cntr_values_in_1]));
4823 : }
4824 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));
4825 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
4826 0 : if (r->in.buffer) {
4827 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.offered));
4828 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4829 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.offered));
4830 0 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, *r->in.offered));
4831 : }
4832 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.offered));
4833 : }
4834 0 : if (flags & NDR_OUT) {
4835 0 : if (r->out.values_out == NULL) {
4836 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4837 : }
4838 0 : if (r->out.needed == NULL) {
4839 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4840 : }
4841 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
4842 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4843 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
4844 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (r->in.num_values); cntr_values_out_1++) {
4845 0 : NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values_out[cntr_values_out_1]));
4846 : }
4847 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (r->in.num_values); cntr_values_out_1++) {
4848 0 : NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values_out[cntr_values_out_1]));
4849 : }
4850 0 : NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
4851 0 : if (r->out.buffer) {
4852 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.offered));
4853 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4854 0 : NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.offered));
4855 0 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, *r->in.offered));
4856 : }
4857 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
4858 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4859 : }
4860 0 : return NDR_ERR_SUCCESS;
4861 : }
4862 :
4863 0 : _PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryMultipleValues2(struct ndr_pull *ndr, int flags, struct winreg_QueryMultipleValues2 *r)
4864 : {
4865 0 : uint32_t size_values_in_1 = 0;
4866 0 : uint32_t length_values_in_1 = 0;
4867 : uint32_t cntr_values_in_1;
4868 0 : uint32_t size_values_out_1 = 0;
4869 0 : uint32_t length_values_out_1 = 0;
4870 : uint32_t cntr_values_out_1;
4871 : uint32_t _ptr_buffer;
4872 0 : uint32_t size_buffer_1 = 0;
4873 0 : uint32_t length_buffer_1 = 0;
4874 0 : TALLOC_CTX *_mem_save_key_handle_0 = NULL;
4875 0 : TALLOC_CTX *_mem_save_values_in_1 = NULL;
4876 0 : TALLOC_CTX *_mem_save_values_out_1 = NULL;
4877 0 : TALLOC_CTX *_mem_save_buffer_0 = NULL;
4878 0 : TALLOC_CTX *_mem_save_offered_0 = NULL;
4879 0 : TALLOC_CTX *_mem_save_needed_0 = NULL;
4880 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4881 0 : if (flags & NDR_IN) {
4882 0 : NDR_ZERO_STRUCT(r->out);
4883 :
4884 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4885 0 : NDR_PULL_ALLOC(ndr, r->in.key_handle);
4886 : }
4887 0 : _mem_save_key_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4888 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.key_handle, LIBNDR_FLAG_REF_ALLOC);
4889 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.key_handle));
4890 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_handle_0, LIBNDR_FLAG_REF_ALLOC);
4891 0 : NDR_CHECK(ndr_pull_array_size(ndr, &r->in.values_in));
4892 0 : NDR_CHECK(ndr_pull_array_length(ndr, &r->in.values_in));
4893 0 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.values_in, &size_values_in_1));
4894 0 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->in.values_in, &length_values_in_1));
4895 0 : if (length_values_in_1 > size_values_in_1) {
4896 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_values_in_1, length_values_in_1);
4897 : }
4898 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4899 0 : NDR_PULL_ALLOC_N(ndr, r->in.values_in, size_values_in_1);
4900 : }
4901 0 : _mem_save_values_in_1 = NDR_PULL_GET_MEM_CTX(ndr);
4902 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.values_in, 0);
4903 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (length_values_in_1); cntr_values_in_1++) {
4904 0 : NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values_in[cntr_values_in_1]));
4905 : }
4906 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (length_values_in_1); cntr_values_in_1++) {
4907 0 : NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values_in[cntr_values_in_1]));
4908 : }
4909 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_in_1, 0);
4910 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_values));
4911 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
4912 0 : if (_ptr_buffer) {
4913 0 : NDR_PULL_ALLOC(ndr, r->in.buffer);
4914 : } else {
4915 0 : r->in.buffer = NULL;
4916 : }
4917 0 : if (r->in.buffer) {
4918 0 : _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
4919 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
4920 0 : NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
4921 0 : NDR_CHECK(ndr_pull_array_length(ndr, &r->in.buffer));
4922 0 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.buffer, &size_buffer_1));
4923 0 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->in.buffer, &length_buffer_1));
4924 0 : if (length_buffer_1 > size_buffer_1) {
4925 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_buffer_1, length_buffer_1);
4926 : }
4927 0 : NDR_PULL_ALLOC_N(ndr, r->in.buffer, size_buffer_1);
4928 0 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, length_buffer_1));
4929 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
4930 : }
4931 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4932 0 : NDR_PULL_ALLOC(ndr, r->in.offered);
4933 : }
4934 0 : _mem_save_offered_0 = NDR_PULL_GET_MEM_CTX(ndr);
4935 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.offered, LIBNDR_FLAG_REF_ALLOC);
4936 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.offered));
4937 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_offered_0, LIBNDR_FLAG_REF_ALLOC);
4938 0 : NDR_PULL_ALLOC_N(ndr, r->out.values_out, r->in.num_values);
4939 0 : memset(r->out.values_out, 0, (r->in.num_values) * sizeof(*r->out.values_out));
4940 0 : NDR_PULL_ALLOC(ndr, r->out.needed);
4941 0 : NDR_ZERO_STRUCTP(r->out.needed);
4942 0 : if (r->in.values_in) {
4943 0 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.values_in, r->in.num_values));
4944 : }
4945 0 : if (r->in.values_in) {
4946 0 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->in.values_in, r->in.num_values));
4947 : }
4948 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (length_values_in_1); cntr_values_in_1++) {
4949 : }
4950 0 : if (r->in.buffer) {
4951 0 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->in.buffer, *r->in.offered));
4952 : }
4953 0 : if (r->in.buffer) {
4954 0 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->in.buffer, *r->in.offered));
4955 : }
4956 : }
4957 0 : if (flags & NDR_OUT) {
4958 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
4959 : if (r->in.key_handle == NULL) {
4960 : NDR_PULL_ALLOC(ndr, r->in.key_handle);
4961 : NDR_ZERO_STRUCTP(r->in.key_handle);
4962 : }
4963 : if (r->in.offered == NULL) {
4964 : NDR_PULL_ALLOC(ndr, r->in.offered);
4965 : NDR_ZERO_STRUCTP(r->in.offered);
4966 : }
4967 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
4968 0 : NDR_CHECK(ndr_pull_array_size(ndr, &r->out.values_out));
4969 0 : NDR_CHECK(ndr_pull_array_length(ndr, &r->out.values_out));
4970 0 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.values_out, &size_values_out_1));
4971 0 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.values_out, &length_values_out_1));
4972 0 : if (length_values_out_1 > size_values_out_1) {
4973 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_values_out_1, length_values_out_1);
4974 : }
4975 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4976 0 : NDR_PULL_ALLOC_N(ndr, r->out.values_out, size_values_out_1);
4977 : }
4978 0 : _mem_save_values_out_1 = NDR_PULL_GET_MEM_CTX(ndr);
4979 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.values_out, 0);
4980 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (length_values_out_1); cntr_values_out_1++) {
4981 0 : NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values_out[cntr_values_out_1]));
4982 : }
4983 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (length_values_out_1); cntr_values_out_1++) {
4984 0 : NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values_out[cntr_values_out_1]));
4985 : }
4986 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_out_1, 0);
4987 0 : NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
4988 0 : if (_ptr_buffer) {
4989 0 : NDR_PULL_ALLOC(ndr, r->out.buffer);
4990 : } else {
4991 0 : r->out.buffer = NULL;
4992 : }
4993 0 : if (r->out.buffer) {
4994 0 : _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
4995 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
4996 0 : NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
4997 0 : NDR_CHECK(ndr_pull_array_length(ndr, &r->out.buffer));
4998 0 : NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.buffer, &size_buffer_1));
4999 0 : NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->out.buffer, &length_buffer_1));
5000 0 : if (length_buffer_1 > size_buffer_1) {
5001 0 : return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_buffer_1, length_buffer_1);
5002 : }
5003 0 : NDR_PULL_ALLOC_N(ndr, r->out.buffer, size_buffer_1);
5004 0 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, length_buffer_1));
5005 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
5006 : }
5007 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5008 0 : NDR_PULL_ALLOC(ndr, r->out.needed);
5009 : }
5010 0 : _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
5011 0 : NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
5012 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
5013 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
5014 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5015 0 : if (r->out.values_out) {
5016 0 : NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.values_out, r->in.num_values));
5017 : }
5018 0 : if (r->out.values_out) {
5019 0 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.values_out, r->in.num_values));
5020 : }
5021 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (length_values_out_1); cntr_values_out_1++) {
5022 : }
5023 0 : if (r->out.buffer) {
5024 0 : NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.buffer, *r->in.offered));
5025 : }
5026 0 : if (r->out.buffer) {
5027 0 : NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->out.buffer, *r->in.offered));
5028 : }
5029 : }
5030 0 : return NDR_ERR_SUCCESS;
5031 : }
5032 :
5033 0 : _PUBLIC_ void ndr_print_winreg_QueryMultipleValues2(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryMultipleValues2 *r)
5034 : {
5035 : uint32_t cntr_values_in_1;
5036 : uint32_t cntr_values_out_1;
5037 0 : ndr_print_struct(ndr, name, "winreg_QueryMultipleValues2");
5038 0 : if (r == NULL) { ndr_print_null(ndr); return; }
5039 0 : ndr->depth++;
5040 0 : if (flags & NDR_SET_VALUES) {
5041 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5042 : }
5043 0 : if (flags & NDR_IN) {
5044 0 : ndr_print_struct(ndr, "in", "winreg_QueryMultipleValues2");
5045 0 : ndr->depth++;
5046 0 : ndr_print_ptr(ndr, "key_handle", r->in.key_handle);
5047 0 : ndr->depth++;
5048 0 : ndr_print_policy_handle(ndr, "key_handle", r->in.key_handle);
5049 0 : ndr->depth--;
5050 0 : ndr_print_ptr(ndr, "values_in", r->in.values_in);
5051 0 : ndr->depth++;
5052 0 : ndr->print(ndr, "%s: ARRAY(%d)", "values_in", (int)r->in.num_values);
5053 0 : ndr->depth++;
5054 0 : for (cntr_values_in_1 = 0; cntr_values_in_1 < (r->in.num_values); cntr_values_in_1++) {
5055 0 : ndr_print_QueryMultipleValue(ndr, "values_in", &r->in.values_in[cntr_values_in_1]);
5056 : }
5057 0 : ndr->depth--;
5058 0 : ndr->depth--;
5059 0 : ndr_print_uint32(ndr, "num_values", r->in.num_values);
5060 0 : ndr_print_ptr(ndr, "buffer", r->in.buffer);
5061 0 : ndr->depth++;
5062 0 : if (r->in.buffer) {
5063 0 : ndr_print_array_uint8(ndr, "buffer", r->in.buffer, *r->in.offered);
5064 : }
5065 0 : ndr->depth--;
5066 0 : ndr_print_ptr(ndr, "offered", r->in.offered);
5067 0 : ndr->depth++;
5068 0 : ndr_print_uint32(ndr, "offered", *r->in.offered);
5069 0 : ndr->depth--;
5070 0 : ndr->depth--;
5071 : }
5072 0 : if (flags & NDR_OUT) {
5073 0 : ndr_print_struct(ndr, "out", "winreg_QueryMultipleValues2");
5074 0 : ndr->depth++;
5075 0 : ndr_print_ptr(ndr, "values_out", r->out.values_out);
5076 0 : ndr->depth++;
5077 0 : ndr->print(ndr, "%s: ARRAY(%d)", "values_out", (int)r->in.num_values);
5078 0 : ndr->depth++;
5079 0 : for (cntr_values_out_1 = 0; cntr_values_out_1 < (r->in.num_values); cntr_values_out_1++) {
5080 0 : ndr_print_QueryMultipleValue(ndr, "values_out", &r->out.values_out[cntr_values_out_1]);
5081 : }
5082 0 : ndr->depth--;
5083 0 : ndr->depth--;
5084 0 : ndr_print_ptr(ndr, "buffer", r->out.buffer);
5085 0 : ndr->depth++;
5086 0 : if (r->out.buffer) {
5087 0 : ndr_print_array_uint8(ndr, "buffer", r->out.buffer, *r->in.offered);
5088 : }
5089 0 : ndr->depth--;
5090 0 : ndr_print_ptr(ndr, "needed", r->out.needed);
5091 0 : ndr->depth++;
5092 0 : ndr_print_uint32(ndr, "needed", *r->out.needed);
5093 0 : ndr->depth--;
5094 0 : ndr_print_WERROR(ndr, "result", r->out.result);
5095 0 : ndr->depth--;
5096 : }
5097 0 : ndr->depth--;
5098 : }
5099 :
5100 0 : static enum ndr_err_code ndr_push_winreg_DeleteKeyEx(struct ndr_push *ndr, int flags, const struct winreg_DeleteKeyEx *r)
5101 : {
5102 0 : NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5103 0 : if (flags & NDR_IN) {
5104 0 : if (r->in.handle == NULL) {
5105 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5106 : }
5107 0 : if (r->in.key == NULL) {
5108 0 : return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5109 : }
5110 0 : NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5111 0 : NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.key));
5112 0 : NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5113 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
5114 : }
5115 0 : if (flags & NDR_OUT) {
5116 0 : NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5117 : }
5118 0 : return NDR_ERR_SUCCESS;
5119 : }
5120 :
5121 0 : static enum ndr_err_code ndr_pull_winreg_DeleteKeyEx(struct ndr_pull *ndr, int flags, struct winreg_DeleteKeyEx *r)
5122 : {
5123 0 : TALLOC_CTX *_mem_save_handle_0 = NULL;
5124 0 : TALLOC_CTX *_mem_save_key_0 = NULL;
5125 0 : NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5126 0 : if (flags & NDR_IN) {
5127 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5128 0 : NDR_PULL_ALLOC(ndr, r->in.handle);
5129 : }
5130 0 : _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5131 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5132 0 : NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5133 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5134 0 : if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5135 0 : NDR_PULL_ALLOC(ndr, r->in.key);
5136 : }
5137 0 : _mem_save_key_0 = NDR_PULL_GET_MEM_CTX(ndr);
5138 0 : NDR_PULL_SET_MEM_CTX(ndr, r->in.key, LIBNDR_FLAG_REF_ALLOC);
5139 0 : NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.key));
5140 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_0, LIBNDR_FLAG_REF_ALLOC);
5141 0 : NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
5142 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
5143 : }
5144 0 : if (flags & NDR_OUT) {
5145 : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
5146 : if (r->in.handle == NULL) {
5147 : NDR_PULL_ALLOC(ndr, r->in.handle);
5148 : NDR_ZERO_STRUCTP(r->in.handle);
5149 : }
5150 : if (r->in.key == NULL) {
5151 : NDR_PULL_ALLOC(ndr, r->in.key);
5152 : NDR_ZERO_STRUCTP(r->in.key);
5153 : }
5154 : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
5155 0 : NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5156 : }
5157 0 : return NDR_ERR_SUCCESS;
5158 : }
5159 :
5160 0 : _PUBLIC_ void ndr_print_winreg_DeleteKeyEx(struct ndr_print *ndr, const char *name, int flags, const struct winreg_DeleteKeyEx *r)
5161 : {
5162 0 : ndr_print_struct(ndr, name, "winreg_DeleteKeyEx");
5163 0 : if (r == NULL) { ndr_print_null(ndr); return; }
5164 0 : ndr->depth++;
5165 0 : if (flags & NDR_SET_VALUES) {
5166 0 : ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5167 : }
5168 0 : if (flags & NDR_IN) {
5169 0 : ndr_print_struct(ndr, "in", "winreg_DeleteKeyEx");
5170 0 : ndr->depth++;
5171 0 : ndr_print_ptr(ndr, "handle", r->in.handle);
5172 0 : ndr->depth++;
5173 0 : ndr_print_policy_handle(ndr, "handle", r->in.handle);
5174 0 : ndr->depth--;
5175 0 : ndr_print_ptr(ndr, "key", r->in.key);
5176 0 : ndr->depth++;
5177 0 : ndr_print_winreg_String(ndr, "key", r->in.key);
5178 0 : ndr->depth--;
5179 0 : ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
5180 0 : ndr_print_uint32(ndr, "reserved", r->in.reserved);
5181 0 : ndr->depth--;
5182 : }
5183 0 : if (flags & NDR_OUT) {
5184 0 : ndr_print_struct(ndr, "out", "winreg_DeleteKeyEx");
5185 0 : ndr->depth++;
5186 0 : ndr_print_WERROR(ndr, "result", r->out.result);
5187 0 : ndr->depth--;
5188 : }
5189 0 : ndr->depth--;
5190 : }
5191 :
5192 : #ifndef SKIP_NDR_TABLE_winreg
5193 : static const struct ndr_interface_public_struct winreg_public_structs[] = {
5194 : {
5195 : .name = "winreg_String",
5196 : .struct_size = sizeof(struct winreg_String ),
5197 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_winreg_String,
5198 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_winreg_String,
5199 : .ndr_print = (ndr_print_function_t) ndr_print_flags_winreg_String,
5200 : },
5201 : { .name = NULL }
5202 : };
5203 :
5204 : static const struct ndr_interface_call winreg_calls[] = {
5205 : {
5206 : "winreg_OpenHKCR",
5207 : sizeof(struct winreg_OpenHKCR),
5208 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCR,
5209 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCR,
5210 : (ndr_print_function_t) ndr_print_winreg_OpenHKCR,
5211 : { 0, NULL },
5212 : { 0, NULL },
5213 : },
5214 : {
5215 : "winreg_OpenHKCU",
5216 : sizeof(struct winreg_OpenHKCU),
5217 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCU,
5218 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCU,
5219 : (ndr_print_function_t) ndr_print_winreg_OpenHKCU,
5220 : { 0, NULL },
5221 : { 0, NULL },
5222 : },
5223 : {
5224 : "winreg_OpenHKLM",
5225 : sizeof(struct winreg_OpenHKLM),
5226 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKLM,
5227 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKLM,
5228 : (ndr_print_function_t) ndr_print_winreg_OpenHKLM,
5229 : { 0, NULL },
5230 : { 0, NULL },
5231 : },
5232 : {
5233 : "winreg_OpenHKPD",
5234 : sizeof(struct winreg_OpenHKPD),
5235 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPD,
5236 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPD,
5237 : (ndr_print_function_t) ndr_print_winreg_OpenHKPD,
5238 : { 0, NULL },
5239 : { 0, NULL },
5240 : },
5241 : {
5242 : "winreg_OpenHKU",
5243 : sizeof(struct winreg_OpenHKU),
5244 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKU,
5245 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKU,
5246 : (ndr_print_function_t) ndr_print_winreg_OpenHKU,
5247 : { 0, NULL },
5248 : { 0, NULL },
5249 : },
5250 : {
5251 : "winreg_CloseKey",
5252 : sizeof(struct winreg_CloseKey),
5253 : (ndr_push_flags_fn_t) ndr_push_winreg_CloseKey,
5254 : (ndr_pull_flags_fn_t) ndr_pull_winreg_CloseKey,
5255 : (ndr_print_function_t) ndr_print_winreg_CloseKey,
5256 : { 0, NULL },
5257 : { 0, NULL },
5258 : },
5259 : {
5260 : "winreg_CreateKey",
5261 : sizeof(struct winreg_CreateKey),
5262 : (ndr_push_flags_fn_t) ndr_push_winreg_CreateKey,
5263 : (ndr_pull_flags_fn_t) ndr_pull_winreg_CreateKey,
5264 : (ndr_print_function_t) ndr_print_winreg_CreateKey,
5265 : { 0, NULL },
5266 : { 0, NULL },
5267 : },
5268 : {
5269 : "winreg_DeleteKey",
5270 : sizeof(struct winreg_DeleteKey),
5271 : (ndr_push_flags_fn_t) ndr_push_winreg_DeleteKey,
5272 : (ndr_pull_flags_fn_t) ndr_pull_winreg_DeleteKey,
5273 : (ndr_print_function_t) ndr_print_winreg_DeleteKey,
5274 : { 0, NULL },
5275 : { 0, NULL },
5276 : },
5277 : {
5278 : "winreg_DeleteValue",
5279 : sizeof(struct winreg_DeleteValue),
5280 : (ndr_push_flags_fn_t) ndr_push_winreg_DeleteValue,
5281 : (ndr_pull_flags_fn_t) ndr_pull_winreg_DeleteValue,
5282 : (ndr_print_function_t) ndr_print_winreg_DeleteValue,
5283 : { 0, NULL },
5284 : { 0, NULL },
5285 : },
5286 : {
5287 : "winreg_EnumKey",
5288 : sizeof(struct winreg_EnumKey),
5289 : (ndr_push_flags_fn_t) ndr_push_winreg_EnumKey,
5290 : (ndr_pull_flags_fn_t) ndr_pull_winreg_EnumKey,
5291 : (ndr_print_function_t) ndr_print_winreg_EnumKey,
5292 : { 0, NULL },
5293 : { 0, NULL },
5294 : },
5295 : {
5296 : "winreg_EnumValue",
5297 : sizeof(struct winreg_EnumValue),
5298 : (ndr_push_flags_fn_t) ndr_push_winreg_EnumValue,
5299 : (ndr_pull_flags_fn_t) ndr_pull_winreg_EnumValue,
5300 : (ndr_print_function_t) ndr_print_winreg_EnumValue,
5301 : { 0, NULL },
5302 : { 0, NULL },
5303 : },
5304 : {
5305 : "winreg_FlushKey",
5306 : sizeof(struct winreg_FlushKey),
5307 : (ndr_push_flags_fn_t) ndr_push_winreg_FlushKey,
5308 : (ndr_pull_flags_fn_t) ndr_pull_winreg_FlushKey,
5309 : (ndr_print_function_t) ndr_print_winreg_FlushKey,
5310 : { 0, NULL },
5311 : { 0, NULL },
5312 : },
5313 : {
5314 : "winreg_GetKeySecurity",
5315 : sizeof(struct winreg_GetKeySecurity),
5316 : (ndr_push_flags_fn_t) ndr_push_winreg_GetKeySecurity,
5317 : (ndr_pull_flags_fn_t) ndr_pull_winreg_GetKeySecurity,
5318 : (ndr_print_function_t) ndr_print_winreg_GetKeySecurity,
5319 : { 0, NULL },
5320 : { 0, NULL },
5321 : },
5322 : {
5323 : "winreg_LoadKey",
5324 : sizeof(struct winreg_LoadKey),
5325 : (ndr_push_flags_fn_t) ndr_push_winreg_LoadKey,
5326 : (ndr_pull_flags_fn_t) ndr_pull_winreg_LoadKey,
5327 : (ndr_print_function_t) ndr_print_winreg_LoadKey,
5328 : { 0, NULL },
5329 : { 0, NULL },
5330 : },
5331 : {
5332 : "winreg_NotifyChangeKeyValue",
5333 : sizeof(struct winreg_NotifyChangeKeyValue),
5334 : (ndr_push_flags_fn_t) ndr_push_winreg_NotifyChangeKeyValue,
5335 : (ndr_pull_flags_fn_t) ndr_pull_winreg_NotifyChangeKeyValue,
5336 : (ndr_print_function_t) ndr_print_winreg_NotifyChangeKeyValue,
5337 : { 0, NULL },
5338 : { 0, NULL },
5339 : },
5340 : {
5341 : "winreg_OpenKey",
5342 : sizeof(struct winreg_OpenKey),
5343 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenKey,
5344 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenKey,
5345 : (ndr_print_function_t) ndr_print_winreg_OpenKey,
5346 : { 0, NULL },
5347 : { 0, NULL },
5348 : },
5349 : {
5350 : "winreg_QueryInfoKey",
5351 : sizeof(struct winreg_QueryInfoKey),
5352 : (ndr_push_flags_fn_t) ndr_push_winreg_QueryInfoKey,
5353 : (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryInfoKey,
5354 : (ndr_print_function_t) ndr_print_winreg_QueryInfoKey,
5355 : { 0, NULL },
5356 : { 0, NULL },
5357 : },
5358 : {
5359 : "winreg_QueryValue",
5360 : sizeof(struct winreg_QueryValue),
5361 : (ndr_push_flags_fn_t) ndr_push_winreg_QueryValue,
5362 : (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryValue,
5363 : (ndr_print_function_t) ndr_print_winreg_QueryValue,
5364 : { 0, NULL },
5365 : { 0, NULL },
5366 : },
5367 : {
5368 : "winreg_ReplaceKey",
5369 : sizeof(struct winreg_ReplaceKey),
5370 : (ndr_push_flags_fn_t) ndr_push_winreg_ReplaceKey,
5371 : (ndr_pull_flags_fn_t) ndr_pull_winreg_ReplaceKey,
5372 : (ndr_print_function_t) ndr_print_winreg_ReplaceKey,
5373 : { 0, NULL },
5374 : { 0, NULL },
5375 : },
5376 : {
5377 : "winreg_RestoreKey",
5378 : sizeof(struct winreg_RestoreKey),
5379 : (ndr_push_flags_fn_t) ndr_push_winreg_RestoreKey,
5380 : (ndr_pull_flags_fn_t) ndr_pull_winreg_RestoreKey,
5381 : (ndr_print_function_t) ndr_print_winreg_RestoreKey,
5382 : { 0, NULL },
5383 : { 0, NULL },
5384 : },
5385 : {
5386 : "winreg_SaveKey",
5387 : sizeof(struct winreg_SaveKey),
5388 : (ndr_push_flags_fn_t) ndr_push_winreg_SaveKey,
5389 : (ndr_pull_flags_fn_t) ndr_pull_winreg_SaveKey,
5390 : (ndr_print_function_t) ndr_print_winreg_SaveKey,
5391 : { 0, NULL },
5392 : { 0, NULL },
5393 : },
5394 : {
5395 : "winreg_SetKeySecurity",
5396 : sizeof(struct winreg_SetKeySecurity),
5397 : (ndr_push_flags_fn_t) ndr_push_winreg_SetKeySecurity,
5398 : (ndr_pull_flags_fn_t) ndr_pull_winreg_SetKeySecurity,
5399 : (ndr_print_function_t) ndr_print_winreg_SetKeySecurity,
5400 : { 0, NULL },
5401 : { 0, NULL },
5402 : },
5403 : {
5404 : "winreg_SetValue",
5405 : sizeof(struct winreg_SetValue),
5406 : (ndr_push_flags_fn_t) ndr_push_winreg_SetValue,
5407 : (ndr_pull_flags_fn_t) ndr_pull_winreg_SetValue,
5408 : (ndr_print_function_t) ndr_print_winreg_SetValue,
5409 : { 0, NULL },
5410 : { 0, NULL },
5411 : },
5412 : {
5413 : "winreg_UnLoadKey",
5414 : sizeof(struct winreg_UnLoadKey),
5415 : (ndr_push_flags_fn_t) ndr_push_winreg_UnLoadKey,
5416 : (ndr_pull_flags_fn_t) ndr_pull_winreg_UnLoadKey,
5417 : (ndr_print_function_t) ndr_print_winreg_UnLoadKey,
5418 : { 0, NULL },
5419 : { 0, NULL },
5420 : },
5421 : {
5422 : "winreg_InitiateSystemShutdown",
5423 : sizeof(struct winreg_InitiateSystemShutdown),
5424 : (ndr_push_flags_fn_t) ndr_push_winreg_InitiateSystemShutdown,
5425 : (ndr_pull_flags_fn_t) ndr_pull_winreg_InitiateSystemShutdown,
5426 : (ndr_print_function_t) ndr_print_winreg_InitiateSystemShutdown,
5427 : { 0, NULL },
5428 : { 0, NULL },
5429 : },
5430 : {
5431 : "winreg_AbortSystemShutdown",
5432 : sizeof(struct winreg_AbortSystemShutdown),
5433 : (ndr_push_flags_fn_t) ndr_push_winreg_AbortSystemShutdown,
5434 : (ndr_pull_flags_fn_t) ndr_pull_winreg_AbortSystemShutdown,
5435 : (ndr_print_function_t) ndr_print_winreg_AbortSystemShutdown,
5436 : { 0, NULL },
5437 : { 0, NULL },
5438 : },
5439 : {
5440 : "winreg_GetVersion",
5441 : sizeof(struct winreg_GetVersion),
5442 : (ndr_push_flags_fn_t) ndr_push_winreg_GetVersion,
5443 : (ndr_pull_flags_fn_t) ndr_pull_winreg_GetVersion,
5444 : (ndr_print_function_t) ndr_print_winreg_GetVersion,
5445 : { 0, NULL },
5446 : { 0, NULL },
5447 : },
5448 : {
5449 : "winreg_OpenHKCC",
5450 : sizeof(struct winreg_OpenHKCC),
5451 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCC,
5452 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCC,
5453 : (ndr_print_function_t) ndr_print_winreg_OpenHKCC,
5454 : { 0, NULL },
5455 : { 0, NULL },
5456 : },
5457 : {
5458 : "winreg_OpenHKDD",
5459 : sizeof(struct winreg_OpenHKDD),
5460 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKDD,
5461 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKDD,
5462 : (ndr_print_function_t) ndr_print_winreg_OpenHKDD,
5463 : { 0, NULL },
5464 : { 0, NULL },
5465 : },
5466 : {
5467 : "winreg_QueryMultipleValues",
5468 : sizeof(struct winreg_QueryMultipleValues),
5469 : (ndr_push_flags_fn_t) ndr_push_winreg_QueryMultipleValues,
5470 : (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryMultipleValues,
5471 : (ndr_print_function_t) ndr_print_winreg_QueryMultipleValues,
5472 : { 0, NULL },
5473 : { 0, NULL },
5474 : },
5475 : {
5476 : "winreg_InitiateSystemShutdownEx",
5477 : sizeof(struct winreg_InitiateSystemShutdownEx),
5478 : (ndr_push_flags_fn_t) ndr_push_winreg_InitiateSystemShutdownEx,
5479 : (ndr_pull_flags_fn_t) ndr_pull_winreg_InitiateSystemShutdownEx,
5480 : (ndr_print_function_t) ndr_print_winreg_InitiateSystemShutdownEx,
5481 : { 0, NULL },
5482 : { 0, NULL },
5483 : },
5484 : {
5485 : "winreg_SaveKeyEx",
5486 : sizeof(struct winreg_SaveKeyEx),
5487 : (ndr_push_flags_fn_t) ndr_push_winreg_SaveKeyEx,
5488 : (ndr_pull_flags_fn_t) ndr_pull_winreg_SaveKeyEx,
5489 : (ndr_print_function_t) ndr_print_winreg_SaveKeyEx,
5490 : { 0, NULL },
5491 : { 0, NULL },
5492 : },
5493 : {
5494 : "winreg_OpenHKPT",
5495 : sizeof(struct winreg_OpenHKPT),
5496 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPT,
5497 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPT,
5498 : (ndr_print_function_t) ndr_print_winreg_OpenHKPT,
5499 : { 0, NULL },
5500 : { 0, NULL },
5501 : },
5502 : {
5503 : "winreg_OpenHKPN",
5504 : sizeof(struct winreg_OpenHKPN),
5505 : (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPN,
5506 : (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPN,
5507 : (ndr_print_function_t) ndr_print_winreg_OpenHKPN,
5508 : { 0, NULL },
5509 : { 0, NULL },
5510 : },
5511 : {
5512 : "winreg_QueryMultipleValues2",
5513 : sizeof(struct winreg_QueryMultipleValues2),
5514 : (ndr_push_flags_fn_t) ndr_push_winreg_QueryMultipleValues2,
5515 : (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryMultipleValues2,
5516 : (ndr_print_function_t) ndr_print_winreg_QueryMultipleValues2,
5517 : { 0, NULL },
5518 : { 0, NULL },
5519 : },
5520 : {
5521 : "winreg_DeleteKeyEx",
5522 : sizeof(struct winreg_DeleteKeyEx),
5523 : (ndr_push_flags_fn_t) ndr_push_winreg_DeleteKeyEx,
5524 : (ndr_pull_flags_fn_t) ndr_pull_winreg_DeleteKeyEx,
5525 : (ndr_print_function_t) ndr_print_winreg_DeleteKeyEx,
5526 : { 0, NULL },
5527 : { 0, NULL },
5528 : },
5529 : { .name = NULL }
5530 : };
5531 :
5532 : static const char * const winreg_endpoint_strings[] = {
5533 : "ncacn_np:[\\pipe\\winreg]",
5534 : "ncacn_ip_tcp:",
5535 : "ncalrpc:",
5536 : };
5537 :
5538 : static const struct ndr_interface_string_array winreg_endpoints = {
5539 : .count = 3,
5540 : .names = winreg_endpoint_strings
5541 : };
5542 :
5543 : static const char * const winreg_authservice_strings[] = {
5544 : "host",
5545 : };
5546 :
5547 : static const struct ndr_interface_string_array winreg_authservices = {
5548 : .count = 1,
5549 : .names = winreg_authservice_strings
5550 : };
5551 :
5552 :
5553 : const struct ndr_interface_table ndr_table_winreg = {
5554 : .name = "winreg",
5555 : .syntax_id = {
5556 : {0x338cd001,0x2244,0x31f1,{0xaa,0xaa},{0x90,0x00,0x38,0x00,0x10,0x03}},
5557 : NDR_WINREG_VERSION
5558 : },
5559 : .helpstring = NDR_WINREG_HELPSTRING,
5560 : .num_calls = 36,
5561 : .calls = winreg_calls,
5562 : .num_public_structs = 1,
5563 : .public_structs = winreg_public_structs,
5564 : .endpoints = &winreg_endpoints,
5565 : .authservices = &winreg_authservices
5566 : };
5567 :
5568 : #endif /* SKIP_NDR_TABLE_winreg */
|
