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