Context Navigation

source: trunk/server/source3/rpc_server/srv_winreg_nt.c@ 590

Visit:

Last change on this file since 590 was 590, checked in by Herwig Bauernfeind, 14 years ago
Samba 3.5: Update trunk to 3.5.6
File size: 27.6 KB

Line
1	/*
2	* Unix SMB/CIFS implementation.
3	* RPC Pipe client / server routines
4	*
5	* Copyright (C) Gerald Carter 2002-2006.
6	*
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 3 of the License, or
10	* (at your option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, see <http://www.gnu.org/licenses/>.
19	*/
20
21	/* Implementation of registry functions. */
22
23	#include "includes.h"
24	#include "../librpc/gen_ndr/srv_winreg.h"
25
26	#undef DBGC_CLASS
27	#define DBGC_CLASS DBGC_RPC_SRV
28
29	/******************************************************************
30	Find a registry key handle and return a struct registry_key *
31	*****************************************************************/
32
33	static struct registry_key find_regkey_by_hnd(pipes_struct p,
34	struct policy_handle *hnd)
35	{
36	struct registry_key *regkey = NULL;
37
38	if(!find_policy_by_hnd(p,hnd,(void *)(void )&regkey)) {
39	DEBUG(2,("find_regkey_index_by_hnd: Registry Key not found: "));
40	return NULL;
41	}
42
43	return regkey;
44	}
45
46	/*******************************************************************
47	Function for open a new registry handle and creating a handle
48	Note that P should be valid & hnd should already have space
49
50	When we open a key, we store the full path to the key as
51	HK[LM\|U]\<key>\<key>\...
52	*******************************************************************/
53
54	static WERROR open_registry_key( pipes_struct p, struct policy_handle hnd,
55	struct registry_key *parent,
56	const char *subkeyname,
57	uint32 access_desired )
58	{
59	WERROR result = WERR_OK;
60	struct registry_key *key;
61
62	if (parent == NULL) {
63	result = reg_openhive(p->mem_ctx, subkeyname, access_desired,
64	p->server_info->ptok, &key);
65	}
66	else {
67	result = reg_openkey(p->mem_ctx, parent, subkeyname,
68	access_desired, &key);
69	}
70
71	if ( !W_ERROR_IS_OK(result) ) {
72	return result;
73	}
74
75	if ( !create_policy_hnd( p, hnd, key ) ) {
76	return WERR_BADFILE;
77	}
78
79	return WERR_OK;
80	}
81
82	/*******************************************************************
83	Function for open a new registry handle and creating a handle
84	Note that P should be valid & hnd should already have space
85	*******************************************************************/
86
87	static bool close_registry_key(pipes_struct p, struct policy_handle hnd)
88	{
89	struct registry_key *regkey = find_regkey_by_hnd(p, hnd);
90
91	if ( !regkey ) {
92	DEBUG(2,("close_registry_key: Invalid handle (%s:%u:%u)\n",
93	OUR_HANDLE(hnd)));
94	return False;
95	}
96
97	close_policy_hnd(p, hnd);
98
99	return True;
100	}
101
102	/********************************************************************
103	_winreg_CloseKey
104	********************************************************************/
105
106	WERROR _winreg_CloseKey(pipes_struct p, struct winreg_CloseKey r)
107	{
108	/* close the policy handle */
109
110	if (!close_registry_key(p, r->in.handle))
111	return WERR_BADFID;
112
113	ZERO_STRUCTP(r->out.handle);
114
115	return WERR_OK;
116	}
117
118	/*******************************************************************
119	_winreg_OpenHKLM
120	********************************************************************/
121
122	WERROR _winreg_OpenHKLM(pipes_struct p, struct winreg_OpenHKLM r)
123	{
124	return open_registry_key(p, r->out.handle, NULL, KEY_HKLM, r->in.access_mask);
125	}
126
127	/*******************************************************************
128	_winreg_OpenHKPD
129	********************************************************************/
130
131	WERROR _winreg_OpenHKPD(pipes_struct p, struct winreg_OpenHKPD r)
132	{
133	return open_registry_key(p, r->out.handle, NULL, KEY_HKPD, r->in.access_mask);
134	}
135
136	/*******************************************************************
137	_winreg_OpenHKPT
138	********************************************************************/
139
140	WERROR _winreg_OpenHKPT(pipes_struct p, struct winreg_OpenHKPT r)
141	{
142	return open_registry_key(p, r->out.handle, NULL, KEY_HKPT, r->in.access_mask);
143	}
144
145	/*******************************************************************
146	_winreg_OpenHKCR
147	********************************************************************/
148
149	WERROR _winreg_OpenHKCR(pipes_struct p, struct winreg_OpenHKCR r)
150	{
151	return open_registry_key(p, r->out.handle, NULL, KEY_HKCR, r->in.access_mask);
152	}
153
154	/*******************************************************************
155	_winreg_OpenHKU
156	********************************************************************/
157
158	WERROR _winreg_OpenHKU(pipes_struct p, struct winreg_OpenHKU r)
159	{
160	return open_registry_key(p, r->out.handle, NULL, KEY_HKU, r->in.access_mask);
161	}
162
163	/*******************************************************************
164	_winreg_OpenHKCU
165	********************************************************************/
166
167	WERROR _winreg_OpenHKCU(pipes_struct p, struct winreg_OpenHKCU r)
168	{
169	return open_registry_key(p, r->out.handle, NULL, KEY_HKCU, r->in.access_mask);
170	}
171
172	/*******************************************************************
173	_winreg_OpenHKCC
174	********************************************************************/
175
176	WERROR _winreg_OpenHKCC(pipes_struct p, struct winreg_OpenHKCC r)
177	{
178	return open_registry_key(p, r->out.handle, NULL, KEY_HKCC, r->in.access_mask);
179	}
180
181	/*******************************************************************
182	_winreg_OpenHKDD
183	********************************************************************/
184
185	WERROR _winreg_OpenHKDD(pipes_struct p, struct winreg_OpenHKDD r)
186	{
187	return open_registry_key(p, r->out.handle, NULL, KEY_HKDD, r->in.access_mask);
188	}
189
190	/*******************************************************************
191	_winreg_OpenHKPN
192	********************************************************************/
193
194	WERROR _winreg_OpenHKPN(pipes_struct p, struct winreg_OpenHKPN r)
195	{
196	return open_registry_key(p, r->out.handle, NULL, KEY_HKPN, r->in.access_mask);
197	}
198
199	/*******************************************************************
200	_winreg_OpenKey
201	********************************************************************/
202
203	WERROR _winreg_OpenKey(pipes_struct p, struct winreg_OpenKey r)
204	{
205	struct registry_key *parent = find_regkey_by_hnd(p, r->in.parent_handle );
206
207	if ( !parent )
208	return WERR_BADFID;
209
210	return open_registry_key(p, r->out.handle, parent, r->in.keyname.name, r->in.access_mask);
211	}
212
213	/*******************************************************************
214	_winreg_QueryValue
215	********************************************************************/
216
217	WERROR _winreg_QueryValue(pipes_struct p, struct winreg_QueryValue r)
218	{
219	WERROR status = WERR_BADFILE;
220	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
221	prs_struct prs_hkpd;
222
223	uint8_t *outbuf = NULL;
224	uint32_t outbuf_size = 0;
225
226	DATA_BLOB val_blob;
227	bool free_buf = False;
228	bool free_prs = False;
229
230	if ( !regkey )
231	return WERR_BADFID;
232
233	if (r->in.value_name->name == NULL) {
234	return WERR_INVALID_PARAM;
235	}
236
237	if ((r->out.data_length == NULL) \|\| (r->out.type == NULL) \|\| (r->out.data_size == NULL)) {
238	return WERR_INVALID_PARAM;
239	}
240
241	DEBUG(7,("_winreg_QueryValue: policy key name = [%s]\n", regkey->key->name));
242	DEBUG(7,("_winreg_QueryValue: policy key type = [%08x]\n", regkey->key->type));
243
244	/* Handle QueryValue calls on HKEY_PERFORMANCE_DATA */
245	if(regkey->key->type == REG_KEY_HKPD)
246	{
247	if (strequal(r->in.value_name->name, "Global")) {
248	if (!prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL))
249	return WERR_NOMEM;
250	status = reg_perfcount_get_hkpd(
251	&prs_hkpd, *r->in.data_size, &outbuf_size, NULL);
252	outbuf = (uint8_t *)prs_hkpd.data_p;
253	free_prs = True;
254	}
255	else if (strequal(r->in.value_name->name, "Counter 009")) {
256	outbuf_size = reg_perfcount_get_counter_names(
257	reg_perfcount_get_base_index(),
258	(char *)(void )&outbuf);
259	free_buf = True;
260	}
261	else if (strequal(r->in.value_name->name, "Explain 009")) {
262	outbuf_size = reg_perfcount_get_counter_help(
263	reg_perfcount_get_base_index(),
264	(char *)(void )&outbuf);
265	free_buf = True;
266	}
267	else if (isdigit(r->in.value_name->name[0])) {
268	/* we probably have a request for a specific object
269	* here */
270	if (!prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL))
271	return WERR_NOMEM;
272	status = reg_perfcount_get_hkpd(
273	&prs_hkpd, *r->in.data_size, &outbuf_size,
274	r->in.value_name->name);
275	outbuf = (uint8_t *)prs_hkpd.data_p;
276	free_prs = True;
277	}
278	else {
279	DEBUG(3,("Unsupported key name [%s] for HKPD.\n",
280	r->in.value_name->name));
281	return WERR_BADFILE;
282	}
283
284	*r->out.type = REG_BINARY;
285	}
286	else {
287	struct registry_value *val;
288
289	status = reg_queryvalue(p->mem_ctx, regkey, r->in.value_name->name,
290	&val);
291	if (!W_ERROR_IS_OK(status)) {
292
293	DEBUG(10,("_winreg_QueryValue: reg_queryvalue failed with: %s\n",
294	win_errstr(status)));
295
296	if (r->out.data_size) {
297	*r->out.data_size = 0;
298	}
299	if (r->out.data_length) {
300	*r->out.data_length = 0;
301	}
302	return status;
303	}
304
305	status = registry_push_value(p->mem_ctx, val, &val_blob);
306	if (!W_ERROR_IS_OK(status)) {
307	return status;
308	}
309
310	outbuf = val_blob.data;
311	outbuf_size = val_blob.length;
312	*r->out.type = val->type;
313	}
314
315	status = WERR_BADFILE;
316
317	if (*r->in.data_size < outbuf_size) {
318	*r->out.data_size = outbuf_size;
319	status = r->in.data ? WERR_MORE_DATA : WERR_OK;
320	} else {
321	*r->out.data_length = outbuf_size;
322	*r->out.data_size = outbuf_size;
323	if (r->out.data) {
324	memcpy(r->out.data, outbuf, outbuf_size);
325	}
326	status = WERR_OK;
327	}
328
329	if (free_prs) prs_mem_free(&prs_hkpd);
330	if (free_buf) SAFE_FREE(outbuf);
331
332	return status;
333	}
334
335	/*****************************************************************************
336	_winreg_QueryInfoKey
337	****************************************************************************/
338
339	WERROR _winreg_QueryInfoKey(pipes_struct p, struct winreg_QueryInfoKey r)
340	{
341	WERROR status = WERR_OK;
342	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
343
344	if ( !regkey )
345	return WERR_BADFID;
346
347	r->out.classname->name = NULL;
348
349	status = reg_queryinfokey(regkey, r->out.num_subkeys, r->out.max_subkeylen,
350	r->out.max_classlen, r->out.num_values, r->out.max_valnamelen,
351	r->out.max_valbufsize, r->out.secdescsize,
352	r->out.last_changed_time);
353	if (!W_ERROR_IS_OK(status)) {
354	return status;
355	}
356
357	/*
358	* These calculations account for the registry buffers being
359	* UTF-16. They are inexact at best, but so far they worked.
360	*/
361
362	r->out.max_subkeylen = 2;
363
364	*r->out.max_valnamelen += 1;
365	r->out.max_valnamelen = 2;
366
367	return WERR_OK;
368	}
369
370
371	/*****************************************************************************
372	_winreg_GetVersion
373	****************************************************************************/
374
375	WERROR _winreg_GetVersion(pipes_struct p, struct winreg_GetVersion r)
376	{
377	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
378
379	if ( !regkey )
380	return WERR_BADFID;
381
382	return reg_getversion(r->out.version);
383	}
384
385
386	/*****************************************************************************
387	_winreg_EnumKey
388	****************************************************************************/
389
390	WERROR _winreg_EnumKey(pipes_struct p, struct winreg_EnumKey r)
391	{
392	WERROR err;
393	struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
394
395	if ( !key )
396	return WERR_BADFID;
397
398	if ( !r->in.name \|\| !r->in.keyclass )
399	return WERR_INVALID_PARAM;
400
401	DEBUG(8,("_reg_enum_key: enumerating key [%s]\n", key->key->name));
402
403	err = reg_enumkey(p->mem_ctx, key, r->in.enum_index, (char **)&r->out.name->name,
404	r->out.last_changed_time);
405	if (!W_ERROR_IS_OK(err)) {
406	return err;
407	}
408	r->out.keyclass->name = "";
409	return WERR_OK;
410	}
411
412	/*****************************************************************************
413	_winreg_EnumValue
414	****************************************************************************/
415
416	WERROR _winreg_EnumValue(pipes_struct p, struct winreg_EnumValue r)
417	{
418	WERROR err;
419	struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
420	char *valname;
421	struct registry_value *val;
422	DATA_BLOB value_blob;
423
424	if ( !key )
425	return WERR_BADFID;
426
427	if ( !r->in.name )
428	return WERR_INVALID_PARAM;
429
430	DEBUG(8,("_winreg_EnumValue: enumerating values for key [%s]\n",
431	key->key->name));
432
433	err = reg_enumvalue(p->mem_ctx, key, r->in.enum_index, &valname, &val);
434	if (!W_ERROR_IS_OK(err)) {
435	return err;
436	}
437
438	err = registry_push_value(p->mem_ctx, val, &value_blob);
439	if (!W_ERROR_IS_OK(err)) {
440	return err;
441	}
442
443	if (r->out.name != NULL) {
444	r->out.name->name = valname;
445	}
446
447	if (r->out.type != NULL) {
448	*r->out.type = val->type;
449	}
450
451	if (r->out.value != NULL) {
452	if ((r->out.size == NULL) \|\| (r->out.length == NULL)) {
453	return WERR_INVALID_PARAM;
454	}
455
456	if (value_blob.length > *r->out.size) {
457	return WERR_MORE_DATA;
458	}
459
460	memcpy( r->out.value, value_blob.data, value_blob.length );
461	}
462
463	if (r->out.length != NULL) {
464	*r->out.length = value_blob.length;
465	}
466	if (r->out.size != NULL) {
467	*r->out.size = value_blob.length;
468	}
469
470	return WERR_OK;
471	}
472
473	/*******************************************************************
474	_winreg_InitiateSystemShutdown
475	********************************************************************/
476
477	WERROR _winreg_InitiateSystemShutdown(pipes_struct p, struct winreg_InitiateSystemShutdown r)
478	{
479	struct winreg_InitiateSystemShutdownEx s;
480
481	s.in.hostname = r->in.hostname;
482	s.in.message = r->in.message;
483	s.in.timeout = r->in.timeout;
484	s.in.force_apps = r->in.force_apps;
485	s.in.do_reboot = r->in.do_reboot;
486	s.in.reason = 0;
487
488	/* thunk down to _winreg_InitiateSystemShutdownEx()
489	(just returns a status) */
490
491	return _winreg_InitiateSystemShutdownEx( p, &s );
492	}
493
494	/*******************************************************************
495	_winreg_InitiateSystemShutdownEx
496	********************************************************************/
497
498	#define SHUTDOWN_R_STRING "-r"
499	#define SHUTDOWN_F_STRING "-f"
500
501
502	WERROR _winreg_InitiateSystemShutdownEx(pipes_struct p, struct winreg_InitiateSystemShutdownEx r)
503	{
504	char *shutdown_script = NULL;
505	char *msg = NULL;
506	char *chkmsg = NULL;
507	fstring str_timeout;
508	fstring str_reason;
509	fstring do_reboot;
510	fstring f;
511	int ret;
512	bool can_shutdown;
513
514	shutdown_script = talloc_strdup(p->mem_ctx, lp_shutdown_script());
515	if (!shutdown_script) {
516	return WERR_NOMEM;
517	}
518	if (!*shutdown_script) {
519	return WERR_ACCESS_DENIED;
520	}
521
522	/* pull the message string and perform necessary sanity checks on it */
523
524	if ( r->in.message && r->in.message->string ) {
525	if ( (msg = talloc_strdup(p->mem_ctx, r->in.message->string )) == NULL ) {
526	return WERR_NOMEM;
527	}
528	chkmsg = TALLOC_ARRAY(p->mem_ctx, char, strlen(msg)+1);
529	if (!chkmsg) {
530	return WERR_NOMEM;
531	}
532	alpha_strcpy(chkmsg, msg, NULL, strlen(msg)+1);
533	}
534
535	fstr_sprintf(str_timeout, "%d", r->in.timeout);
536	fstr_sprintf(do_reboot, r->in.do_reboot ? SHUTDOWN_R_STRING : "");
537	fstr_sprintf(f, r->in.force_apps ? SHUTDOWN_F_STRING : "");
538	fstr_sprintf(str_reason, "%d", r->in.reason );
539
540	shutdown_script = talloc_all_string_sub(p->mem_ctx,
541	shutdown_script, "%z", chkmsg ? chkmsg : "");
542	if (!shutdown_script) {
543	return WERR_NOMEM;
544	}
545	shutdown_script = talloc_all_string_sub(p->mem_ctx,
546	shutdown_script, "%t", str_timeout);
547	if (!shutdown_script) {
548	return WERR_NOMEM;
549	}
550	shutdown_script = talloc_all_string_sub(p->mem_ctx,
551	shutdown_script, "%r", do_reboot);
552	if (!shutdown_script) {
553	return WERR_NOMEM;
554	}
555	shutdown_script = talloc_all_string_sub(p->mem_ctx,
556	shutdown_script, "%f", f);
557	if (!shutdown_script) {
558	return WERR_NOMEM;
559	}
560	shutdown_script = talloc_all_string_sub(p->mem_ctx,
561	shutdown_script, "%x", str_reason);
562	if (!shutdown_script) {
563	return WERR_NOMEM;
564	}
565
566	can_shutdown = user_has_privileges( p->server_info->ptok,
567	&se_remote_shutdown );
568
569	/* IF someone has privs, run the shutdown script as root. OTHERWISE run it as not root
570	Take the error return from the script and provide it as the Windows return code. */
571
572	/******** BEGIN SeRemoteShutdownPrivilege BLOCK ********/
573
574	if ( can_shutdown )
575	become_root();
576
577	ret = smbrun( shutdown_script, NULL );
578
579	if ( can_shutdown )
580	unbecome_root();
581
582	/******** END SeRemoteShutdownPrivilege BLOCK ********/
583
584	DEBUG(3,("_reg_shutdown_ex: Running the command `%s' gave %d\n",
585	shutdown_script, ret));
586
587	return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
588	}
589
590	/*******************************************************************
591	_winreg_AbortSystemShutdown
592	********************************************************************/
593
594	WERROR _winreg_AbortSystemShutdown(pipes_struct p, struct winreg_AbortSystemShutdown r)
595	{
596	const char *abort_shutdown_script;
597	int ret;
598	bool can_shutdown;
599
600	abort_shutdown_script = lp_abort_shutdown_script();
601
602	if (!*abort_shutdown_script)
603	return WERR_ACCESS_DENIED;
604
605	can_shutdown = user_has_privileges( p->server_info->ptok,
606	&se_remote_shutdown );
607
608	/******** BEGIN SeRemoteShutdownPrivilege BLOCK ********/
609
610	if ( can_shutdown )
611	become_root();
612
613	ret = smbrun( abort_shutdown_script, NULL );
614
615	if ( can_shutdown )
616	unbecome_root();
617
618	/******** END SeRemoteShutdownPrivilege BLOCK ********/
619
620	DEBUG(3,("_reg_abort_shutdown: Running the command `%s' gave %d\n",
621	abort_shutdown_script, ret));
622
623	return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
624	}
625
626	/*******************************************************************
627	********************************************************************/
628
629	static int validate_reg_filename(TALLOC_CTX ctx, char *pp_fname )
630	{
631	char *p = NULL;
632	int num_services = lp_numservices();
633	int snum = -1;
634	const char *share_path;
635	char fname = pp_fname;
636
637	/* convert to a unix path, stripping the C:\ along the way */
638
639	if (!(p = valid_share_pathname(ctx, fname))) {
640	return -1;
641	}
642
643	/* has to exist within a valid file share */
644
645	for (snum=0; snum<num_services; snum++) {
646	if (!lp_snum_ok(snum) \|\| lp_print_ok(snum)) {
647	continue;
648	}
649
650	share_path = lp_pathname(snum);
651
652	/* make sure we have a path (e.g. [homes] ) */
653	if (strlen(share_path) == 0) {
654	continue;
655	}
656
657	if (strncmp(share_path, p, strlen(share_path)) == 0) {
658	break;
659	}
660	}
661
662	*pp_fname = p;
663	return (snum < num_services) ? snum : -1;
664	}
665
666	/*******************************************************************
667	_winreg_RestoreKey
668	********************************************************************/
669
670	WERROR _winreg_RestoreKey(pipes_struct p, struct winreg_RestoreKey r)
671	{
672	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
673	char *fname = NULL;
674	int snum;
675
676	if ( !regkey )
677	return WERR_BADFID;
678
679	if ( !r->in.filename \|\| !r->in.filename->name )
680	return WERR_INVALID_PARAM;
681
682	fname = talloc_strdup(p->mem_ctx, r->in.filename->name);
683	if (!fname) {
684	return WERR_NOMEM;
685	}
686
687	DEBUG(8,("_winreg_RestoreKey: verifying restore of key [%s] from "
688	"\"%s\"\n", regkey->key->name, fname));
689
690	if ((snum = validate_reg_filename(p->mem_ctx, &fname)) == -1)
691	return WERR_OBJECT_PATH_INVALID;
692
693	/* user must posses SeRestorePrivilege for this this proceed */
694
695	if ( !user_has_privileges( p->server_info->ptok, &se_restore ) )
696	return WERR_ACCESS_DENIED;
697
698	DEBUG(2,("_winreg_RestoreKey: Restoring [%s] from %s in share %s\n",
699	regkey->key->name, fname, lp_servicename(snum) ));
700
701	return reg_restorekey(regkey, fname);
702	}
703
704	/*******************************************************************
705	_winreg_SaveKey
706	********************************************************************/
707
708	WERROR _winreg_SaveKey(pipes_struct p, struct winreg_SaveKey r)
709	{
710	struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
711	char *fname = NULL;
712	int snum = -1;
713
714	if ( !regkey )
715	return WERR_BADFID;
716
717	if ( !r->in.filename \|\| !r->in.filename->name )
718	return WERR_INVALID_PARAM;
719
720	fname = talloc_strdup(p->mem_ctx, r->in.filename->name);
721	if (!fname) {
722	return WERR_NOMEM;
723	}
724
725	DEBUG(8,("_winreg_SaveKey: verifying backup of key [%s] to \"%s\"\n",
726	regkey->key->name, fname));
727
728	if ((snum = validate_reg_filename(p->mem_ctx, &fname)) == -1 )
729	return WERR_OBJECT_PATH_INVALID;
730
731	DEBUG(2,("_winreg_SaveKey: Saving [%s] to %s in share %s\n",
732	regkey->key->name, fname, lp_servicename(snum) ));
733
734	return reg_savekey(regkey, fname);
735	}
736
737	/*******************************************************************
738	_winreg_SaveKeyEx
739	********************************************************************/
740
741	WERROR _winreg_SaveKeyEx(pipes_struct p, struct winreg_SaveKeyEx r)
742	{
743	/* fill in your code here if you think this call should
744	do anything */
745
746	p->rng_fault_state = True;
747	return WERR_NOT_SUPPORTED;
748	}
749
750	/*******************************************************************
751	_winreg_CreateKey
752	********************************************************************/
753
754	WERROR _winreg_CreateKey( pipes_struct p, struct winreg_CreateKey r)
755	{
756	struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
757	struct registry_key *new_key;
758	WERROR result;
759
760	if ( !parent )
761	return WERR_BADFID;
762
763	DEBUG(10, ("_winreg_CreateKey called with parent key '%s' and "
764	"subkey name '%s'\n", parent->key->name, r->in.name.name));
765
766	result = reg_createkey(NULL, parent, r->in.name.name, r->in.access_mask,
767	&new_key, r->out.action_taken);
768	if (!W_ERROR_IS_OK(result)) {
769	return result;
770	}
771
772	if (!create_policy_hnd(p, r->out.new_handle, new_key)) {
773	TALLOC_FREE(new_key);
774	return WERR_BADFILE;
775	}
776
777	return WERR_OK;
778	}
779
780	/*******************************************************************
781	_winreg_SetValue
782	********************************************************************/
783
784	WERROR _winreg_SetValue(pipes_struct p, struct winreg_SetValue r)
785	{
786	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
787	struct registry_value *val;
788	WERROR status;
789
790	if ( !key )
791	return WERR_BADFID;
792
793	DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n",
794	key->key->name, r->in.name.name));
795
796	status = registry_pull_value(p->mem_ctx, &val, r->in.type, r->in.data,
797	r->in.size, r->in.size);
798	if (!W_ERROR_IS_OK(status)) {
799	return status;
800	}
801
802	return reg_setvalue(key, r->in.name.name, val);
803	}
804
805	/*******************************************************************
806	_winreg_DeleteKey
807	********************************************************************/
808
809	WERROR _winreg_DeleteKey(pipes_struct p, struct winreg_DeleteKey r)
810	{
811	struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
812
813	if ( !parent )
814	return WERR_BADFID;
815
816	return reg_deletekey(parent, r->in.key.name);
817	}
818
819
820	/*******************************************************************
821	_winreg_DeleteValue
822	********************************************************************/
823
824	WERROR _winreg_DeleteValue(pipes_struct p, struct winreg_DeleteValue r)
825	{
826	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
827
828	if ( !key )
829	return WERR_BADFID;
830
831	return reg_deletevalue(key, r->in.value.name);
832	}
833
834	/*******************************************************************
835	_winreg_GetKeySecurity
836	********************************************************************/
837
838	WERROR _winreg_GetKeySecurity(pipes_struct p, struct winreg_GetKeySecurity r)
839	{
840	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
841	WERROR err;
842	struct security_descriptor *secdesc;
843	uint8 *data;
844	size_t len;
845
846	if ( !key )
847	return WERR_BADFID;
848
849	/* access checks first */
850
851	if ( !(key->key->access_granted & STD_RIGHT_READ_CONTROL_ACCESS) )
852	return WERR_ACCESS_DENIED;
853
854	err = reg_getkeysecurity(p->mem_ctx, key, &secdesc);
855	if (!W_ERROR_IS_OK(err)) {
856	return err;
857	}
858
859	err = ntstatus_to_werror(marshall_sec_desc(p->mem_ctx, secdesc,
860	&data, &len));
861	if (!W_ERROR_IS_OK(err)) {
862	return err;
863	}
864
865	if (len > r->out.sd->size) {
866	r->out.sd->size = len;
867	return WERR_INSUFFICIENT_BUFFER;
868	}
869
870	r->out.sd->size = len;
871	r->out.sd->len = len;
872	r->out.sd->data = data;
873
874	return WERR_OK;
875	}
876
877	/*******************************************************************
878	_winreg_SetKeySecurity
879	********************************************************************/
880
881	WERROR _winreg_SetKeySecurity(pipes_struct p, struct winreg_SetKeySecurity r)
882	{
883	struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
884	struct security_descriptor *secdesc;
885	WERROR err;
886
887	if ( !key )
888	return WERR_BADFID;
889
890	/* access checks first */
891
892	if ( !(key->key->access_granted & STD_RIGHT_WRITE_DAC_ACCESS) )
893	return WERR_ACCESS_DENIED;
894
895	err = ntstatus_to_werror(unmarshall_sec_desc(p->mem_ctx, r->in.sd->data,
896	r->in.sd->len, &secdesc));
897	if (!W_ERROR_IS_OK(err)) {
898	return err;
899	}
900
901	return reg_setkeysecurity(key, secdesc);
902	}
903
904	/*******************************************************************
905	_winreg_FlushKey
906	********************************************************************/
907
908	WERROR _winreg_FlushKey(pipes_struct p, struct winreg_FlushKey r)
909	{
910	/* I'm just replying OK because there's not a lot
911	here I see to do i --jerry */
912
913	return WERR_OK;
914	}
915
916	/*******************************************************************
917	_winreg_UnLoadKey
918	********************************************************************/
919
920	WERROR _winreg_UnLoadKey(pipes_struct p, struct winreg_UnLoadKey r)
921	{
922	/* fill in your code here if you think this call should
923	do anything */
924
925	p->rng_fault_state = True;
926	return WERR_NOT_SUPPORTED;
927	}
928
929	/*******************************************************************
930	_winreg_ReplaceKey
931	********************************************************************/
932
933	WERROR _winreg_ReplaceKey(pipes_struct p, struct winreg_ReplaceKey r)
934	{
935	/* fill in your code here if you think this call should
936	do anything */
937
938	p->rng_fault_state = True;
939	return WERR_NOT_SUPPORTED;
940	}
941
942	/*******************************************************************
943	_winreg_LoadKey
944	********************************************************************/
945
946	WERROR _winreg_LoadKey(pipes_struct p, struct winreg_LoadKey r)
947	{
948	/* fill in your code here if you think this call should
949	do anything */
950
951	p->rng_fault_state = True;
952	return WERR_NOT_SUPPORTED;
953	}
954
955	/*******************************************************************
956	_winreg_NotifyChangeKeyValue
957	********************************************************************/
958
959	WERROR _winreg_NotifyChangeKeyValue(pipes_struct p, struct winreg_NotifyChangeKeyValue r)
960	{
961	return WERR_NOT_SUPPORTED;
962	}
963
964	/*******************************************************************
965	_winreg_QueryMultipleValues
966	********************************************************************/
967
968	WERROR _winreg_QueryMultipleValues(pipes_struct p, struct winreg_QueryMultipleValues r)
969	{
970	/* fill in your code here if you think this call should
971	do anything */
972
973	p->rng_fault_state = True;
974	return WERR_NOT_SUPPORTED;
975	}
976
977	/*******************************************************************
978	_winreg_QueryMultipleValues2
979	********************************************************************/
980
981	WERROR _winreg_QueryMultipleValues2(pipes_struct p, struct winreg_QueryMultipleValues2 r)
982	{
983	/* fill in your code here if you think this call should
984	do anything */
985
986	p->rng_fault_state = True;
987	return WERR_NOT_SUPPORTED;
988	}
989

Note: See TracBrowser for help on using the repository browser.

Download in other formats: