Reformat copied reg_savekey/reg_restorekey code.

Sticking to coding rules.

Michael
(This used to be commit 2c54ef2d07ab440f1c163b666caedcb9c061543b)

1 files changed, 119 insertions, 86 deletions

diff --git a/source3/registry/reg_api.c b/source3/registry/reg_api.c
index 6be60f04ec..aba5735a0c 100644
--- a/source3/registry/reg_api.c
+++ b/source3/registry/reg_api.c
@@ -702,8 +702,8 @@ WERROR reg_getversion(uint32_t *version)
  loaded into (including the name of the key)
  ********************************************************************/
 
-static WERROR reg_load_tree( REGF_FILE *regfile, const char *topkeypath,
-                             REGF_NK_REC *key )
+static WERROR reg_load_tree(REGF_FILE *regfile, const char *topkeypath,
+			    REGF_NK_REC *key)
 {
 	REGF_NK_REC *subkey;
 	REGISTRY_KEY registry_key;
@@ -715,68 +715,77 @@ static WERROR reg_load_tree( REGF_FILE *regfile, const char *topkeypath,
 
 	/* 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 ));
+	registry_key.hook = reghook_cache_find(topkeypath);
+	if (!registry_key.hook) {
+		DEBUG(0, ("reg_load_tree: Failed to assigned a REGISTRY_HOOK "
+			  "to [%s]\n", topkeypath));
 		return WERR_BADFILE;
 	}
 
-	registry_key.name = talloc_strdup( regfile->mem_ctx, topkeypath );
-	if ( !registry_key.name ) {
-		DEBUG(0,("reg_load_tree: Talloc failed for reg_key.name!\n"));
+	registry_key.name = talloc_strdup(regfile->mem_ctx, topkeypath);
+	if (!registry_key.name) {
+		DEBUG(0, ("reg_load_tree: Talloc failed for reg_key.name!\n"));
 		return WERR_NOMEM;
 	}
 
 	/* now start parsing the values and subkeys */
 
-	if ( !(subkeys = TALLOC_ZERO_P( regfile->mem_ctx, REGSUBKEY_CTR )) )
+	subkeys = TALLOC_ZERO_P(regfile->mem_ctx, REGSUBKEY_CTR);
+	if (subkeys == NULL) {
 		return WERR_NOMEM;
+	}
 
-	if ( !(values = TALLOC_ZERO_P( subkeys, REGVAL_CTR )) )
+	values = TALLOC_ZERO_P(subkeys, REGVAL_CTR);
+	if (values == NULL) {
 		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) );
+	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));
 	}
 
 	/* copy subkeys into the REGSUBKEY_CTR */
 
 	key->subkey_index = 0;
-	while ( (subkey = regfio_fetch_subkey( regfile, key )) ) {
-		regsubkey_ctr_addkey( subkeys, subkey->keyname );
+	while ((subkey = regfio_fetch_subkey( regfile, key ))) {
+		regsubkey_ctr_addkey(subkeys, subkey->keyname);
 	}
 
 	/* write this key and values out */
 
-	if ( !store_reg_values( &registry_key, values )
-		|| !store_reg_keys( &registry_key, subkeys ) )
+	if (!store_reg_values(&registry_key, values)
+	    || !store_reg_keys(&registry_key, subkeys))
 	{
 		DEBUG(0,("reg_load_tree: Failed to load %s!\n", topkeypath));
 		result = WERR_REG_IO_FAILURE;
 	}
 
-	TALLOC_FREE( subkeys );
+	TALLOC_FREE(subkeys);
 
-	if ( !W_ERROR_IS_OK(result) )
+	if (!W_ERROR_IS_OK(result)) {
 		return result;
+	}
 
 	/* now continue to load each subkey registry tree */
 
 	key->subkey_index = 0;
-	while ( (subkey = regfio_fetch_subkey( regfile, key )) ) {
+	while ((subkey = regfio_fetch_subkey(regfile, key))) {
 		path = talloc_asprintf(regfile->mem_ctx,
-				"%s\\%s",
-				topkeypath,
-				subkey->keyname);
-		if (!path) {
+				       "%s\\%s",
+				       topkeypath,
+				       subkey->keyname);
+		if (path == NULL) {
 			return WERR_NOMEM;
 		}
-		result = reg_load_tree( regfile, path, subkey );
-		if ( !W_ERROR_IS_OK(result) )
+		result = reg_load_tree(regfile, path, subkey);
+		if (!W_ERROR_IS_OK(result)) {
 			break;
+		}
 	}
 
 	return result;
@@ -785,33 +794,34 @@ static WERROR reg_load_tree( REGF_FILE *regfile, const char *topkeypath,
 /*******************************************************************
  ********************************************************************/
 
-static WERROR restore_registry_key ( REGISTRY_KEY *krecord, const char *fname )
+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 )) );
-        }
-	
+
+	regfile = regfio_open(fname, (O_RDONLY), 0);
+	if (regfile == NULL) {
+		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 );
+
+	if (!(rootkey = regfio_rootkey(regfile))) {
+		regfio_close(regfile);
 		return WERR_REG_FILE_INVALID;
 	}
 
-	result = reg_load_tree( regfile, krecord->name, rootkey );
+	result = reg_load_tree(regfile, krecord->name, rootkey);
 
 	/* cleanup */
 
-	regfio_close( regfile );
+	regfio_close(regfile);
 
 	return result;
 }
@@ -824,8 +834,8 @@ WERROR reg_restorekey(struct registry_key *key, const char *fname)
 /********************************************************************
 ********************************************************************/
 
-static WERROR reg_write_tree( REGF_FILE *regfile, const char *keypath,
-                              REGF_NK_REC *parent, SEC_DESC *sec_desc )
+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;
@@ -838,11 +848,13 @@ static WERROR reg_write_tree( REGF_FILE *regfile, const char *keypath,
 	REGISTRY_KEY registry_key;
 	WERROR result = WERR_OK;
 
-	if (!regfile)
+	if (!regfile) {
 		return WERR_GENERAL_FAILURE;
+	}
 
-	if (!keypath)
+	if (!keypath) {
 		return WERR_OBJECT_PATH_INVALID;
+	}
 
 	/* split up the registry key path */
 
@@ -850,61 +862,73 @@ static WERROR reg_write_tree( REGF_FILE *regfile, const char *keypath,
 	if (!key_tmp) {
 		return WERR_NOMEM;
 	}
-	if (!reg_split_key( key_tmp, &parentpath, &keyname ) )
+	if (!reg_split_key(key_tmp, &parentpath, &keyname)) {
 		return WERR_OBJECT_PATH_INVALID;
+	}
 
-	if ( !keyname )
+	if (!keyname) {
 		keyname = parentpath;
+	}
 
 	/* we need a REGISTRY_KEY object here to enumerate subkeys and values */
 
-	ZERO_STRUCT( registry_key );
+	ZERO_STRUCT(registry_key);
 
-	if ( (registry_key.name = talloc_strdup(regfile->mem_ctx, keypath)) == NULL )
+	registry_key.name = talloc_strdup(regfile->mem_ctx, keypath);
+	if (registry_key.name == NULL) {
 		return WERR_NOMEM;
+	}
 
-	if ( (registry_key.hook = reghook_cache_find( registry_key.name )) == NULL )
+	registry_key.hook = reghook_cache_find(registry_key.name);
+	if (registry_key.hook == NULL) {
 		return WERR_BADFILE;
+	}
 
 	/* lookup the values and subkeys */
 
-	if ( !(subkeys = TALLOC_ZERO_P( regfile->mem_ctx, REGSUBKEY_CTR )) )
+	subkeys = TALLOC_ZERO_P(regfile->mem_ctx, REGSUBKEY_CTR);
+	if (subkeys == NULL) {
 		return WERR_NOMEM;
+	}
 
-	if ( !(values = TALLOC_ZERO_P( subkeys, REGVAL_CTR )) )
+	values = TALLOC_ZERO_P(subkeys, REGVAL_CTR);
+	if (values == NULL) {
 		return WERR_NOMEM;
+	}
 
-	fetch_reg_keys( &registry_key, subkeys );
-	fetch_reg_values( &registry_key, values );
+	fetch_reg_keys(&registry_key, subkeys);
+	fetch_reg_values(&registry_key, values);
 
 	/* write out this key */
 
-	if ( !(key = regfio_write_key( regfile, keyname, values, subkeys, sec_desc, parent )) ) {
+	key = regfio_write_key(regfile, keyname, values, subkeys, sec_desc,
+			       parent);
+	if (key == NULL) {
 		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 );
-		subkeypath = talloc_asprintf(regfile->mem_ctx,
-					"%s\\%s", keypath, subkeyname);
-		if (!subkeypath) {
+	num_subkeys = regsubkey_ctr_numkeys(subkeys);
+	for (i=0; i<num_subkeys; i++) {
+		subkeyname = regsubkey_ctr_specific_key(subkeys, i);
+		subkeypath = talloc_asprintf(regfile->mem_ctx, "%s\\%s",
+					     keypath, subkeyname);
+		if (subkeypath == NULL) {
 			result = WERR_NOMEM;
 			goto done;
 		}
-		result = reg_write_tree( regfile, subkeypath, key, sec_desc );
-		if ( !W_ERROR_IS_OK(result) )
+		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 ));
+	DEBUG(6, ("reg_write_tree: wrote key [%s]\n", keypath));
 
 done:
-	TALLOC_FREE( subkeys );
-	TALLOC_FREE( registry_key.name );
+	TALLOC_FREE(subkeys);
+	TALLOC_FREE(registry_key.name);
 
 	return result;
 }
@@ -912,7 +936,7 @@ done:
 static const struct generic_mapping reg_generic_map =
 	{ REG_KEY_READ, REG_KEY_WRITE, REG_KEY_EXECUTE, REG_KEY_ALL };
 
-static WERROR make_default_reg_sd( TALLOC_CTX *ctx, SEC_DESC **psd )
+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 */
@@ -928,8 +952,10 @@ static WERROR make_default_reg_sd( TALLOC_CTX *ctx, SEC_DESC **psd )
 
 	/* 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);
+	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' */
 
@@ -938,45 +964,52 @@ static WERROR make_default_reg_sd( TALLOC_CTX *ctx, SEC_DESC **psd )
 	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 */
+	/* create the security descriptor */
 
-        if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, 2, ace)) == NULL)
-                return WERR_NOMEM;
+	psa = make_sec_acl(ctx, NT4_ACL_REVISION, 2, ace);
+	if (psa == NULL) {
+		return WERR_NOMEM;
+	}
 
-        if ((*psd = make_sec_desc(ctx, SECURITY_DESCRIPTOR_REVISION_1,
-				  SEC_DESC_SELF_RELATIVE, &owner_sid, NULL,
-				  NULL, psa, &sd_size)) == NULL)
-                return WERR_NOMEM;
+	*psd = make_sec_desc(ctx, SECURITY_DESCRIPTOR_REVISION_1,
+			     SEC_DESC_SELF_RELATIVE, &owner_sid, NULL,
+			     NULL, psa, &sd_size);
+	if (*psd == NULL) {
+		return WERR_NOMEM;
+	}
 
 	return WERR_OK;
 }
 
-static WERROR backup_registry_key ( REGISTRY_KEY *krecord, const char *fname )
+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 )) );
-        }
+	regfile = regfio_open(fname, (O_RDWR|O_CREAT|O_EXCL),
+			      (S_IREAD|S_IWRITE));
+	if (regfile == NULL) {
+		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 );
+	result = make_default_reg_sd(regfile->mem_ctx, &sd);
+	if (!W_ERROR_IS_OK(result)) {
+		regfio_close(regfile);
 		return result;
 	}
 
 	/* write the registry tree to the file  */
 
-	result = reg_write_tree( regfile, krecord->name, NULL, sd );
+	result = reg_write_tree(regfile, krecord->name, NULL, sd);
 
 	/* cleanup */
 
-	regfio_close( regfile );
+	regfio_close(regfile);
 
 	return result;
 }