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