*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
/* Implementation of registry functions. */
#include "includes.h"
-#include "regfio.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
-static struct generic_mapping reg_generic_map =
- { REG_KEY_READ, REG_KEY_WRITE, REG_KEY_EXECUTE, REG_KEY_ALL };
-
-/******************************************************************
- free() function for struct regkey_info
- *****************************************************************/
-
-static void free_regkey(void *ptr)
-{
- struct registry_key *key = (struct registry_key *)ptr;
- TALLOC_FREE(key);
-}
-
/******************************************************************
- Find a registry key handle and return a REGISTRY_KEY
+ Find a registry key handle and return a struct registry_key *
*****************************************************************/
static struct registry_key *find_regkey_by_hnd(pipes_struct *p,
- POLICY_HND *hnd)
+ struct policy_handle *hnd)
{
struct registry_key *regkey = NULL;
HK[LM|U]\<key>\<key>\...
*******************************************************************/
-static WERROR open_registry_key( pipes_struct *p, POLICY_HND *hnd,
+static WERROR open_registry_key( pipes_struct *p, struct policy_handle *hnd,
struct registry_key *parent,
const char *subkeyname,
uint32 access_desired )
WERROR result = WERR_OK;
struct registry_key *key;
- /* now do the internal open */
-
if (parent == NULL) {
- result = reg_openhive(NULL, subkeyname, access_desired,
- p->pipe_user.nt_user_token, &key);
+ result = reg_openhive(p->mem_ctx, subkeyname, access_desired,
+ p->server_info->ptok, &key);
}
else {
- result = reg_openkey(NULL, parent, subkeyname, access_desired,
- &key);
+ result = reg_openkey(p->mem_ctx, parent, subkeyname,
+ access_desired, &key);
}
if ( !W_ERROR_IS_OK(result) ) {
return result;
}
- if ( !create_policy_hnd( p, hnd, free_regkey, key ) ) {
+ if ( !create_policy_hnd( p, hnd, key ) ) {
return WERR_BADFILE;
}
- return WERR_OK;;
+ return WERR_OK;
}
/*******************************************************************
Note that P should be valid & hnd should already have space
*******************************************************************/
-static BOOL close_registry_key(pipes_struct *p, POLICY_HND *hnd)
+static bool close_registry_key(pipes_struct *p, struct policy_handle *hnd)
{
struct registry_key *regkey = find_regkey_by_hnd(p, hnd);
uint32_t outbuf_size;
DATA_BLOB val_blob;
- BOOL free_buf = False;
- BOOL free_prs = False;
+ bool free_buf = False;
+ bool free_prs = False;
if ( !regkey )
return WERR_BADFID;
- *r->out.value_length = *r->out.type = 0;
+ if ((r->out.data_length == NULL) || (r->out.type == NULL)) {
+ return WERR_INVALID_PARAM;
+ }
+
+ *r->out.data_length = *r->out.type = REG_NONE;
DEBUG(7,("_reg_info: policy key name = [%s]\n", regkey->key->name));
DEBUG(7,("_reg_info: policy key type = [%08x]\n", regkey->key->type));
/* Handle QueryValue calls on HKEY_PERFORMANCE_DATA */
if(regkey->key->type == REG_KEY_HKPD)
{
- if(strequal(r->in.value_name.name, "Global")) {
- prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL);
+ if (strequal(r->in.value_name->name, "Global")) {
+ if (!prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL))
+ return WERR_NOMEM;
status = reg_perfcount_get_hkpd(
&prs_hkpd, *r->in.data_size, &outbuf_size, NULL);
outbuf = (uint8_t *)prs_hkpd.data_p;
free_prs = True;
}
- else if(strequal(r->in.value_name.name, "Counter 009")) {
+ else if (strequal(r->in.value_name->name, "Counter 009")) {
outbuf_size = reg_perfcount_get_counter_names(
reg_perfcount_get_base_index(),
(char **)(void *)&outbuf);
free_buf = True;
}
- else if(strequal(r->in.value_name.name, "Explain 009")) {
+ else if (strequal(r->in.value_name->name, "Explain 009")) {
outbuf_size = reg_perfcount_get_counter_help(
reg_perfcount_get_base_index(),
(char **)(void *)&outbuf);
free_buf = True;
}
- else if(isdigit(r->in.value_name.name[0])) {
+ else if (isdigit(r->in.value_name->name[0])) {
/* we probably have a request for a specific object
* here */
- prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL);
+ if (!prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL))
+ return WERR_NOMEM;
status = reg_perfcount_get_hkpd(
&prs_hkpd, *r->in.data_size, &outbuf_size,
- r->in.value_name.name);
+ r->in.value_name->name);
outbuf = (uint8_t *)prs_hkpd.data_p;
free_prs = True;
}
else {
DEBUG(3,("Unsupported key name [%s] for HKPD.\n",
- r->in.value_name.name));
+ r->in.value_name->name));
return WERR_BADFILE;
}
else {
struct registry_value *val;
- status = reg_queryvalue(p->mem_ctx, regkey, r->in.value_name.name,
+ status = reg_queryvalue(p->mem_ctx, regkey, r->in.value_name->name,
&val);
if (!W_ERROR_IS_OK(status)) {
if (r->out.data_size) {
*r->out.data_size = 0;
}
- if (r->out.value_length) {
- *r->out.value_length = 0;
+ if (r->out.data_length) {
+ *r->out.data_length = 0;
}
return status;
}
*r->out.type = val->type;
}
- *r->out.value_length = outbuf_size;
+ *r->out.data_length = outbuf_size;
if ( *r->in.data_size == 0 || !r->out.data ) {
status = WERR_OK;
- } else if ( *r->out.value_length > *r->in.data_size ) {
+ } else if ( *r->out.data_length > *r->in.data_size ) {
status = WERR_MORE_DATA;
} else {
- memcpy( r->out.data, outbuf, *r->out.value_length );
+ memcpy( r->out.data, outbuf, *r->out.data_length );
status = WERR_OK;
}
- *r->out.data_size = *r->out.value_length;
+ *r->out.data_size = *r->out.data_length;
if (free_prs) prs_mem_free(&prs_hkpd);
if (free_buf) SAFE_FREE(outbuf);
if ( !regkey )
return WERR_BADFID;
- *r->out.version = 0x00000005; /* Windows 2000 registry API version */
-
- return WERR_OK;
+ return reg_getversion(r->out.version);
}
s.in.message = r->in.message;
s.in.timeout = r->in.timeout;
s.in.force_apps = r->in.force_apps;
- s.in.reboot = r->in.reboot;
+ s.in.do_reboot = r->in.do_reboot;
s.in.reason = 0;
/* thunk down to _winreg_InitiateSystemShutdownEx()
WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, struct winreg_InitiateSystemShutdownEx *r)
{
- pstring shutdown_script;
+ char *shutdown_script = NULL;
char *msg = NULL;
- pstring chkmsg;
+ char *chkmsg = NULL;
fstring str_timeout;
fstring str_reason;
- fstring reboot;
+ fstring do_reboot;
fstring f;
int ret;
- BOOL can_shutdown;
-
+ bool can_shutdown;
- pstrcpy(shutdown_script, lp_shutdown_script());
-
- if ( !*shutdown_script )
+ shutdown_script = talloc_strdup(p->mem_ctx, lp_shutdown_script());
+ if (!shutdown_script) {
+ return WERR_NOMEM;
+ }
+ if (!*shutdown_script) {
return WERR_ACCESS_DENIED;
+ }
/* pull the message string and perform necessary sanity checks on it */
- chkmsg[0] = '\0';
-
- if ( r->in.message && r->in.message->name && r->in.message->name->name ) {
- if ( (msg = talloc_strdup(p->mem_ctx, r->in.message->name->name )) == NULL ) {
+ if ( r->in.message && r->in.message->string ) {
+ if ( (msg = talloc_strdup(p->mem_ctx, r->in.message->string )) == NULL ) {
return WERR_NOMEM;
}
- alpha_strcpy (chkmsg, msg, NULL, sizeof(chkmsg));
- }
-
+ chkmsg = TALLOC_ARRAY(p->mem_ctx, char, strlen(msg)+1);
+ if (!chkmsg) {
+ return WERR_NOMEM;
+ }
+ alpha_strcpy(chkmsg, msg, NULL, strlen(msg)+1);
+ }
+
fstr_sprintf(str_timeout, "%d", r->in.timeout);
- fstr_sprintf(reboot, r->in.reboot ? SHUTDOWN_R_STRING : "");
+ fstr_sprintf(do_reboot, r->in.do_reboot ? SHUTDOWN_R_STRING : "");
fstr_sprintf(f, r->in.force_apps ? SHUTDOWN_F_STRING : "");
fstr_sprintf(str_reason, "%d", r->in.reason );
- all_string_sub( shutdown_script, "%z", chkmsg, sizeof(shutdown_script) );
- all_string_sub( shutdown_script, "%t", str_timeout, sizeof(shutdown_script) );
- all_string_sub( shutdown_script, "%r", reboot, sizeof(shutdown_script) );
- all_string_sub( shutdown_script, "%f", f, sizeof(shutdown_script) );
- all_string_sub( shutdown_script, "%x", str_reason, sizeof(shutdown_script) );
+ shutdown_script = talloc_all_string_sub(p->mem_ctx,
+ shutdown_script, "%z", chkmsg ? chkmsg : "");
+ if (!shutdown_script) {
+ return WERR_NOMEM;
+ }
+ shutdown_script = talloc_all_string_sub(p->mem_ctx,
+ shutdown_script, "%t", str_timeout);
+ if (!shutdown_script) {
+ return WERR_NOMEM;
+ }
+ shutdown_script = talloc_all_string_sub(p->mem_ctx,
+ shutdown_script, "%r", do_reboot);
+ if (!shutdown_script) {
+ return WERR_NOMEM;
+ }
+ shutdown_script = talloc_all_string_sub(p->mem_ctx,
+ shutdown_script, "%f", f);
+ if (!shutdown_script) {
+ return WERR_NOMEM;
+ }
+ shutdown_script = talloc_all_string_sub(p->mem_ctx,
+ shutdown_script, "%x", str_reason);
+ if (!shutdown_script) {
+ return WERR_NOMEM;
+ }
+
+ can_shutdown = user_has_privileges( p->server_info->ptok,
+ &se_remote_shutdown );
- can_shutdown = user_has_privileges( p->pipe_user.nt_user_token, &se_remote_shutdown );
-
/* IF someone has privs, run the shutdown script as root. OTHERWISE run it as not root
Take the error return from the script and provide it as the Windows return code. */
-
+
/********** BEGIN SeRemoteShutdownPrivilege BLOCK **********/
-
- if ( can_shutdown )
+
+ if ( can_shutdown )
become_root();
ret = smbrun( shutdown_script, NULL );
-
+
if ( can_shutdown )
unbecome_root();
/********** END SeRemoteShutdownPrivilege BLOCK **********/
-
+
DEBUG(3,("_reg_shutdown_ex: Running the command `%s' gave %d\n",
shutdown_script, ret));
-
return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
}
-
-
-
/*******************************************************************
reg_abort_shutdwon
********************************************************************/
WERROR _winreg_AbortSystemShutdown(pipes_struct *p, struct winreg_AbortSystemShutdown *r)
{
- pstring abort_shutdown_script;
+ const char *abort_shutdown_script;
int ret;
- BOOL can_shutdown;
+ bool can_shutdown;
- pstrcpy(abort_shutdown_script, lp_abort_shutdown_script());
+ abort_shutdown_script = lp_abort_shutdown_script();
- if ( !*abort_shutdown_script )
+ if (!*abort_shutdown_script)
return WERR_ACCESS_DENIED;
-
- can_shutdown = user_has_privileges( p->pipe_user.nt_user_token, &se_remote_shutdown );
-
+
+ can_shutdown = user_has_privileges( p->server_info->ptok,
+ &se_remote_shutdown );
+
/********** BEGIN SeRemoteShutdownPrivilege BLOCK **********/
-
+
if ( can_shutdown )
become_root();
-
+
ret = smbrun( abort_shutdown_script, NULL );
-
+
if ( can_shutdown )
unbecome_root();
-
+
/********** END SeRemoteShutdownPrivilege BLOCK **********/
DEBUG(3,("_reg_abort_shutdown: Running the command `%s' gave %d\n",
abort_shutdown_script, ret));
-
return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
}
/*******************************************************************
********************************************************************/
-static int validate_reg_filename( pstring fname )
+static int validate_reg_filename(TALLOC_CTX *ctx, char **pp_fname )
{
- char *p;
+ char *p = NULL;
int num_services = lp_numservices();
- int snum;
- pstring share_path;
- pstring unix_fname;
-
+ int snum = -1;
+ const char *share_path;
+ char *fname = *pp_fname;
+
/* convert to a unix path, stripping the C:\ along the way */
-
- if ( !(p = valid_share_pathname( fname ) ))
+
+ if (!(p = valid_share_pathname(ctx, fname))) {
return -1;
+ }
/* has to exist within a valid file share */
-
- for ( snum=0; snum<num_services; snum++ ) {
-
- if ( !lp_snum_ok(snum) || lp_print_ok(snum) )
- continue;
-
- pstrcpy( share_path, lp_pathname(snum) );
-
- /* make sure we have a path (e.g. [homes] ) */
- if ( strlen( share_path ) == 0 )
+ for (snum=0; snum<num_services; snum++) {
+ if (!lp_snum_ok(snum) || lp_print_ok(snum)) {
continue;
+ }
- if ( strncmp( share_path, p, strlen( share_path )) == 0 )
- break;
- }
-
- /* p and fname are overlapping memory so copy out and back in again */
-
- pstrcpy( unix_fname, p );
- pstrcpy( fname, unix_fname );
-
- return (snum < num_services) ? snum : -1;
-}
-
-/*******************************************************************
- Note: topkeypat is the *full* path that this *key will be
- loaded into (including the name of the key)
- ********************************************************************/
-
-static WERROR reg_load_tree( REGF_FILE *regfile, const char *topkeypath,
- REGF_NK_REC *key )
-{
- REGF_NK_REC *subkey;
- REGISTRY_KEY registry_key;
- REGVAL_CTR *values;
- REGSUBKEY_CTR *subkeys;
- int i;
- pstring path;
- WERROR result = WERR_OK;
-
- /* initialize the REGISTRY_KEY structure */
-
- if ( !(registry_key.hook = reghook_cache_find(topkeypath)) ) {
- DEBUG(0,("reg_load_tree: Failed to assigned a REGISTRY_HOOK to [%s]\n",
- topkeypath ));
- return WERR_BADFILE;
- }
- pstrcpy( registry_key.name, topkeypath );
-
- /* now start parsing the values and subkeys */
-
- if ( !(subkeys = TALLOC_ZERO_P( regfile->mem_ctx, REGSUBKEY_CTR )) )
- return WERR_NOMEM;
-
- if ( !(values = TALLOC_ZERO_P( subkeys, REGVAL_CTR )) )
- return WERR_NOMEM;
-
- /* copy values into the REGVAL_CTR */
-
- for ( i=0; i<key->num_values; i++ ) {
- regval_ctr_addvalue( values, key->values[i].valuename, key->values[i].type,
- (char*)key->values[i].data, (key->values[i].data_size & ~VK_DATA_IN_OFFSET) );
- }
+ share_path = lp_pathname(snum);
- /* copy subkeys into the REGSUBKEY_CTR */
-
- key->subkey_index = 0;
- while ( (subkey = regfio_fetch_subkey( regfile, key )) ) {
- regsubkey_ctr_addkey( subkeys, subkey->keyname );
- }
-
- /* write this key and values out */
-
- if ( !store_reg_values( ®istry_key, values )
- || !store_reg_keys( ®istry_key, subkeys ) )
- {
- DEBUG(0,("reg_load_tree: Failed to load %s!\n", topkeypath));
- result = WERR_REG_IO_FAILURE;
- }
-
- TALLOC_FREE( subkeys );
-
- if ( !W_ERROR_IS_OK(result) )
- return result;
-
- /* now continue to load each subkey registry tree */
+ /* make sure we have a path (e.g. [homes] ) */
+ if (strlen(share_path) == 0) {
+ continue;
+ }
- key->subkey_index = 0;
- while ( (subkey = regfio_fetch_subkey( regfile, key )) ) {
- pstr_sprintf( path, "%s%s%s", topkeypath, "\\", subkey->keyname );
- result = reg_load_tree( regfile, path, subkey );
- if ( !W_ERROR_IS_OK(result) )
+ if (strncmp(share_path, p, strlen(share_path)) == 0) {
break;
+ }
}
- return result;
-}
-
-/*******************************************************************
- ********************************************************************/
-
-static WERROR restore_registry_key ( REGISTRY_KEY *krecord, const char *fname )
-{
- REGF_FILE *regfile;
- REGF_NK_REC *rootkey;
- WERROR result;
-
- /* open the registry file....fail if the file already exists */
-
- if ( !(regfile = regfio_open( fname, (O_RDONLY), 0 )) ) {
- DEBUG(0,("restore_registry_key: failed to open \"%s\" (%s)\n",
- fname, strerror(errno) ));
- return ( ntstatus_to_werror(map_nt_error_from_unix( errno )) );
- }
-
- /* get the rootkey from the regf file and then load the tree
- via recursive calls */
-
- if ( !(rootkey = regfio_rootkey( regfile )) ) {
- regfio_close( regfile );
- return WERR_REG_FILE_INVALID;
- }
-
- result = reg_load_tree( regfile, krecord->name, rootkey );
-
- /* cleanup */
-
- regfio_close( regfile );
-
- return result;
+ *pp_fname = p;
+ return (snum < num_services) ? snum : -1;
}
/*******************************************************************
WERROR _winreg_RestoreKey(pipes_struct *p, struct winreg_RestoreKey *r)
{
struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
- pstring fname;
+ char *fname = NULL;
int snum;
-
+
if ( !regkey )
- return WERR_BADFID;
+ return WERR_BADFID;
if ( !r->in.filename || !r->in.filename->name )
return WERR_INVALID_PARAM;
- pstrcpy( fname, r->in.filename->name );
+ fname = talloc_strdup(p->mem_ctx, r->in.filename->name);
+ if (!fname) {
+ return WERR_NOMEM;
+ }
DEBUG(8,("_winreg_RestoreKey: verifying restore of key [%s] from "
"\"%s\"\n", regkey->key->name, fname));
- if ( (snum = validate_reg_filename( fname )) == -1 )
+ if ((snum = validate_reg_filename(p->mem_ctx, &fname)) == -1)
return WERR_OBJECT_PATH_INVALID;
-
+
/* user must posses SeRestorePrivilege for this this proceed */
-
- if ( !user_has_privileges( p->pipe_user.nt_user_token, &se_restore ) )
+
+ if ( !user_has_privileges( p->server_info->ptok, &se_restore ) )
return WERR_ACCESS_DENIED;
-
+
DEBUG(2,("_winreg_RestoreKey: Restoring [%s] from %s in share %s\n",
regkey->key->name, fname, lp_servicename(snum) ));
- return restore_registry_key( regkey->key, fname );
+ return reg_restorekey(regkey, fname);
}
-/********************************************************************
-********************************************************************/
-
-static WERROR reg_write_tree( REGF_FILE *regfile, const char *keypath,
- REGF_NK_REC *parent, SEC_DESC *sec_desc )
-{
- REGF_NK_REC *key;
- REGVAL_CTR *values;
- REGSUBKEY_CTR *subkeys;
- int i, num_subkeys;
- pstring key_tmp;
- char *keyname, *parentpath;
- pstring subkeypath;
- char *subkeyname;
- REGISTRY_KEY registry_key;
- WERROR result = WERR_OK;
-
- if ( !regfile )
- return WERR_GENERAL_FAILURE;
-
- if ( !keypath )
- return WERR_OBJECT_PATH_INVALID;
-
- /* split up the registry key path */
-
- pstrcpy( key_tmp, keypath );
- if ( !reg_split_key( key_tmp, &parentpath, &keyname ) )
- return WERR_OBJECT_PATH_INVALID;
-
- if ( !keyname )
- keyname = parentpath;
-
- /* we need a REGISTRY_KEY object here to enumerate subkeys and values */
-
- ZERO_STRUCT( registry_key );
-
- if ( (registry_key.name = talloc_strdup(regfile->mem_ctx, keypath)) == NULL )
- return WERR_NOMEM;
-
- if ( (registry_key.hook = reghook_cache_find( registry_key.name )) == NULL )
- return WERR_BADFILE;
-
- /* lookup the values and subkeys */
-
- if ( !(subkeys = TALLOC_ZERO_P( regfile->mem_ctx, REGSUBKEY_CTR )) )
- return WERR_NOMEM;
-
- if ( !(values = TALLOC_ZERO_P( subkeys, REGVAL_CTR )) )
- return WERR_NOMEM;
-
- fetch_reg_keys( ®istry_key, subkeys );
- fetch_reg_values( ®istry_key, values );
-
- /* write out this key */
-
- if ( !(key = regfio_write_key( regfile, keyname, values, subkeys, sec_desc, parent )) ) {
- result = WERR_CAN_NOT_COMPLETE;
- goto done;
- }
-
- /* write each one of the subkeys out */
-
- num_subkeys = regsubkey_ctr_numkeys( subkeys );
- for ( i=0; i<num_subkeys; i++ ) {
- subkeyname = regsubkey_ctr_specific_key( subkeys, i );
- pstr_sprintf( subkeypath, "%s\\%s", keypath, subkeyname );
- result = reg_write_tree( regfile, subkeypath, key, sec_desc );
- if ( !W_ERROR_IS_OK(result) )
- goto done;
- }
-
- DEBUG(6,("reg_write_tree: wrote key [%s]\n", keypath ));
-
-done:
- TALLOC_FREE( subkeys );
- TALLOC_FREE( registry_key.name );
-
- return result;
-}
-
-/*******************************************************************
- ********************************************************************/
-
-static WERROR make_default_reg_sd( TALLOC_CTX *ctx, SEC_DESC **psd )
-{
- DOM_SID adm_sid, owner_sid;
- SEC_ACE ace[2]; /* at most 2 entries */
- SEC_ACCESS mask;
- SEC_ACL *psa = NULL;
- size_t sd_size;
-
- /* set the owner to BUILTIN\Administrator */
-
- sid_copy(&owner_sid, &global_sid_Builtin);
- sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN );
-
-
- /* basic access for Everyone */
-
- init_sec_access(&mask, reg_generic_map.generic_execute | reg_generic_map.generic_read );
- init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
-
- /* add Full Access 'BUILTIN\Administrators' */
-
- init_sec_access(&mask, reg_generic_map.generic_all);
- sid_copy(&adm_sid, &global_sid_Builtin);
- sid_append_rid(&adm_sid, BUILTIN_ALIAS_RID_ADMINS);
- init_sec_ace(&ace[1], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
-
- /* create the security descriptor */
-
- if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, 2, ace)) == NULL)
- return WERR_NOMEM;
-
- if ((*psd = make_sec_desc(ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE, &owner_sid, NULL, NULL, psa, &sd_size)) == NULL)
- return WERR_NOMEM;
-
- return WERR_OK;
-}
-
-/*******************************************************************
- ********************************************************************/
-
-static WERROR backup_registry_key ( REGISTRY_KEY *krecord, const char *fname )
-{
- REGF_FILE *regfile;
- WERROR result;
- SEC_DESC *sd = NULL;
-
- /* open the registry file....fail if the file already exists */
-
- if ( !(regfile = regfio_open( fname, (O_RDWR|O_CREAT|O_EXCL), (S_IREAD|S_IWRITE) )) ) {
- DEBUG(0,("backup_registry_key: failed to open \"%s\" (%s)\n",
- fname, strerror(errno) ));
- return ( ntstatus_to_werror(map_nt_error_from_unix( errno )) );
- }
-
- if ( !W_ERROR_IS_OK(result = make_default_reg_sd( regfile->mem_ctx, &sd )) ) {
- regfio_close( regfile );
- return result;
- }
-
- /* write the registry tree to the file */
-
- result = reg_write_tree( regfile, krecord->name, NULL, sd );
-
- /* cleanup */
-
- regfio_close( regfile );
-
- return result;
-}
-
-/*******************************************************************
- ********************************************************************/
-
WERROR _winreg_SaveKey(pipes_struct *p, struct winreg_SaveKey *r)
{
struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
- pstring fname;
- int snum;
-
+ char *fname = NULL;
+ int snum = -1;
+
if ( !regkey )
- return WERR_BADFID;
+ return WERR_BADFID;
if ( !r->in.filename || !r->in.filename->name )
return WERR_INVALID_PARAM;
- pstrcpy( fname, r->in.filename->name );
+ fname = talloc_strdup(p->mem_ctx, r->in.filename->name);
+ if (!fname) {
+ return WERR_NOMEM;
+ }
DEBUG(8,("_winreg_SaveKey: verifying backup of key [%s] to \"%s\"\n",
regkey->key->name, fname));
-
- if ( (snum = validate_reg_filename( fname )) == -1 )
+
+ if ((snum = validate_reg_filename(p->mem_ctx, &fname)) == -1 )
return WERR_OBJECT_PATH_INVALID;
-
+
DEBUG(2,("_winreg_SaveKey: Saving [%s] to %s in share %s\n",
regkey->key->name, fname, lp_servicename(snum) ));
-
- return backup_registry_key( regkey->key, fname );
+
+ return reg_savekey(regkey, fname);
}
/*******************************************************************
if ( !parent )
return WERR_BADFID;
+ DEBUG(10, ("_winreg_CreateKey called with parent key '%s' and "
+ "subkey name '%s'\n", parent->key->name, r->in.name.name));
+
result = reg_createkey(NULL, parent, r->in.name.name, r->in.access_mask,
&new_key, r->out.action_taken);
if (!W_ERROR_IS_OK(result)) {
return result;
}
- if (!create_policy_hnd(p, r->out.new_handle, free_regkey, new_key)) {
+ if (!create_policy_hnd(p, r->out.new_handle, new_key)) {
TALLOC_FREE(new_key);
return WERR_BADFILE;
}
if ( !(key->key->access_granted & STD_RIGHT_READ_CONTROL_ACCESS) )
return WERR_ACCESS_DENIED;
- err = regkey_get_secdesc(p->mem_ctx, key->key, &secdesc);
+ err = reg_getkeysecurity(p->mem_ctx, key, &secdesc);
if (!W_ERROR_IS_OK(err)) {
return err;
}
return err;
}
- return regkey_set_secdesc(key->key, secdesc);
+ return reg_setkeysecurity(key, secdesc);
}
/*******************************************************************
git.samba.org / ira / wip.git / blobdiff