source: vendor/current/librpc/gen_ndr/ndr_winreg.c@ 427

Last change on this file since 427 was 427, checked in by Silvan Scherrer, 15 years ago

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