summaryrefslogtreecommitdiff
path: root/source4/registry
diff options
context:
space:
mode:
Diffstat (limited to 'source4/registry')
-rw-r--r--source4/registry/reg_cachehook.c112
-rw-r--r--source4/registry/reg_db.c311
-rw-r--r--source4/registry/reg_frontend.c260
-rw-r--r--source4/registry/reg_objects.c374
4 files changed, 0 insertions, 1057 deletions
diff --git a/source4/registry/reg_cachehook.c b/source4/registry/reg_cachehook.c
deleted file mode 100644
index 547eed392d..0000000000
--- a/source4/registry/reg_cachehook.c
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Unix SMB/CIFS implementation.
- * RPC Pipe client / server routines
- * Copyright (C) Gerald Carter 2002.
- *
- * 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
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * 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.
- */
-
-/* Implementation of registry hook cache tree */
-
-#include "includes.h"
-
-#undef DBGC_CLASS
-#define DBGC_CLASS DBGC_RPC_SRV
-
-static SORTED_TREE *cache_tree;
-extern REGISTRY_OPS regdb_ops; /* these are the default */
-static REGISTRY_HOOK default_hook = { KEY_TREE_ROOT, &regdb_ops };
-
-/**********************************************************************
- Initialize the cache tree
- *********************************************************************/
-
-BOOL reghook_cache_init( void )
-{
- cache_tree = sorted_tree_init( &default_hook, NULL, NULL );
-
- return ( cache_tree == NULL );
-}
-
-/**********************************************************************
- Add a new REGISTRY_HOOK to the cache. Note that the keyname
- is not in the exact format that a SORTED_TREE expects.
- *********************************************************************/
-
-BOOL reghook_cache_add( REGISTRY_HOOK *hook )
-{
- pstring key;
-
- if ( !hook )
- return False;
-
- pstrcpy( key, "\\");
- pstrcat( key, hook->keyname );
-
- pstring_sub( key, "\\", "/" );
-
- DEBUG(10,("reghook_cache_add: Adding key [%s]\n", key));
-
- return sorted_tree_add( cache_tree, key, hook );
-}
-
-/**********************************************************************
- Initialize the cache tree
- *********************************************************************/
-
-REGISTRY_HOOK* reghook_cache_find( char *keyname )
-{
- char *key;
- int len;
- REGISTRY_HOOK *hook;
-
- if ( !keyname )
- return NULL;
-
- /* prepend the string with a '\' character */
-
- len = strlen( keyname );
- if ( !(key = malloc( len + 2 )) ) {
- DEBUG(0,("reghook_cache_find: malloc failed for string [%s] !?!?!\n",
- keyname));
- return NULL;
- }
-
- *key = '\\';
- strncpy( key+1, keyname, len+1);
-
- /* swap to a form understood by the SORTED_TREE */
-
- string_sub( key, "\\", "/", 0 );
-
- DEBUG(10,("reghook_cache_find: Searching for keyname [%s]\n", key));
-
- hook = sorted_tree_find( cache_tree, key ) ;
-
- SAFE_FREE( key );
-
- return hook;
-}
-
-/**********************************************************************
- Initialize the cache tree
- *********************************************************************/
-
-void reghook_dump_cache( int debuglevel )
-{
- DEBUG(debuglevel,("reghook_dump_cache: Starting cache dump now...\n"));
-
- sorted_tree_print_keys( cache_tree, debuglevel );
-}
diff --git a/source4/registry/reg_db.c b/source4/registry/reg_db.c
deleted file mode 100644
index b0917c8f60..0000000000
--- a/source4/registry/reg_db.c
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * Unix SMB/CIFS implementation.
- * RPC Pipe client / server routines
- * Copyright (C) Gerald Carter 2002.
- *
- * 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
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * 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.
- */
-
-/* Implementation of internal registry database functions. */
-
-#include "includes.h"
-
-#undef DBGC_CLASS
-#define DBGC_CLASS DBGC_RPC_SRV
-
-static TDB_CONTEXT *tdb_reg;
-
-
-/***********************************************************************
- Open the registry data in the tdb
- ***********************************************************************/
-
-static BOOL init_registry_data( void )
-{
- pstring keyname;
- REGSUBKEY_CTR subkeys;
-
- ZERO_STRUCTP( &subkeys );
-
- /* HKEY_LOCAL_MACHINE */
-
- regsubkey_ctr_init( &subkeys );
- pstrcpy( keyname, KEY_HKLM );
- regsubkey_ctr_addkey( &subkeys, "SYSTEM" );
- if ( !regdb_store_reg_keys( keyname, &subkeys ))
- return False;
- regsubkey_ctr_destroy( &subkeys );
-
- regsubkey_ctr_init( &subkeys );
- pstrcpy( keyname, KEY_HKLM );
- pstrcat( keyname, "/SYSTEM" );
- regsubkey_ctr_addkey( &subkeys, "CurrentControlSet" );
- if ( !regdb_store_reg_keys( keyname, &subkeys ))
- return False;
- regsubkey_ctr_destroy( &subkeys );
-
- regsubkey_ctr_init( &subkeys );
- pstrcpy( keyname, KEY_HKLM );
- pstrcat( keyname, "/SYSTEM/CurrentControlSet" );
- regsubkey_ctr_addkey( &subkeys, "Control" );
- regsubkey_ctr_addkey( &subkeys, "Services" );
- if ( !regdb_store_reg_keys( keyname, &subkeys ))
- return False;
- regsubkey_ctr_destroy( &subkeys );
-
- regsubkey_ctr_init( &subkeys );
- pstrcpy( keyname, KEY_HKLM );
- pstrcat( keyname, "/SYSTEM/CurrentControlSet/Control" );
- regsubkey_ctr_addkey( &subkeys, "Print" );
- regsubkey_ctr_addkey( &subkeys, "ProductOptions" );
- if ( !regdb_store_reg_keys( keyname, &subkeys ))
- return False;
- regsubkey_ctr_destroy( &subkeys );
-
- pstrcpy( keyname, KEY_HKLM );
- pstrcat( keyname, "/SYSTEM/CurrentControlSet/Control/ProductOptions" );
- if ( !regdb_store_reg_keys( keyname, &subkeys ))
- return False;
-
- regsubkey_ctr_init( &subkeys );
- pstrcpy( keyname, KEY_HKLM );
- pstrcat( keyname, "/SYSTEM/CurrentControlSet/Services" );
- regsubkey_ctr_addkey( &subkeys, "Netlogon" );
- if ( !regdb_store_reg_keys( keyname, &subkeys ))
- return False;
- regsubkey_ctr_destroy( &subkeys );
-
- regsubkey_ctr_init( &subkeys );
- pstrcpy( keyname, KEY_HKLM );
- pstrcat( keyname, "/SYSTEM/CurrentControlSet/Services/Netlogon" );
- regsubkey_ctr_addkey( &subkeys, "Parameters" );
- if ( !regdb_store_reg_keys( keyname, &subkeys ))
- return False;
- regsubkey_ctr_destroy( &subkeys );
-
- pstrcpy( keyname, KEY_HKLM );
- pstrcat( keyname, "/SYSTEM/CurrentControlSet/Services/Netlogon/Parameters" );
- if ( !regdb_store_reg_keys( keyname, &subkeys ))
- return False;
-
- /* HKEY_USER */
-
- pstrcpy( keyname, KEY_HKU );
- if ( !regdb_store_reg_keys( keyname, &subkeys ) )
- return False;
-
- /* HKEY_CLASSES_ROOT*/
-
- pstrcpy( keyname, KEY_HKCR );
- if ( !regdb_store_reg_keys( keyname, &subkeys ) )
- return False;
-
- return True;
-}
-
-/***********************************************************************
- Open the registry database
- ***********************************************************************/
-
-BOOL init_registry_db( void )
-{
- static pid_t local_pid;
-
- if (tdb_reg && local_pid == sys_getpid())
- return True;
-
- /*
- * try to open first without creating so we can determine
- * if we need to init the data in the registry
- */
-
- tdb_reg = tdb_open_log(lock_path("registry.tdb"), 0, TDB_DEFAULT, O_RDWR, 0600);
- if ( !tdb_reg )
- {
- tdb_reg = tdb_open_log(lock_path("registry.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
- if ( !tdb_reg ) {
- DEBUG(0,("init_registry: Failed to open registry %s (%s)\n",
- lock_path("registry.tdb"), strerror(errno) ));
- return False;
- }
-
- DEBUG(10,("init_registry: Successfully created registry tdb\n"));
-
- /* create the registry here */
- if ( !init_registry_data() ) {
- DEBUG(0,("init_registry: Failed to initiailize data in registry!\n"));
- return False;
- }
- }
-
- local_pid = sys_getpid();
-
- return True;
-}
-
-
-
-/***********************************************************************
- Add subkey strings to the registry tdb under a defined key
- fmt is the same format as tdb_pack except this function only supports
- fstrings
-
- The full path to the registry key is used as database after the
- \'s are converted to /'s. Key string is also normalized to UPPER
- case.
- ***********************************************************************/
-
-BOOL regdb_store_reg_keys( char *keyname, REGSUBKEY_CTR *ctr )
-{
- TDB_DATA kbuf, dbuf;
- char *buffer, *tmpbuf;
- int i = 0;
- uint32 len, buflen;
- BOOL ret = True;
- uint32 num_subkeys = regsubkey_ctr_numkeys( ctr );
-
- if ( !keyname )
- return False;
-
- strupper_m( keyname );
-
- /* allocate some initial memory */
-
- buffer = malloc(sizeof(pstring));
- buflen = sizeof(pstring);
- len = 0;
-
- /* store the number of subkeys */
-
- len += tdb_pack(buffer+len, buflen-len, "d", num_subkeys );
-
- /* pack all the strings */
-
- for (i=0; i<num_subkeys; i++) {
- len += tdb_pack( buffer+len, buflen-len, "f", regsubkey_ctr_specific_key(ctr, i) );
- if ( len > buflen ) {
- /* allocate some extra space */
- if ((tmpbuf = Realloc( buffer, len*2 )) == NULL) {
- DEBUG(0,("regdb_store_reg_keys: Failed to realloc memory of size [%d]\n", len*2));
- ret = False;
- goto done;
- }
- buffer = tmpbuf;
- buflen = len*2;
-
- len = tdb_pack( buffer+len, buflen-len, "f", regsubkey_ctr_specific_key(ctr, i) );
- }
- }
-
- /* finally write out the data */
-
- kbuf.dptr = keyname;
- kbuf.dsize = strlen(keyname)+1;
- dbuf.dptr = buffer;
- dbuf.dsize = len;
- if ( tdb_store( tdb_reg, kbuf, dbuf, TDB_REPLACE ) == -1) {
- ret = False;
- goto done;
- }
-
-done:
- SAFE_FREE( buffer );
-
- return ret;
-}
-
-/***********************************************************************
- Retrieve an array of strings containing subkeys. Memory should be
- released by the caller. The subkeys are stored in a catenated string
- of null terminated character strings
- ***********************************************************************/
-
-int regdb_fetch_reg_keys( char* key, REGSUBKEY_CTR *ctr )
-{
- pstring path;
- uint32 num_items;
- TDB_DATA dbuf;
- char *buf;
- uint32 buflen, len;
- int i;
- fstring subkeyname;
-
- DEBUG(10,("regdb_fetch_reg_keys: Enter key => [%s]\n", key ? key : "NULL"));
-
- pstrcpy( path, key );
-
- /* convert to key format */
- pstring_sub( path, "\\", "/" );
- strupper_m( path );
-
- dbuf = tdb_fetch_by_string( tdb_reg, path );
-
- buf = dbuf.dptr;
- buflen = dbuf.dsize;
-
- if ( !buf ) {
- DEBUG(5,("regdb_fetch_reg_keys: tdb lookup failed to locate key [%s]\n", key));
- return -1;
- }
-
- len = tdb_unpack( buf, buflen, "d", &num_items);
-
- for (i=0; i<num_items; i++) {
- len += tdb_unpack( buf+len, buflen-len, "f", subkeyname );
- regsubkey_ctr_addkey( ctr, subkeyname );
- }
-
- SAFE_FREE( dbuf.dptr );
-
- DEBUG(10,("regdb_fetch_reg_keys: Exit [%d] items\n", num_items));
-
- return num_items;
-}
-
-
-/***********************************************************************
- Retrieve an array of strings containing subkeys. Memory should be
- released by the caller. The subkeys are stored in a catenated string
- of null terminated character strings
- ***********************************************************************/
-
-int regdb_fetch_reg_values( char* key, REGVAL_CTR *val )
-{
- return 0;
-}
-
-/***********************************************************************
- Stub function since we do not currently support storing registry
- values in the registry.tdb
- ***********************************************************************/
-
-BOOL regdb_store_reg_values( char *key, REGVAL_CTR *val )
-{
- return False;
-}
-
-
-/*
- * Table of function pointers for default access
- */
-
-REGISTRY_OPS regdb_ops = {
- regdb_fetch_reg_keys,
- regdb_fetch_reg_values,
- regdb_store_reg_keys,
- regdb_store_reg_values
-};
-
-
diff --git a/source4/registry/reg_frontend.c b/source4/registry/reg_frontend.c
deleted file mode 100644
index a9dfb52f01..0000000000
--- a/source4/registry/reg_frontend.c
+++ /dev/null
@@ -1,260 +0,0 @@
-/*
- * Unix SMB/CIFS implementation.
- * RPC Pipe client / server routines
- * Copyright (C) Gerald Carter 2002.
- *
- * 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
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * 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.
- */
-
-/* Implementation of registry frontend view functions. */
-
-#include "includes.h"
-
-#undef DBGC_CLASS
-#define DBGC_CLASS DBGC_RPC_SRV
-
-extern REGISTRY_OPS printing_ops;
-extern REGISTRY_OPS regdb_ops; /* these are the default */
-
-/* array of REGISTRY_HOOK's which are read into a tree for easy access */
-
-
-REGISTRY_HOOK reg_hooks[] = {
- { KEY_PRINTING, &printing_ops },
- { NULL, NULL }
-};
-
-
-/***********************************************************************
- Open the registry database and initialize the REGISTRY_HOOK cache
- ***********************************************************************/
-
-BOOL init_registry( void )
-{
- int i;
-
- if ( !init_registry_db() ) {
- DEBUG(0,("init_registry: failed to initialize the registry tdb!\n"));
- return False;
- }
-
- /* build the cache tree of registry hooks */
-
- reghook_cache_init();
-
- for ( i=0; reg_hooks[i].keyname; i++ ) {
- if ( !reghook_cache_add(&reg_hooks[i]) )
- return False;
- }
-
- if ( DEBUGLEVEL >= 20 )
- reghook_dump_cache(20);
-
- return True;
-}
-
-
-
-
-/***********************************************************************
- High level wrapper function for storing registry subkeys
- ***********************************************************************/
-
-BOOL store_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkeys )
-{
- if ( key->hook && key->hook->ops && key->hook->ops->store_subkeys_fn )
- return key->hook->ops->store_subkeys_fn( key->name, subkeys );
- else
- return False;
-
-}
-
-/***********************************************************************
- High level wrapper function for storing registry values
- ***********************************************************************/
-
-BOOL store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
-{
- if ( key->hook && key->hook->ops && key->hook->ops->store_values_fn )
- return key->hook->ops->store_values_fn( key->name, val );
- else
- return False;
-}
-
-
-/***********************************************************************
- High level wrapper function for enumerating registry subkeys
- Initialize the TALLOC_CTX if necessary
- ***********************************************************************/
-
-int fetch_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkey_ctr )
-{
- int result = -1;
-
- if ( key->hook && key->hook->ops && key->hook->ops->subkey_fn )
- result = key->hook->ops->subkey_fn( key->name, subkey_ctr );
-
- return result;
-}
-
-/***********************************************************************
- retreive a specific subkey specified by index. Caller is
- responsible for freeing memory
- ***********************************************************************/
-
-BOOL fetch_reg_keys_specific( REGISTRY_KEY *key, char** subkey, uint32 key_index )
-{
- static REGSUBKEY_CTR ctr;
- static pstring save_path;
- static BOOL ctr_init = False;
- char *s;
-
- *subkey = NULL;
-
- /* simple caching for performance; very basic heuristic */
-
- if ( !ctr_init ) {
- DEBUG(8,("fetch_reg_keys_specific: Initializing cache of subkeys for [%s]\n", key->name));
- ZERO_STRUCTP( &ctr );
- regsubkey_ctr_init( &ctr );
-
- pstrcpy( save_path, key->name );
-
- if ( fetch_reg_keys( key, &ctr) == -1 )
- return False;
-
- ctr_init = True;
- }
- /* clear the cache when key_index == 0 or the path has changed */
- else if ( !key_index || StrCaseCmp( save_path, key->name) ) {
-
- DEBUG(8,("fetch_reg_keys_specific: Updating cache of subkeys for [%s]\n", key->name));
-
- regsubkey_ctr_destroy( &ctr );
- regsubkey_ctr_init( &ctr );
-
- pstrcpy( save_path, key->name );
-
- if ( fetch_reg_keys( key, &ctr) == -1 )
- return False;
- }
-
- if ( !(s = regsubkey_ctr_specific_key( &ctr, key_index )) )
- return False;
-
- *subkey = strdup( s );
-
- return True;
-}
-
-
-/***********************************************************************
- High level wrapper function for enumerating registry values
- Initialize the TALLOC_CTX if necessary
- ***********************************************************************/
-
-int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
-{
- int result = -1;
-
- if ( key->hook && key->hook->ops && key->hook->ops->value_fn )
- result = key->hook->ops->value_fn( key->name, val );
-
- return result;
-}
-
-
-/***********************************************************************
- retreive a specific subkey specified by index. Caller is
- responsible for freeing memory
- ***********************************************************************/
-
-BOOL fetch_reg_values_specific( REGISTRY_KEY *key, REGISTRY_VALUE **val, uint32 val_index )
-{
- static REGVAL_CTR ctr;
- static pstring save_path;
- static BOOL ctr_init = False;
- REGISTRY_VALUE *v;
-
- *val = NULL;
-
- /* simple caching for performance; very basic heuristic */
-
- if ( !ctr_init ) {
- DEBUG(8,("fetch_reg_values_specific: Initializing cache of values for [%s]\n", key->name));
-
- ZERO_STRUCTP( &ctr );
- regval_ctr_init( &ctr );
-
- pstrcpy( save_path, key->name );
-
- if ( fetch_reg_values( key, &ctr) == -1 )
- return False;
-
- ctr_init = True;
- }
- /* clear the cache when val_index == 0 or the path has changed */
- else if ( !val_index || StrCaseCmp(save_path, key->name) ) {
-
- DEBUG(8,("fetch_reg_values_specific: Updating cache of values for [%s]\n", key->name));
-
- regval_ctr_destroy( &ctr );
- regval_ctr_init( &ctr );
-
- pstrcpy( save_path, key->name );
-
- if ( fetch_reg_values( key, &ctr) == -1 )
- return False;
- }
-
- if ( !(v = regval_ctr_specific_value( &ctr, val_index )) )
- return False;
-
- *val = dup_registry_value( v );
-
- return True;
-}
-
-/***********************************************************************
- Utility function for splitting the base path of a registry path off
- by setting base and new_path to the apprapriate offsets withing the
- path.
-
- WARNING!! Does modify the original string!
- ***********************************************************************/
-
-BOOL reg_split_path( char *path, char **base, char **new_path )
-{
- char *p;
-
- *new_path = *base = NULL;
-
- if ( !path)
- return False;
-
- *base = path;
-
- p = strchr( path, '\\' );
-
- if ( p ) {
- *p = '\0';
- *new_path = p+1;
- }
-
- return True;
-}
-
-
-
diff --git a/source4/registry/reg_objects.c b/source4/registry/reg_objects.c
deleted file mode 100644
index 9cfeb7faa9..0000000000
--- a/source4/registry/reg_objects.c
+++ /dev/null
@@ -1,374 +0,0 @@
-/*
- * Unix SMB/CIFS implementation.
- * RPC Pipe client / server routines
- * Copyright (C) Gerald Carter 2002.
- *
- * 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
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * 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.
- */
-
-/* Implementation of registry frontend view functions. */
-
-#include "includes.h"
-
-#undef DBGC_CLASS
-#define DBGC_CLASS DBGC_RPC_SRV
-
-
-/***********************************************************************
- Init the talloc context held by a REGSUBKEY_CTR structure
- **********************************************************************/
-
-void regsubkey_ctr_init( REGSUBKEY_CTR *ctr )
-{
- if ( !ctr->ctx )
- ctr->ctx = talloc_init("regsubkey_ctr_init for ctr %p", ctr);
-}
-
-/***********************************************************************
- Add a new key to the array
- **********************************************************************/
-
-int regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, const char *keyname )
-{
- uint32 len;
- char **pp;
-
- if ( keyname )
- {
- len = strlen( keyname );
-
- /* allocate a space for the char* in the array */
-
- if ( ctr->subkeys == 0 )
- ctr->subkeys = talloc( ctr->ctx, sizeof(char*) );
- else {
- pp = talloc_realloc( ctr->ctx, ctr->subkeys, sizeof(char*)*(ctr->num_subkeys+1) );
- if ( pp )
- ctr->subkeys = pp;
- }
-
- /* allocate the string and save it in the array */
-
- ctr->subkeys[ctr->num_subkeys] = talloc( ctr->ctx, len+1 );
- strncpy( ctr->subkeys[ctr->num_subkeys], keyname, len+1 );
- ctr->num_subkeys++;
- }
-
- return ctr->num_subkeys;
-}
-
-/***********************************************************************
- How many keys does the container hold ?
- **********************************************************************/
-
-int regsubkey_ctr_numkeys( REGSUBKEY_CTR *ctr )
-{
- return ctr->num_subkeys;
-}
-
-/***********************************************************************
- Retreive a specific key string
- **********************************************************************/
-
-char* regsubkey_ctr_specific_key( REGSUBKEY_CTR *ctr, uint32 key_index )
-{
- if ( ! (key_index < ctr->num_subkeys) )
- return NULL;
-
- return ctr->subkeys[key_index];
-}
-
-/***********************************************************************
- free memory held by a REGSUBKEY_CTR structure
- **********************************************************************/
-
-void regsubkey_ctr_destroy( REGSUBKEY_CTR *ctr )
-{
- if ( ctr ) {
- talloc_destroy( ctr->ctx );
- ZERO_STRUCTP( ctr );
- }
-}
-
-
-/*
- * Utility functions for REGVAL_CTR
- */
-
-/***********************************************************************
- Init the talloc context held by a REGSUBKEY_CTR structure
- **********************************************************************/
-
-void regval_ctr_init( REGVAL_CTR *ctr )
-{
- if ( !ctr->ctx )
- ctr->ctx = talloc_init("regval_ctr_init for ctr %p", ctr);
-}
-
-/***********************************************************************
- How many keys does the container hold ?
- **********************************************************************/
-
-int regval_ctr_numvals( REGVAL_CTR *ctr )
-{
- return ctr->num_values;
-}
-
-/***********************************************************************
- allocate memory for and duplicate a REGISTRY_VALUE.
- This is malloc'd memory so the caller should free it when done
- **********************************************************************/
-
-REGISTRY_VALUE* dup_registry_value( REGISTRY_VALUE *val )
-{
- REGISTRY_VALUE *copy = NULL;
-
- if ( !val )
- return NULL;
-
- if ( !(copy = malloc( sizeof(REGISTRY_VALUE) )) ) {
- DEBUG(0,("dup_registry_value: malloc() failed!\n"));
- return NULL;
- }
-
- /* copy all the non-pointer initial data */
-
- memcpy( copy, val, sizeof(REGISTRY_VALUE) );
- if ( val->data_p )
- {
- if ( !(copy->data_p = memdup( val->data_p, val->size )) ) {
- DEBUG(0,("dup_registry_value: memdup() failed for [%d] bytes!\n",
- val->size));
- SAFE_FREE( copy );
- }
- }
-
- return copy;
-}
-
-/**********************************************************************
- free the memory allocated to a REGISTRY_VALUE
- *********************************************************************/
-
-void free_registry_value( REGISTRY_VALUE *val )
-{
- if ( !val )
- return;
-
- SAFE_FREE( val->data_p );
- SAFE_FREE( val );
-
- return;
-}
-
-/**********************************************************************
- *********************************************************************/
-
-uint8* regval_data_p( REGISTRY_VALUE *val )
-{
- return val->data_p;
-}
-
-/**********************************************************************
- *********************************************************************/
-
-int regval_size( REGISTRY_VALUE *val )
-{
- return val->size;
-}
-
-/**********************************************************************
- *********************************************************************/
-
-char* regval_name( REGISTRY_VALUE *val )
-{
- return val->valuename;
-}
-
-/**********************************************************************
- *********************************************************************/
-
-uint32 regval_type( REGISTRY_VALUE *val )
-{
- return val->type;
-}
-
-/***********************************************************************
- Retreive a pointer to a specific value. Caller shoud dup the structure
- since this memory may go away with a regval_ctr_destroy()
- **********************************************************************/
-
-REGISTRY_VALUE* regval_ctr_specific_value( REGVAL_CTR *ctr, uint32 idx )
-{
- if ( !(idx < ctr->num_values) )
- return NULL;
-
- return ctr->values[idx];
-}
-
-/***********************************************************************
- Retrive the TALLOC_CTX associated with a REGISTRY_VALUE
- **********************************************************************/
-
-TALLOC_CTX* regval_ctr_getctx( REGVAL_CTR *val )
-{
- if ( !val )
- return NULL;
-
- return val->ctx;
-}
-
-/***********************************************************************
- Add a new registry value to the array
- **********************************************************************/
-
-int regval_ctr_addvalue( REGVAL_CTR *ctr, const char *name, uint16 type,
- const char *data_p, size_t size )
-{
- REGISTRY_VALUE **ppreg;
-
- if ( name )
- {
- /* allocate a slot in the array of pointers */
-
- if ( ctr->num_values == 0 )
- ctr->values = talloc( ctr->ctx, sizeof(REGISTRY_VALUE*) );
- else {
- ppreg = talloc_realloc( ctr->ctx, ctr->values, sizeof(REGISTRY_VALUE*)*(ctr->num_values+1) );
- if ( ppreg )
- ctr->values = ppreg;
- }
-
- /* allocate a new value and store the pointer in the arrya */
-
- ctr->values[ctr->num_values] = talloc( ctr->ctx, sizeof(REGISTRY_VALUE) );
-
- /* init the value */
-
- fstrcpy( ctr->values[ctr->num_values]->valuename, name );
- ctr->values[ctr->num_values]->type = type;
- ctr->values[ctr->num_values]->data_p = talloc_memdup( ctr->ctx, data_p, size );
- ctr->values[ctr->num_values]->size = size;
- ctr->num_values++;
- }
-
- return ctr->num_values;
-}
-
-/***********************************************************************
- Add a new registry value to the array
- **********************************************************************/
-
-int regval_ctr_copyvalue( REGVAL_CTR *ctr, REGISTRY_VALUE *val )
-{
- REGISTRY_VALUE **ppreg;
-
- if ( val )
- {
- /* allocate a slot in the array of pointers */
-
- if ( ctr->num_values == 0 )
- ctr->values = talloc( ctr->ctx, sizeof(REGISTRY_VALUE*) );
- else {
- ppreg = talloc_realloc( ctr->ctx, ctr->values, sizeof(REGISTRY_VALUE*)*(ctr->num_values+1) );
- if ( ppreg )
- ctr->values = ppreg;
- }
-
- /* allocate a new value and store the pointer in the arrya */
-
- ctr->values[ctr->num_values] = talloc( ctr->ctx, sizeof(REGISTRY_VALUE) );
-
- /* init the value */
-
- fstrcpy( ctr->values[ctr->num_values]->valuename, val->valuename );
- ctr->values[ctr->num_values]->type = val->type;
- ctr->values[ctr->num_values]->data_p = talloc_memdup( ctr->ctx, val->data_p, val->size );
- ctr->values[ctr->num_values]->size = val->size;
- ctr->num_values++;
- }
-
- return ctr->num_values;
-}
-
-/***********************************************************************
- Delete a single value from the registry container.
- No need to free memory since it is talloc'd.
- **********************************************************************/
-
-int regval_ctr_delvalue( REGVAL_CTR *ctr, const char *name )
-{
- int i;
-
- /* search for the value */
- if (!(ctr->num_values))
- return 0;
-
- for ( i=0; i<ctr->num_values; i++ ) {
- if ( strcmp( ctr->values[i]->valuename, name ) == 0)
- break;
- }
-
- /* just return if we don't find it */
-
- if ( i == ctr->num_values )
- return ctr->num_values;
-
- /* just shift everything down one */
-
- for ( /* use previous i */; i<(ctr->num_values-1); i++ )
- memcpy( ctr->values[i], ctr->values[i+1], sizeof(REGISTRY_VALUE) );
-
- /* paranoia */
-
- ZERO_STRUCTP( ctr->values[i] );
-
- ctr->num_values--;
-
- return ctr->num_values;
-}
-
-/***********************************************************************
- Delete a single value from the registry container.
- No need to free memory since it is talloc'd.
- **********************************************************************/
-
-REGISTRY_VALUE* regval_ctr_getvalue( REGVAL_CTR *ctr, const char *name )
-{
- int i;
-
- /* search for the value */
-
- for ( i=0; i<ctr->num_values; i++ ) {
- if ( strequal( ctr->values[i]->valuename, name ) )
- return ctr->values[i];
- }
-
- return NULL;
-}
-
-/***********************************************************************
- free memory held by a REGVAL_CTR structure
- **********************************************************************/
-
-void regval_ctr_destroy( REGVAL_CTR *ctr )
-{
- if ( ctr ) {
- talloc_destroy( ctr->ctx );
- ZERO_STRUCTP( ctr );
- }
-}
-
-
generated by cgit (git 2.34.1) at 2024-09-30 08:49:45 +0000