source: vendor/current/source3/librpc/gen_ndr/ndr_winreg.c@ 746

Last change on this file since 746 was 746, checked in by Silvan Scherrer, 12 years ago

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