/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- dcerpc_winreg_bind
- dcesrv_winreg_openhive
- func_winreg_OpenHive
- dcesrv_winreg_CreateKey
- dcesrv_winreg_DeleteKey
- dcesrv_winreg_DeleteValue
- dcesrv_winreg_EnumKey
- dcesrv_winreg_EnumValue
- dcesrv_winreg_FlushKey
- dcesrv_winreg_GetKeySecurity
- dcesrv_winreg_LoadKey
- dcesrv_winreg_NotifyChangeKeyValue
- dcesrv_winreg_OpenKey
- dcesrv_winreg_QueryInfoKey
- dcesrv_winreg_QueryValue
- dcesrv_winreg_ReplaceKey
- dcesrv_winreg_RestoreKey
- dcesrv_winreg_SaveKey
- dcesrv_winreg_SetKeySecurity
- dcesrv_winreg_SetValue
- dcesrv_winreg_UnLoadKey
- dcesrv_winreg_InitiateSystemShutdown
- dcesrv_winreg_AbortSystemShutdown
- dcesrv_winreg_GetVersion
- dcesrv_winreg_QueryMultipleValues
- dcesrv_winreg_InitiateSystemShutdownEx
- dcesrv_winreg_SaveKeyEx
- dcesrv_winreg_QueryMultipleValues2
1 /*
2 Unix SMB/CIFS implementation.
3
4 endpoint server for the winreg pipe
5
6 Copyright (C) 2004 Jelmer Vernooij, jelmer@samba.org
7 Copyright (C) 2008 Matthias Dieter Wallnöfer, mwallnoefer@yahoo.de
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "rpc_server/dcerpc_server.h"
25 #include "lib/registry/registry.h"
26 #include "librpc/gen_ndr/ndr_winreg.h"
27 #include "rpc_server/common/common.h"
28 #include "librpc/gen_ndr/ndr_security.h"
29 #include "param/param.h"
30 #include "libcli/security/security.h"
31
32 enum handle_types { HTYPE_REGVAL, HTYPE_REGKEY };
33
34 static NTSTATUS dcerpc_winreg_bind(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
35 const struct dcesrv_interface *iface)
36 {
37 struct registry_context *ctx;
38 WERROR err;
39
40 err = reg_open_samba(dce_call->context,
41 &ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info,
42 NULL);
43
44 if (!W_ERROR_IS_OK(err)) {
45 DEBUG(0, ("Error opening registry: %s\n", win_errstr(err)));
46 return NT_STATUS_UNSUCCESSFUL;
47 }
48
49 dce_call->context->private_data = ctx;
50
51 return NT_STATUS_OK;
52 }
53
54 #define DCESRV_INTERFACE_WINREG_BIND dcerpc_winreg_bind
55
56 static WERROR dcesrv_winreg_openhive(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
57 TALLOC_CTX *mem_ctx, uint32_t hkey,
58 struct policy_handle **outh)
59 {
60 struct registry_context *ctx = dce_call->context->private_data;
61 struct dcesrv_handle *h;
62 WERROR result;
63
64 h = dcesrv_handle_new(dce_call->context, HTYPE_REGKEY);
65
66 result = reg_get_predefined_key(ctx, hkey,
67 (struct registry_key **)&h->data);
68 if (!W_ERROR_IS_OK(result)) {
69 return result;
70 }
71 *outh = &h->wire_handle;
72
73 return result;
74 }
75
76 #define func_winreg_OpenHive(k,n) static WERROR dcesrv_winreg_Open ## k (struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct winreg_Open ## k *r) \
77 { \
78 return dcesrv_winreg_openhive (dce_call, mem_ctx, n, &r->out.handle);\
79 }
80
81 func_winreg_OpenHive(HKCR,HKEY_CLASSES_ROOT)
/* [<][>][^][v][top][bottom][index][help] */
82 func_winreg_OpenHive(HKCU,HKEY_CURRENT_USER)
83 func_winreg_OpenHive(HKLM,HKEY_LOCAL_MACHINE)
84 func_winreg_OpenHive(HKPD,HKEY_PERFORMANCE_DATA)
85 func_winreg_OpenHive(HKU,HKEY_USERS)
86 func_winreg_OpenHive(HKCC,HKEY_CURRENT_CONFIG)
87 func_winreg_OpenHive(HKDD,HKEY_DYN_DATA)
88 func_winreg_OpenHive(HKPT,HKEY_PERFORMANCE_TEXT)
89 func_winreg_OpenHive(HKPN,HKEY_PERFORMANCE_NLSTEXT)
90
91 /*
92 winreg_CloseKey
93 */
94 static WERROR dcesrv_winreg_CloseKey(struct dcesrv_call_state *dce_call,
95 TALLOC_CTX *mem_ctx,
96 struct winreg_CloseKey *r)
97 {
98 struct dcesrv_handle *h;
99
100 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
101
102 talloc_free(h);
103
104 ZERO_STRUCTP(r->out.handle);
105
106 return WERR_OK;
107 }
108
109 /*
110 winreg_CreateKey
111 */
112 static WERROR dcesrv_winreg_CreateKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
113 TALLOC_CTX *mem_ctx,
114 struct winreg_CreateKey *r)
115 {
116 struct dcesrv_handle *h, *newh;
117 struct security_descriptor sd;
118 struct registry_key *key;
119 WERROR result;
120
121 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
122 key = h->data;
123
124 newh = dcesrv_handle_new(dce_call->context, HTYPE_REGKEY);
125
126 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
127 {
128 case SECURITY_SYSTEM:
129 case SECURITY_ADMINISTRATOR:
130 /* the security descriptor is optional */
131 if (r->in.secdesc != NULL) {
132 DATA_BLOB sdblob;
133 enum ndr_err_code ndr_err;
134 sdblob.data = r->in.secdesc->sd.data;
135 sdblob.length = r->in.secdesc->sd.len;
136 if (sdblob.data == NULL) {
137 return WERR_INVALID_PARAM;
138 }
139 ndr_err = ndr_pull_struct_blob_all(&sdblob, mem_ctx, NULL, &sd,
140 (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
141 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
142 return WERR_INVALID_PARAM;
143 }
144 }
145
146 result = reg_key_add_name(newh, key, r->in.name.name, NULL,
147 r->in.secdesc?&sd:NULL, (struct registry_key **)&newh->data);
148 if (W_ERROR_IS_OK(result)) {
149 r->out.new_handle = &newh->wire_handle;
150 } else {
151 talloc_free(newh);
152 }
153
154 return result;
155 default:
156 return WERR_ACCESS_DENIED;
157 }
158 }
159
160
161 /*
162 winreg_DeleteKey
163 */
164 static WERROR dcesrv_winreg_DeleteKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
165 TALLOC_CTX *mem_ctx,
166 struct winreg_DeleteKey *r)
167 {
168 struct dcesrv_handle *h;
169 struct registry_key *key;
170
171 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
172 key = h->data;
173
174 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
175 {
176 case SECURITY_SYSTEM:
177 case SECURITY_ADMINISTRATOR:
178 return reg_key_del(key, r->in.key.name);
179 default:
180 return WERR_ACCESS_DENIED;
181 }
182 }
183
184
185 /*
186 winreg_DeleteValue
187 */
188 static WERROR dcesrv_winreg_DeleteValue(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
189 TALLOC_CTX *mem_ctx,
190 struct winreg_DeleteValue *r)
191 {
192 struct dcesrv_handle *h;
193 struct registry_key *key;
194
195 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
196 key = h->data;
197
198 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
199 {
200 case SECURITY_SYSTEM:
201 case SECURITY_ADMINISTRATOR:
202 return reg_del_value(key, r->in.value.name);
203 default:
204 return WERR_ACCESS_DENIED;
205 }
206 }
207
208
209 /*
210 winreg_EnumKey
211 */
212 static WERROR dcesrv_winreg_EnumKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
213 TALLOC_CTX *mem_ctx,
214 struct winreg_EnumKey *r)
215 {
216 struct dcesrv_handle *h;
217 struct registry_key *key;
218 const char *name, *classname;
219 NTTIME last_mod;
220 WERROR result;
221
222 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
223 key = h->data;
224
225 result = reg_key_get_subkey_by_index(mem_ctx,
226 key, r->in.enum_index, &name, &classname, &last_mod);
227
228 if (2*strlen_m_term(name) > r->in.name->size) {
229 return WERR_MORE_DATA;
230 }
231
232 if (name != NULL) {
233 r->out.name->name = name;
234 r->out.name->length = 2*strlen_m_term(name);
235 } else {
236 r->out.name->name = r->in.name->name;
237 r->out.name->length = r->in.name->length;
238 }
239 r->out.name->size = r->in.name->size;
240
241 r->out.keyclass = r->in.keyclass;
242 if (classname != NULL) {
243 r->out.keyclass->name = classname;
244 r->out.keyclass->length = 2*strlen_m_term(classname);
245 } else {
246 r->out.keyclass->name = r->in.keyclass->name;
247 r->out.keyclass->length = r->in.keyclass->length;
248 }
249 r->out.keyclass->size = r->in.keyclass->size;
250
251 if (r->in.last_changed_time != NULL)
252 r->out.last_changed_time = &last_mod;
253
254 return result;
255 }
256
257
258 /*
259 winreg_EnumValue
260 */
261 static WERROR dcesrv_winreg_EnumValue(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
262 TALLOC_CTX *mem_ctx,
263 struct winreg_EnumValue *r)
264 {
265 struct dcesrv_handle *h;
266 struct registry_key *key;
267 const char *data_name;
268 uint32_t data_type;
269 DATA_BLOB data;
270 WERROR result;
271
272 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
273 key = h->data;
274
275 result = reg_key_get_value_by_index(mem_ctx, key,
276 r->in.enum_index, &data_name, &data_type, &data);
277
278 if (!W_ERROR_IS_OK(result)) {
279 /* if the lookup wasn't successful, send client query back */
280 data_name = r->in.name->name;
281 data_type = *r->in.type;
282 data.data = r->in.value;
283 data.length = *r->in.length;
284 }
285
286 /* check if there is enough room for the name */
287 if (r->in.name->size < 2*strlen_m_term(data_name)) {
288 return WERR_MORE_DATA;
289 }
290
291 /* "data_name" is NULL when we query the default attribute */
292 if (data_name != NULL) {
293 r->out.name->name = data_name;
294 r->out.name->length = 2*strlen_m_term(data_name);
295 } else {
296 r->out.name->name = r->in.name->name;
297 r->out.name->length = r->in.name->length;
298 }
299 r->out.name->size = r->in.name->size;
300
301 r->out.type = talloc(mem_ctx, uint32_t);
302 if (!r->out.type) {
303 return WERR_NOMEM;
304 }
305 *r->out.type = data_type;
306
307 /* check the client has enough room for the value */
308 if (r->in.value != NULL &&
309 r->in.size != NULL &&
310 data.length > *r->in.size) {
311 return WERR_MORE_DATA;
312 }
313
314 if (r->in.value != NULL) {
315 r->out.value = data.data;
316 }
317
318 if (r->in.size != NULL) {
319 r->out.size = talloc(mem_ctx, uint32_t);
320 *r->out.size = data.length;
321 r->out.length = r->out.size;
322 }
323
324 return result;
325 }
326
327
328 /*
329 winreg_FlushKey
330 */
331 static WERROR dcesrv_winreg_FlushKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
332 TALLOC_CTX *mem_ctx,
333 struct winreg_FlushKey *r)
334 {
335 struct dcesrv_handle *h;
336 struct registry_key *key;
337
338 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
339 key = h->data;
340
341 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
342 {
343 case SECURITY_SYSTEM:
344 case SECURITY_ADMINISTRATOR:
345 return reg_key_flush(key);
346 default:
347 return WERR_ACCESS_DENIED;
348 }
349 }
350
351
352 /*
353 winreg_GetKeySecurity
354 */
355 static WERROR dcesrv_winreg_GetKeySecurity(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
356 TALLOC_CTX *mem_ctx,
357 struct winreg_GetKeySecurity *r)
358 {
359 struct dcesrv_handle *h;
360
361 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
362
363 return WERR_NOT_SUPPORTED;
364 }
365
366
367 /*
368 winreg_LoadKey
369 */
370 static WERROR dcesrv_winreg_LoadKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
371 TALLOC_CTX *mem_ctx,
372 struct winreg_LoadKey *r)
373 {
374 return WERR_NOT_SUPPORTED;
375 }
376
377
378 /*
379 winreg_NotifyChangeKeyValue
380 */
381 static WERROR dcesrv_winreg_NotifyChangeKeyValue(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
382 TALLOC_CTX *mem_ctx,
383 struct winreg_NotifyChangeKeyValue *r)
384 {
385 return WERR_NOT_SUPPORTED;
386 }
387
388
389 /*
390 winreg_OpenKey
391 */
392 static WERROR dcesrv_winreg_OpenKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
393 TALLOC_CTX *mem_ctx,
394 struct winreg_OpenKey *r)
395 {
396 struct dcesrv_handle *h, *newh;
397 struct registry_key *key;
398 WERROR result;
399
400 DCESRV_PULL_HANDLE_FAULT(h, r->in.parent_handle, HTYPE_REGKEY);
401 key = h->data;
402
403 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
404 {
405 case SECURITY_SYSTEM:
406 case SECURITY_ADMINISTRATOR:
407 case SECURITY_USER:
408 if (r->in.keyname.name && strcmp(r->in.keyname.name, "") == 0) {
409 newh = talloc_reference(dce_call->context, h);
410 result = WERR_OK;
411 } else {
412 newh = dcesrv_handle_new(dce_call->context, HTYPE_REGKEY);
413 result = reg_open_key(newh, key, r->in.keyname.name,
414 (struct registry_key **)&newh->data);
415 }
416
417 if (W_ERROR_IS_OK(result)) {
418 r->out.handle = &newh->wire_handle;
419 } else {
420 talloc_free(newh);
421 }
422 return result;
423 default:
424 return WERR_ACCESS_DENIED;
425 }
426
427 }
428
429
430 /*
431 winreg_QueryInfoKey
432 */
433 static WERROR dcesrv_winreg_QueryInfoKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
434 TALLOC_CTX *mem_ctx,
435 struct winreg_QueryInfoKey *r)
436 {
437 struct dcesrv_handle *h;
438 struct registry_key *key;
439 const char *classname = NULL;
440 WERROR result;
441
442 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
443 key = h->data;
444
445 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
446 {
447 case SECURITY_SYSTEM:
448 case SECURITY_ADMINISTRATOR:
449 case SECURITY_USER:
450 result = reg_key_get_info(mem_ctx, key, &classname,
451 r->out.num_subkeys, r->out.num_values,
452 r->out.last_changed_time, r->out.max_subkeylen,
453 r->out.max_valnamelen, r->out.max_valbufsize);
454
455 if (classname != NULL) {
456 r->out.classname->name = classname;
457 r->out.classname->name_len = 2*strlen_m_term(classname);
458 } else {
459 r->out.classname->name = r->in.classname->name;
460 r->out.classname->name_len = r->in.classname->name_len;
461 }
462 r->out.classname->name_size = r->in.classname->name_size;
463
464 return result;
465 default:
466 return WERR_ACCESS_DENIED;
467 }
468 }
469
470
471 /*
472 winreg_QueryValue
473 */
474 static WERROR dcesrv_winreg_QueryValue(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
475 TALLOC_CTX *mem_ctx,
476 struct winreg_QueryValue *r)
477 {
478 struct dcesrv_handle *h;
479 struct registry_key *key;
480 uint32_t value_type;
481 DATA_BLOB value_data;
482 WERROR result;
483
484 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
485 key = h->data;
486
487 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
488 {
489 case SECURITY_SYSTEM:
490 case SECURITY_ADMINISTRATOR:
491 case SECURITY_USER:
492 result = reg_key_get_value_by_name(mem_ctx, key,
493 r->in.value_name->name, &value_type, &value_data);
494
495 if (!W_ERROR_IS_OK(result)) {
496 /* if the lookup wasn't successful, send client query back */
497 value_type = *r->in.type;
498 value_data.data = r->in.data;
499 value_data.length = *r->in.data_length;
500 }
501
502 r->out.type = talloc(mem_ctx, uint32_t);
503 if (!r->out.type) {
504 return WERR_NOMEM;
505 }
506 *r->out.type = value_type;
507 r->out.data_length = talloc(mem_ctx, uint32_t);
508 if (!r->out.data_length) {
509 return WERR_NOMEM;
510 }
511 *r->out.data_length = value_data.length;
512 r->out.data_size = talloc(mem_ctx, uint32_t);
513 if (!r->out.data_size) {
514 return WERR_NOMEM;
515 }
516 *r->out.data_size = value_data.length;
517 r->out.data = value_data.data;
518
519 return result;
520 default:
521 return WERR_ACCESS_DENIED;
522 }
523 }
524
525
526 /*
527 winreg_ReplaceKey
528 */
529 static WERROR dcesrv_winreg_ReplaceKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
530 TALLOC_CTX *mem_ctx,
531 struct winreg_ReplaceKey *r)
532 {
533 return WERR_NOT_SUPPORTED;
534 }
535
536
537 /*
538 winreg_RestoreKey
539 */
540 static WERROR dcesrv_winreg_RestoreKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
541 TALLOC_CTX *mem_ctx,
542 struct winreg_RestoreKey *r)
543 {
544 return WERR_NOT_SUPPORTED;
545 }
546
547
548 /*
549 winreg_SaveKey
550 */
551 static WERROR dcesrv_winreg_SaveKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
552 TALLOC_CTX *mem_ctx,
553 struct winreg_SaveKey *r)
554 {
555 return WERR_NOT_SUPPORTED;
556 }
557
558
559 /*
560 winreg_SetKeySecurity
561 */
562 static WERROR dcesrv_winreg_SetKeySecurity(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
563 TALLOC_CTX *mem_ctx,
564 struct winreg_SetKeySecurity *r)
565 {
566 return WERR_NOT_SUPPORTED;
567 }
568
569
570 /*
571 winreg_SetValue
572 */
573 static WERROR dcesrv_winreg_SetValue(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
574 TALLOC_CTX *mem_ctx,
575 struct winreg_SetValue *r)
576 {
577 struct dcesrv_handle *h;
578 struct registry_key *key;
579 DATA_BLOB data;
580 WERROR result;
581
582 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
583 key = h->data;
584
585 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
586 {
587 case SECURITY_SYSTEM:
588 case SECURITY_ADMINISTRATOR:
589 data.data = r->in.data;
590 data.length = r->in.size;
591 result = reg_val_set(key, r->in.name.name, r->in.type, data);
592 return result;
593 default:
594 return WERR_ACCESS_DENIED;
595 }
596 }
597
598
599 /*
600 winreg_UnLoadKey
601 */
602 static WERROR dcesrv_winreg_UnLoadKey(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
603 TALLOC_CTX *mem_ctx,
604 struct winreg_UnLoadKey *r)
605 {
606 return WERR_NOT_SUPPORTED;
607 }
608
609
610 /*
611 winreg_InitiateSystemShutdown
612 */
613 static WERROR dcesrv_winreg_InitiateSystemShutdown(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
614 TALLOC_CTX *mem_ctx,
615 struct winreg_InitiateSystemShutdown *r)
616 {
617 return WERR_NOT_SUPPORTED;
618 }
619
620
621 /*
622 winreg_AbortSystemShutdown
623 */
624 static WERROR dcesrv_winreg_AbortSystemShutdown(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
625 TALLOC_CTX *mem_ctx,
626 struct winreg_AbortSystemShutdown *r)
627 {
628 return WERR_NOT_SUPPORTED;
629 }
630
631
632 /*
633 winreg_GetVersion
634 */
635 static WERROR dcesrv_winreg_GetVersion(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
636 TALLOC_CTX *mem_ctx,
637 struct winreg_GetVersion *r)
638 {
639 struct dcesrv_handle *h;
640
641 DCESRV_PULL_HANDLE_FAULT(h, r->in.handle, HTYPE_REGKEY);
642
643 r->out.version = talloc(mem_ctx, uint32_t);
644 W_ERROR_HAVE_NO_MEMORY(r->out.version);
645
646 *r->out.version = 5;
647
648 return WERR_OK;
649 }
650
651
652 /*
653 winreg_QueryMultipleValues
654 */
655 static WERROR dcesrv_winreg_QueryMultipleValues(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
656 TALLOC_CTX *mem_ctx,
657 struct winreg_QueryMultipleValues *r)
658 {
659 return WERR_NOT_SUPPORTED;
660 }
661
662
663 /*
664 winreg_InitiateSystemShutdownEx
665 */
666 static WERROR dcesrv_winreg_InitiateSystemShutdownEx(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
667 TALLOC_CTX *mem_ctx,
668 struct winreg_InitiateSystemShutdownEx *r)
669 {
670 return WERR_NOT_SUPPORTED;
671 }
672
673
674 /*
675 winreg_SaveKeyEx
676 */
677 static WERROR dcesrv_winreg_SaveKeyEx(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
678 TALLOC_CTX *mem_ctx,
679 struct winreg_SaveKeyEx *r)
680 {
681 return WERR_NOT_SUPPORTED;
682 }
683
684
685 /*
686 winreg_QueryMultipleValues2
687 */
688 static WERROR dcesrv_winreg_QueryMultipleValues2(struct dcesrv_call_state *dce_call,
/* [<][>][^][v][top][bottom][index][help] */
689 TALLOC_CTX *mem_ctx,
690 struct winreg_QueryMultipleValues2 *r)
691 {
692 return WERR_NOT_SUPPORTED;
693 }
694
695
696 /* include the generated boilerplate */
697 #include "librpc/gen_ndr/ndr_winreg_s.c"