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