{
struct sockaddr_un sunaddr;
struct stat st;
- pstring path;
+ char *path = NULL;
int fd;
int wait_time;
int slept;
-
+
/* Check permissions on unix socket directory */
-
+
if (lstat(dir, &st) == -1) {
return -1;
}
-
- if (!S_ISDIR(st.st_mode) ||
+
+ if (!S_ISDIR(st.st_mode) ||
(st.st_uid != 0 && st.st_uid != geteuid())) {
return -1;
}
-
+
/* Connect to socket */
-
- strncpy(path, dir, sizeof(path) - 1);
- path[sizeof(path) - 1] = '\0';
-
- strncat(path, "/", sizeof(path) - 1 - strlen(path));
- path[sizeof(path) - 1] = '\0';
-
- strncat(path, WINBINDD_SOCKET_NAME, sizeof(path) - 1 - strlen(path));
- path[sizeof(path) - 1] = '\0';
-
+
+ if (asprintf(&path, "%s/%s", dir, WINBINDD_SOCKET_NAME) < 0) {
+ return -1;
+ }
+
ZERO_STRUCT(sunaddr);
sunaddr.sun_family = AF_UNIX;
strncpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path) - 1);
-
+
/* If socket file doesn't exist, don't bother trying to connect
with retry. This is an attempt to make the system usable when
the winbindd daemon is not running. */
if (lstat(path, &st) == -1) {
+ SAFE_FREE(path);
return -1;
}
-
+
+ SAFE_FREE(path);
/* Check permissions on unix socket file */
-
- if (!S_ISSOCK(st.st_mode) ||
+
+ if (!S_ISSOCK(st.st_mode) ||
(st.st_uid != 0 && st.st_uid != geteuid())) {
return -1;
}
-
+
/* Connect to socket */
-
+
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
return -1;
}
bool reghook_cache_add( REGISTRY_HOOK *hook )
{
- pstring key;
-
- if ( !hook )
- return False;
-
- pstrcpy( key, "\\");
- pstrcat( key, hook->keyname );
-
- pstring_sub( key, "\\", "/" );
+ TALLOC_CTX *ctx = talloc_tos();
+ char *key = NULL;
+
+ if (!hook) {
+ return false;
+ }
+
+ key = talloc_asprintf(ctx, "//%s", hook->keyname);
+ if (!key) {
+ return false;
+ }
+ key = talloc_string_sub(ctx, key, "\\", "/");
+ if (!key) {
+ return false;
+ }
DEBUG(10,("reghook_cache_add: Adding key [%s]\n", key));
-
+
return pathtree_add( cache_tree, key, hook );
}
/***********************************************************************
Open the registry data in the tdb
***********************************************************************/
-
+
static bool init_registry_data( void )
{
- pstring path, base, remaining;
+ char *path = NULL;
+ char *base = NULL;
+ char *remaining = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
fstring keyname, subkeyname;
REGSUBKEY_CTR *subkeys;
REGVAL_CTR *values;
if ( tdb_transaction_start( tdb_reg->tdb ) == -1 ) {
DEBUG(0, ("init_registry_data: tdb_transaction_start "
"failed\n"));
- return False;
+ return false;
}
-
+
/* loop over all of the predefined paths and add each component */
-
+
for ( i=0; builtin_registry_paths[i] != NULL; i++ ) {
DEBUG(6,("init_registry_data: Adding [%s]\n", builtin_registry_paths[i]));
- pstrcpy( path, builtin_registry_paths[i] );
- pstrcpy( base, "" );
+ TALLOC_FREE(path);
+ path = talloc_strdup(ctx, builtin_registry_paths[i]);
+ TALLOC_FREE(base);
+ base = talloc_strdup(ctx, "");
+ if (!path || !base) {
+ goto fail;
+ }
p = path;
-
- while ( next_token(&p, keyname, "\\", sizeof(keyname)) ) {
-
+
+ while (next_token(&p, keyname, "\\", sizeof(keyname))) {
+
/* build up the registry path from the components */
-
- if ( *base )
- pstrcat( base, "\\" );
- pstrcat( base, keyname );
-
+
+ if (*base) {
+ base = talloc_asprintf(ctx, "%s\\", base);
+ if (!base) {
+ goto fail;
+ }
+ }
+ base = talloc_asprintf_append(base, "%s", keyname);
+ if (!base) {
+ goto fail;
+ }
+
/* get the immediate subkeyname (if we have one ) */
-
+
*subkeyname = '\0';
- if ( *p ) {
- pstrcpy( remaining, p );
+ if (*p) {
+ TALLOC_FREE(remaining);
+ remaining = talloc_strdup(ctx, p);
+ if (!remaining) {
+ goto fail;
+ }
p2 = remaining;
-
- if ( !next_token(&p2, subkeyname, "\\", sizeof(subkeyname)) )
+
+ if (!next_token(&p2, subkeyname, "\\",
+ sizeof(subkeyname))) {
fstrcpy( subkeyname, p2 );
+ }
}
DEBUG(10,("init_registry_data: Storing key [%s] with subkey [%s]\n",
base, *subkeyname ? subkeyname : "NULL"));
-
+
/* we don't really care if the lookup succeeds or not since
- we are about to update the record. We just want any
+ we are about to update the record. We just want any
subkeys already present */
-
- if ( !(subkeys = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR )) ) {
+
+ if ( !(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR )) ) {
DEBUG(0,("talloc() failure!\n"));
goto fail;
}
- regdb_fetch_keys( base, subkeys );
- if ( *subkeyname )
- regsubkey_ctr_addkey( subkeys, subkeyname );
- if ( !regdb_store_keys( base, subkeys ))
+ regdb_fetch_keys(base, subkeys);
+ if (*subkeyname) {
+ regsubkey_ctr_addkey( subkeys, subkeyname);
+ }
+ if (!regdb_store_keys( base, subkeys)) {
goto fail;
-
- TALLOC_FREE( subkeys );
+ }
+
+ TALLOC_FREE(subkeys);
}
}
/* loop over all of the predefined values and add each component */
-
- for ( i=0; builtin_registry_values[i].path != NULL; i++ ) {
- if ( !(values = TALLOC_ZERO_P( NULL, REGVAL_CTR )) ) {
- DEBUG(0,("talloc() failure!\n"));
+
+ for (i=0; builtin_registry_values[i].path != NULL; i++) {
+ if (!(values = TALLOC_ZERO_P(ctx, REGVAL_CTR))) {
goto fail;
}
- regdb_fetch_values( builtin_registry_values[i].path, values );
+ regdb_fetch_values( builtin_registry_values[i].path, values);
/* preserve existing values across restarts. Only add new ones */
- if ( !regval_ctr_key_exists( values, builtin_registry_values[i].valuename ) )
- {
- switch( builtin_registry_values[i].type ) {
+ if (!regval_ctr_key_exists(values, builtin_registry_values[i].valuename)) {
+ switch(builtin_registry_values[i].type) {
case REG_DWORD:
- regval_ctr_addvalue( values,
+ regval_ctr_addvalue( values,
builtin_registry_values[i].valuename,
REG_DWORD,
(char*)&builtin_registry_values[i].data.dw_value,
sizeof(uint32) );
break;
-
+
case REG_SZ:
init_unistr2( &data, builtin_registry_values[i].data.string, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values,
+ regval_ctr_addvalue( values,
builtin_registry_values[i].valuename,
REG_SZ,
(char*)data.buffer,
data.uni_str_len*sizeof(uint16) );
break;
-
+
default:
DEBUG(0,("init_registry_data: invalid value type in builtin_registry_values [%d]\n",
builtin_registry_values[i].type));
}
regdb_store_values( builtin_registry_values[i].path, values );
}
-
TALLOC_FREE( values );
}
-
+
if (tdb_transaction_commit( tdb_reg->tdb ) == -1) {
DEBUG(0, ("init_registry_data: Could not commit "
"transaction\n"));
- return False;
+ return false;
}
- return True;
+ return true;
fail:
"failed\n");
}
- return False;
+ return false;
}
/***********************************************************************
fmt is the same format as tdb_pack except this function only supports
fstrings
***********************************************************************/
-
-static bool regdb_store_keys_internal( const char *key, REGSUBKEY_CTR *ctr )
+
+static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr)
{
TDB_DATA dbuf;
- uint8 *buffer;
+ uint8 *buffer = NULL;
int i = 0;
uint32 len, buflen;
bool ret = True;
- uint32 num_subkeys = regsubkey_ctr_numkeys( ctr );
- pstring keyname;
-
- if ( !key )
- return False;
+ uint32 num_subkeys = regsubkey_ctr_numkeys(ctr);
+ char *keyname = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
- pstrcpy( keyname, key );
- normalize_reg_path( keyname );
+ if (!key) {
+ return false;
+ }
+
+ keyname = talloc_strdup(ctx, key);
+ if (!keyname) {
+ return false;
+ }
+ keyname = normalize_reg_path(ctx, keyname);
/* allocate some initial memory */
-
- if (!(buffer = (uint8 *)SMB_MALLOC(sizeof(pstring)))) {
+
+ if (!(buffer = (uint8 *)SMB_MALLOC(1024))) {
return False;
}
- buflen = sizeof(pstring);
+ buflen = 1024;
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 ) {
goto done;
}
buflen = len*2;
-
+
len = tdb_pack( buffer+len, buflen-len, "f", regsubkey_ctr_specific_key(ctr, i) );
- }
+ }
}
-
+
/* finally write out the data */
-
+
dbuf.dptr = buffer;
dbuf.dsize = len;
if ( tdb_store_bystring( tdb_reg->tdb, keyname, dbuf, TDB_REPLACE ) == -1) {
goto done;
}
-done:
+done:
SAFE_FREE( buffer );
-
return ret;
}
/***********************************************************************
- Store the new subkey record and create any child key records that
+ Store the new subkey record and create any child key records that
do not currently exist
***********************************************************************/
-bool regdb_store_keys( const char *key, REGSUBKEY_CTR *ctr )
+bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
{
int num_subkeys, i;
- pstring path;
+ char *path = NULL;
REGSUBKEY_CTR *subkeys = NULL, *old_subkeys = NULL;
- char *oldkeyname;
-
+ char *oldkeyname = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
+
/*
* fetch a list of the old subkeys so we can determine if anything has
* changed
*/
- if ( !(old_subkeys = TALLOC_ZERO_P( ctr, REGSUBKEY_CTR )) ) {
+ if (!(old_subkeys = TALLOC_ZERO_P(ctr, REGSUBKEY_CTR))) {
DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
- goto fail;
+ return false;
}
- regdb_fetch_keys( key, old_subkeys );
+ regdb_fetch_keys(key, old_subkeys);
if (ctr->num_subkeys == old_subkeys->num_subkeys) {
* transaction
*/
TALLOC_FREE(old_subkeys);
- return True;
+ return true;
}
}
- if ( tdb_transaction_start( tdb_reg->tdb ) == -1 ) {
+ if (tdb_transaction_start( tdb_reg->tdb ) == -1) {
DEBUG(0, ("regdb_store_keys: tdb_transaction_start failed\n"));
- return False;
+ return false;
}
/*
TALLOC_FREE(old_subkeys);
- if ( !(old_subkeys = TALLOC_ZERO_P( ctr, REGSUBKEY_CTR )) ) {
+ if (!(old_subkeys = TALLOC_ZERO_P(ctr, REGSUBKEY_CTR))) {
DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
goto fail;
}
- regdb_fetch_keys( key, old_subkeys );
-
+ regdb_fetch_keys(key, old_subkeys);
+
/* store the subkey list for the parent */
-
- if ( !regdb_store_keys_internal( key, ctr ) ) {
+
+ if (!regdb_store_keys_internal(key, ctr) ) {
DEBUG(0,("regdb_store_keys: Failed to store new subkey list "
- "for parent [%s]\n", key ));
+ "for parent [%s]\n", key));
goto fail;
}
-
+
/* now delete removed keys */
-
- num_subkeys = regsubkey_ctr_numkeys( old_subkeys );
- for ( i=0; i<num_subkeys; i++ ) {
- oldkeyname = regsubkey_ctr_specific_key( old_subkeys, i );
- if ( regsubkey_ctr_key_exists( ctr, oldkeyname ) ) {
+ num_subkeys = regsubkey_ctr_numkeys(old_subkeys);
+ for (i=0; i<num_subkeys; i++) {
+ oldkeyname = regsubkey_ctr_specific_key(old_subkeys, i);
+
+ if (regsubkey_ctr_key_exists(ctr, oldkeyname)) {
/*
* It's still around, don't delete
*/
continue;
}
- pstr_sprintf( path, "%s/%s", key, oldkeyname );
- normalize_reg_path( path );
- if (tdb_delete_bystring( tdb_reg->tdb, path ) == -1) {
+ path = talloc_asprintf(ctx, "%s/%s", key, oldkeyname);
+ if (!path) {
+ goto fail;
+ }
+ path = normalize_reg_path(ctx, path);
+ if (!path) {
+ goto fail;
+ }
+ if (tdb_delete_bystring(tdb_reg->tdb, path) == -1) {
DEBUG(1, ("Deleting %s failed\n", path));
goto fail;
}
-
- pstr_sprintf( path, "%s/%s/%s", REG_VALUE_PREFIX, key,
- oldkeyname );
- normalize_reg_path( path );
+
+ TALLOC_FREE(path);
+ path = talloc_asprintf(ctx, "%s/%s/%s",
+ REG_VALUE_PREFIX,
+ key,
+ oldkeyname );
+ if (!path) {
+ goto fail;
+ }
+ path = normalize_reg_path(ctx, path);
+ if (!path) {
+ goto fail;
+ }
/*
* Ignore errors here, we might have no values around
*/
tdb_delete_bystring( tdb_reg->tdb, path );
+ TALLOC_FREE(path);
}
- TALLOC_FREE( old_subkeys );
-
+ TALLOC_FREE(old_subkeys);
+
/* now create records for any subkeys that don't already exist */
-
- num_subkeys = regsubkey_ctr_numkeys( ctr );
- for ( i=0; i<num_subkeys; i++ ) {
- pstr_sprintf( path, "%s/%s", key,
- regsubkey_ctr_specific_key( ctr, i ) );
- if ( !(subkeys = TALLOC_ZERO_P( ctr, REGSUBKEY_CTR )) ) {
+ num_subkeys = regsubkey_ctr_numkeys(ctr);
+ for (i=0; i<num_subkeys; i++) {
+ path = talloc_asprintf(ctx, "%s/%s",
+ key,
+ regsubkey_ctr_specific_key(ctr, i));
+ if (!path) {
+ goto fail;
+ }
+ if (!(subkeys = TALLOC_ZERO_P(ctr, REGSUBKEY_CTR)) ) {
DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
goto fail;
}
- if ( regdb_fetch_keys( path, subkeys ) == -1 ) {
+ if (regdb_fetch_keys( path, subkeys ) == -1) {
/* create a record with 0 subkeys */
- if ( !regdb_store_keys_internal( path, subkeys ) ) {
+ if (!regdb_store_keys_internal(path, subkeys)) {
DEBUG(0,("regdb_store_keys: Failed to store "
- "new record for key [%s]\n", path ));
+ "new record for key [%s]\n", path));
goto fail;
}
}
- TALLOC_FREE( subkeys );
+ TALLOC_FREE(subkeys);
+ TALLOC_FREE(path);
}
if (tdb_transaction_commit( tdb_reg->tdb ) == -1) {
DEBUG(0, ("regdb_store_keys: Could not commit transaction\n"));
- return False;
+ return false;
}
- return True;
+ return true;
fail:
- TALLOC_FREE( old_subkeys );
- TALLOC_FREE( subkeys );
+ TALLOC_FREE(old_subkeys);
+ TALLOC_FREE(subkeys);
- if (tdb_transaction_cancel( tdb_reg->tdb ) == -1) {
+ if (tdb_transaction_cancel(tdb_reg->tdb) == -1) {
smb_panic("regdb_store_keys: tdb_transaction_cancel failed\n");
}
- return False;
+ return false;
}
/***********************************************************************
- Retrieve an array of strings containing subkeys. Memory should be
- released by the caller.
+ Retrieve an array of strings containing subkeys. Memory should be
+ released by the caller.
***********************************************************************/
-int regdb_fetch_keys( const char* key, REGSUBKEY_CTR *ctr )
+int regdb_fetch_keys(const char *key, REGSUBKEY_CTR *ctr)
{
- pstring path;
+ char *path = NULL;
uint32 num_items;
TDB_DATA dbuf;
uint8 *buf;
uint32 buflen, len;
int i;
fstring subkeyname;
+ TALLOC_CTX *ctx = talloc_tos();
DEBUG(11,("regdb_fetch_keys: Enter key => [%s]\n", key ? key : "NULL"));
-
- pstrcpy( path, key );
-
+
+ path = talloc_strdup(ctx, key);
+ if (!path) {
+ return -1;
+ }
+
/* convert to key format */
- pstring_sub( path, "\\", "/" );
- strupper_m( path );
-
- dbuf = tdb_fetch_bystring( tdb_reg->tdb, path );
-
+ path = talloc_string_sub(ctx, path, "\\", "/");
+ if (!path) {
+ return -1;
+ }
+ strupper_m(path);
+
+ dbuf = tdb_fetch_bystring(tdb_reg->tdb, path);
+
+ TALLOC_FREE(path);
+
buf = dbuf.dptr;
buflen = dbuf.dsize;
-
+
if ( !buf ) {
DEBUG(5,("regdb_fetch_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 );
+ len += tdb_unpack(buf+len, buflen-len, "f", subkeyname);
+ regsubkey_ctr_addkey(ctr, subkeyname);
}
- SAFE_FREE( dbuf.dptr );
-
+ SAFE_FREE(dbuf.dptr);
+
DEBUG(11,("regdb_fetch_keys: Exit [%d] items\n", num_items));
-
+
return num_items;
}
/****************************************************************************
Unpack a list of registry values frem the TDB
***************************************************************************/
-
+
static int regdb_unpack_values(REGVAL_CTR *values, uint8 *buf, int buflen)
{
int len = 0;
uint32 type;
- pstring valuename;
+ fstring valuename;
uint32 size;
uint8 *data_p;
uint32 num_values = 0;
int i;
-
-
-
+
/* loop and unpack the rest of the registry values */
-
+
len += tdb_unpack(buf+len, buflen-len, "d", &num_values);
-
+
for ( i=0; i<num_values; i++ ) {
/* unpack the next regval */
-
+
type = REG_NONE;
size = 0;
data_p = NULL;
+ valuename[0] = '\0';
len += tdb_unpack(buf+len, buflen-len, "fdB",
valuename,
&type,
&size,
&data_p);
-
+
/* add the new value. Paranoid protective code -- make sure data_p is valid */
- if ( size && data_p ) {
- regval_ctr_addvalue( values, valuename, type, (const char *)data_p, size );
- SAFE_FREE(data_p); /* 'B' option to tdb_unpack does a malloc() */
+ if (*valuename && size && data_p) {
+ regval_ctr_addvalue(values, valuename, type,
+ (const char *)data_p, size);
}
+ SAFE_FREE(data_p); /* 'B' option to tdb_unpack does a malloc() */
DEBUG(8,("specific: [%s], len: %d\n", valuename, size));
}
/****************************************************************************
Pack all values in all printer keys
***************************************************************************/
-
+
static int regdb_pack_values(REGVAL_CTR *values, uint8 *buf, int buflen)
{
int len = 0;
num_values = regval_ctr_numvals( values );
/* pack the number of values first */
-
+
len += tdb_pack( buf+len, buflen-len, "d", num_values );
-
+
/* loop over all values */
-
- for ( i=0; i<num_values; i++ ) {
+
+ for ( i=0; i<num_values; i++ ) {
val = regval_ctr_specific_value( values, i );
len += tdb_pack(buf+len, buflen-len, "fdB",
regval_name(val),
}
/***********************************************************************
- Retrieve an array of strings containing subkeys. Memory should be
+ Retrieve an array of strings containing subkeys. Memory should be
released by the caller.
***********************************************************************/
int regdb_fetch_values( const char* key, REGVAL_CTR *values )
{
TDB_DATA data;
- pstring keystr;
+ char *keystr = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
DEBUG(10,("regdb_fetch_values: Looking for value of key [%s] \n", key));
-
- pstr_sprintf( keystr, "%s/%s", REG_VALUE_PREFIX, key );
- normalize_reg_path( keystr );
-
- data = tdb_fetch_bystring( tdb_reg->tdb, keystr );
-
- if ( !data.dptr ) {
+
+ keystr = talloc_asprintf(ctx, "%s/%s", REG_VALUE_PREFIX, key);
+ if (!keystr) {
+ return 0;
+ }
+ keystr = normalize_reg_path(ctx, keystr);
+ if (!keystr) {
+ return 0;
+ }
+
+ data = tdb_fetch_bystring(tdb_reg->tdb, keystr);
+
+ if (!data.dptr) {
/* all keys have zero values by default */
return 0;
}
-
- regdb_unpack_values( values, data.dptr, data.dsize );
-
- SAFE_FREE( data.dptr );
-
+
+ regdb_unpack_values(values, data.dptr, data.dsize);
+
+ SAFE_FREE(data.dptr);
return regval_ctr_numvals(values);
}
bool regdb_store_values( const char *key, REGVAL_CTR *values )
{
TDB_DATA old_data, data;
- pstring keystr;
+ char *keystr = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
int len, ret;
-
+
DEBUG(10,("regdb_store_values: Looking for value of key [%s] \n", key));
-
- ZERO_STRUCT( data );
-
- len = regdb_pack_values( values, data.dptr, data.dsize );
- if ( len <= 0 ) {
+
+ ZERO_STRUCT(data);
+
+ len = regdb_pack_values(values, data.dptr, data.dsize);
+ if (len <= 0) {
DEBUG(0,("regdb_store_values: unable to pack values. len <= 0\n"));
- return False;
+ return false;
}
-
+
data.dptr = SMB_MALLOC_ARRAY( uint8, len );
data.dsize = len;
-
- len = regdb_pack_values( values, data.dptr, data.dsize );
-
+
+ len = regdb_pack_values(values, data.dptr, data.dsize);
+
SMB_ASSERT( len == data.dsize );
-
- pstr_sprintf( keystr, "%s/%s", REG_VALUE_PREFIX, key );
- normalize_reg_path( keystr );
-
+
+ keystr = talloc_asprintf(ctx, "%s/%s", REG_VALUE_PREFIX, key );
+ if (!keystr) {
+ SAFE_FREE(data.dptr);
+ return false;
+ }
+ keystr = normalize_reg_path(ctx, keystr);
+ if (!keystr) {
+ SAFE_FREE(data.dptr);
+ return false;
+ }
+
old_data = tdb_fetch_bystring(tdb_reg->tdb, keystr);
if ((old_data.dptr != NULL)
}
ret = tdb_trans_store_bystring(tdb_reg->tdb, keystr, data, TDB_REPLACE);
-
+
SAFE_FREE( old_data.dptr );
SAFE_FREE( data.dptr );
-
+
return ret != -1 ;
}
int fetch_dynamic_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
{
int i;
- pstring path;
-
- pstrcpy( path, key->name );
- normalize_reg_path( path );
-
+ char *path = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
+
+ path = talloc_strdup(ctx, key->name);
+ if (!path) {
+ return -1;
+ }
+ path = normalize_reg_path(ctx, path);
+ if (!path) {
+ return -1;
+ }
+
for ( i=0; dynamic_values[i].path; i++ ) {
if ( strcmp( path, dynamic_values[i].path ) == 0 )
return dynamic_values[i].fetch_values( val );
}
-
+
return -1;
}
bool check_dynamic_reg_values( REGISTRY_KEY *key )
{
int i;
- pstring path;
-
- pstrcpy( path, key->name );
- normalize_reg_path( path );
-
+ char *path = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
+
+ path = talloc_strdup(ctx, key->name);
+ if (!path) {
+ return false;
+ }
+ path = normalize_reg_path(ctx, path);
+ if (!path) {
+ return false;
+ }
+
for ( i=0; dynamic_values[i].path; i++ ) {
/* can't write to dynamic keys */
if ( strcmp( path, dynamic_values[i].path ) == 0 )
- return True;
+ return true;
}
-
- return False;
-}
+ return false;
+}
for an eventlog, add in the default values
*********************************************************************/
-bool eventlog_init_keys( void )
+bool eventlog_init_keys(void)
{
/* Find all of the eventlogs, add keys for each of them */
- const char **elogs = lp_eventlog_list( );
- pstring evtlogpath;
- pstring evtfilepath;
+ const char **elogs = lp_eventlog_list();
+ char *evtlogpath = NULL;
+ char *evtfilepath = NULL;
REGSUBKEY_CTR *subkeys;
REGVAL_CTR *values;
uint32 uiMaxSize;
uint32 uiRetention;
uint32 uiCategoryCount;
UNISTR2 data;
+ TALLOC_CTX *ctx = talloc_tos();
- while ( elogs && *elogs ) {
- if ( !( subkeys = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR ) ) ) {
+ while (elogs && *elogs) {
+ if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR ) ) ) {
DEBUG( 0, ( "talloc() failure!\n" ) );
return False;
}
- regdb_fetch_keys( KEY_EVENTLOG, subkeys );
+ regdb_fetch_keys(KEY_EVENTLOG, subkeys);
regsubkey_ctr_addkey( subkeys, *elogs );
if ( !regdb_store_keys( KEY_EVENTLOG, subkeys ) ) {
TALLOC_FREE(subkeys);
return False;
}
- TALLOC_FREE( subkeys );
+ TALLOC_FREE(subkeys);
/* add in the key of form KEY_EVENTLOG/Application */
DEBUG( 5,
( "Adding key of [%s] to path of [%s]\n", *elogs,
KEY_EVENTLOG ) );
- slprintf( evtlogpath, sizeof( evtlogpath ) - 1, "%s\\%s",
- KEY_EVENTLOG, *elogs );
+ evtlogpath = talloc_asprintf(ctx, "%s\\%s",
+ KEY_EVENTLOG, *elogs);
+ if (!evtlogpath) {
+ return false;
+ }
/* add in the key of form KEY_EVENTLOG/Application/Application */
DEBUG( 5,
( "Adding key of [%s] to path of [%s]\n", *elogs,
evtlogpath ) );
- if ( !( subkeys = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR ) ) ) {
+ if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) {
DEBUG( 0, ( "talloc() failure!\n" ) );
return False;
}
TALLOC_FREE( subkeys );
/* now add the values to the KEY_EVENTLOG/Application form key */
- if ( !( values = TALLOC_ZERO_P( NULL, REGVAL_CTR ) ) ) {
+ if (!(values = TALLOC_ZERO_P(ctx, REGVAL_CTR))) {
DEBUG( 0, ( "talloc() failure!\n" ) );
return False;
}
regdb_fetch_values( evtlogpath, values );
- if ( !regval_ctr_key_exists( values, "MaxSize" ) ) {
+ if (!regval_ctr_key_exists(values, "MaxSize")) {
/* assume we have none, add them all */
uiMaxSize = 0x00080000;
uiRetention = 0x93A80;
- regval_ctr_addvalue( values, "MaxSize", REG_DWORD,
- ( char * ) &uiMaxSize,
- sizeof( uint32 ) );
+ regval_ctr_addvalue(values, "MaxSize", REG_DWORD,
+ (char *)&uiMaxSize,
+ sizeof(uint32));
- regval_ctr_addvalue( values, "Retention", REG_DWORD,
- ( char * ) &uiRetention,
- sizeof( uint32 ) );
- init_unistr2( &data, *elogs, UNI_STR_TERMINATE );
+ regval_ctr_addvalue(values, "Retention", REG_DWORD,
+ (char *)&uiRetention,
+ sizeof(uint32));
+ init_unistr2(&data, *elogs, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "PrimaryModule", REG_SZ,
- ( char * ) data.buffer,
+ regval_ctr_addvalue(values, "PrimaryModule", REG_SZ,
+ (char *)data.buffer,
data.uni_str_len *
- sizeof( uint16 ) );
- init_unistr2( &data, *elogs, UNI_STR_TERMINATE );
+ sizeof(uint16));
+ init_unistr2(&data, *elogs, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Sources", REG_MULTI_SZ,
- ( char * ) data.buffer,
+ regval_ctr_addvalue(values, "Sources", REG_MULTI_SZ,
+ (char *)data.buffer,
data.uni_str_len *
- sizeof( uint16 ) );
+ sizeof(uint16));
- pstr_sprintf( evtfilepath, "%%SystemRoot%%\\system32\\config\\%s.tdb", *elogs );
- init_unistr2( &data, evtfilepath, UNI_STR_TERMINATE );
- regval_ctr_addvalue( values, "File", REG_EXPAND_SZ, ( char * ) data.buffer,
- data.uni_str_len * sizeof( uint16 ) );
- regdb_store_values( evtlogpath, values );
+ evtfilepath = talloc_asprintf(ctx,
+ "%%SystemRoot%%\\system32\\config\\%s.tdb",
+ *elogs);
+ if (!evtfilepath) {
+ TALLOC_FREE(values);
+ }
+ init_unistr2(&data, evtfilepath, UNI_STR_TERMINATE);
+ regval_ctr_addvalue(values, "File", REG_EXPAND_SZ, (char *)data.buffer,
+ data.uni_str_len * sizeof(uint16));
+ regdb_store_values(evtlogpath, values);
}
- TALLOC_FREE( values );
+ TALLOC_FREE(values);
/* now do the values under KEY_EVENTLOG/Application/Application */
- slprintf( evtlogpath, sizeof( evtlogpath ) - 1, "%s\\%s\\%s",
- KEY_EVENTLOG, *elogs, *elogs );
- if ( !( values = TALLOC_ZERO_P( NULL, REGVAL_CTR ) ) ) {
+ TALLOC_FREE(evtlogpath);
+ evtlogpath = talloc_asprintf("%s\\%s\\%s",
+ KEY_EVENTLOG, *elogs, *elogs);
+ if (!evtlogpath) {
+ return false;
+ }
+ if (!(values = TALLOC_ZERO_P(ctx, REGVAL_CTR))) {
DEBUG( 0, ( "talloc() failure!\n" ) );
return False;
}
DEBUG( 5,
( "Storing values to eventlog path of [%s]\n",
- evtlogpath ) );
- regdb_fetch_values( evtlogpath, values );
- if ( !regval_ctr_key_exists( values, "CategoryCount" ) ) {
+ evtlogpath));
+ regdb_fetch_values(evtlogpath, values);
+ if (!regval_ctr_key_exists( values, "CategoryCount")) {
/* hard code some initial values */
sizeof( uint16 ) );
regdb_store_values( evtlogpath, values );
}
- TALLOC_FREE( values );
+ TALLOC_FREE(values);
elogs++;
}
- return True;
-
+ return true;
}
/*********************************************************************
- for an eventlog, add in a source name. If the eventlog doesn't
- exist (not in the list) do nothing. If a source for the log
+ for an eventlog, add in a source name. If the eventlog doesn't
+ exist (not in the list) do nothing. If a source for the log
already exists, change the information (remove, replace)
*********************************************************************/
const char **elogs = lp_eventlog_list( );
char **wrklist, **wp;
- pstring evtlogpath;
+ char *evtlogpath = NULL;
REGSUBKEY_CTR *subkeys;
REGVAL_CTR *values;
REGISTRY_VALUE *rval;
bool already_in;
int i;
int numsources;
+ TALLOC_CTX *ctx = talloc_tos();
if (!elogs) {
return False;
DEBUG( 0,
( "Eventlog [%s] not found in list of valid event logs\n",
eventlog ) );
- return False; /* invalid named passed in */
+ return false; /* invalid named passed in */
}
/* have to assume that the evenlog key itself exists at this point */
/* todo add to Sources */
- if ( !( values = TALLOC_ZERO_P( NULL, REGVAL_CTR ) ) ) {
- DEBUG( 0, ( "talloc() failure!\n" ) );
- return False;
+ if (!( values = TALLOC_ZERO_P(ctx, REGVAL_CTR))) {
+ DEBUG( 0, ( "talloc() failure!\n" ));
+ return false;
}
- pstr_sprintf( evtlogpath, "%s\\%s", KEY_EVENTLOG, eventlog );
+ evtlogpath = talloc_asprintf("%s\\%s", KEY_EVENTLOG, eventlog);
+ if (!evtlogpath) {
+ TALLOC_FREE(values);
+ return false;
+ }
regdb_fetch_values( evtlogpath, values );
if ( !already_in ) {
/* make a new list with an additional entry; copy values, add another */
- wp = TALLOC_ARRAY( NULL, char *, numsources + 2 );
+ wp = TALLOC_ARRAY(ctx, char *, numsources + 2 );
if ( !wp ) {
DEBUG( 0, ( "talloc() failed \n" ) );
regval_ctr_addvalue( values, "Sources", REG_MULTI_SZ,
( char * ) msz_wp, mbytes );
regdb_store_values( evtlogpath, values );
- TALLOC_FREE( msz_wp );
+ TALLOC_FREE(msz_wp);
} else {
DEBUG( 3,
( "Source name [%s] found in existing list of sources\n",
sourcename ) );
}
- TALLOC_FREE( values );
- TALLOC_FREE( wrklist ); /* */
+ TALLOC_FREE(values);
+ TALLOC_FREE(wrklist); /* */
- if ( !( subkeys = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR ) ) ) {
+ if ( !( subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR ) ) ) {
DEBUG( 0, ( "talloc() failure!\n" ) );
return False;
}
- pstr_sprintf( evtlogpath, "%s\\%s", KEY_EVENTLOG, eventlog );
+ TALLOC_FREE(evtlogpath);
+ evtlogpath = talloc_asprintf("%s\\%s", KEY_EVENTLOG, eventlog );
+ if (!evtlogpath) {
+ TALLOC_FREE(subkeys);
+ return false;
+ }
regdb_fetch_keys( evtlogpath, subkeys );
if ( !regdb_store_keys( evtlogpath, subkeys ) )
return False;
}
- TALLOC_FREE( subkeys );
+ TALLOC_FREE(subkeys);
/* at this point KEY_EVENTLOG/<eventlog>/<sourcename> key is in there. Now need to add EventMessageFile */
/* now allocate room for the source's subkeys */
- if ( !( subkeys = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR ) ) ) {
+ if ( !( subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR ) ) ) {
DEBUG( 0, ( "talloc() failure!\n" ) );
return False;
}
- slprintf( evtlogpath, sizeof( evtlogpath ) - 1, "%s\\%s\\%s",
- KEY_EVENTLOG, eventlog, sourcename );
+ TALLOC_FREE(evtlogpath);
+ evtlogpath = talloc_asprintf("%s\\%s\\%s",
+ KEY_EVENTLOG, eventlog, sourcename);
+ if (!evtlogpath) {
+ TALLOC_FREE(subkeys);
+ return false;
+ }
regdb_fetch_keys( evtlogpath, subkeys );
/* now add the values to the KEY_EVENTLOG/Application form key */
- if ( !( values = TALLOC_ZERO_P( NULL, REGVAL_CTR ) ) ) {
+ if ( !( values = TALLOC_ZERO_P(ctx, REGVAL_CTR ) ) ) {
DEBUG( 0, ( "talloc() failure!\n" ) );
return False;
}
data.uni_str_len * sizeof( uint16 ) );
regdb_store_values( evtlogpath, values );
- TALLOC_FREE( values );
+ TALLOC_FREE(values);
return True;
}
return the data_p as a character string
**********************************************************************/
-char* regval_sz( REGISTRY_VALUE *val )
+char *regval_sz(REGISTRY_VALUE *val)
{
- pstring data;
+ char *data = NULL;
- rpcstr_pull(data, regval_data_p(val), sizeof(data), regval_size(val),0);
-
- return talloc_strdup(talloc_tos(), data);
+ rpcstr_pull_talloc(talloc_tos(), &data,
+ regval_data_p(val), regval_size(val),0);
+ return data;
}
/*********************************************************************
*********************************************************************/
-static char* counters_directory( const char *dbname )
+static char *counters_directory(const char *dbname)
{
- pstring fname;
- fstring path;
-
- if ( !dbname )
+ char *path = NULL;
+ char *ret = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
+
+ if (!dbname)
return NULL;
-
- fstr_sprintf( path, "%s/%s", PERFCOUNTDIR, dbname );
-
- pstrcpy( fname, state_path( path ) );
-
- return talloc_strdup(talloc_tos(), fname);
+
+ path = talloc_asprintf(ctx, "%s/%s", PERFCOUNTDIR, dbname);
+ if (!path) {
+ return NULL;
+ }
+
+ ret = talloc_strdup(ctx, state_path(path));
+ TALLOC_FREE(path);
+ return ret;
}
/*********************************************************************
{
TDB_DATA key, data;
char buf[PERFCOUNT_MAX_LEN], temp[PERFCOUNT_MAX_LEN];
- wpstring name;
+ smb_ucs2_t *name = NULL;
int pad;
/* First grab the instance data from the data file */
else
{
memset(buf, 0, PERFCOUNT_MAX_LEN);
- memcpy(buf, data.dptr, data.dsize);
- rpcstr_push((void *)name, buf, sizeof(name), STR_TERMINATE);
- inst->NameLength = (strlen_w(name) * 2) + 2;
+ memcpy(buf, data.dptr, MIN(PERFCOUNT_MAX_LEN-1,data.dsize));
+ buf[PERFCOUNT_MAX_LEN-1] = '\0';
+ inst->NameLength = rpcstr_push_talloc(ps->mem_ctx, &name, buf);
+ if (inst->NameLength == (size_t)-1 || !name) {
+ SAFE_FREE(data.dptr);
+ return False;
+ }
inst->data = TALLOC_REALLOC_ARRAY(ps->mem_ctx,
inst->data,
uint8,
static bool _reg_perfcount_init_data_block(PERF_DATA_BLOCK *block,
prs_struct *ps, TDB_CONTEXT *names)
{
- wpstring temp;
+ smb_ucs2_t *temp = NULL;
time_t tm;
-
- memset(temp, 0, sizeof(temp));
- rpcstr_push((void *)temp, "PERF", sizeof(temp), STR_TERMINATE);
+
+ if (rpcstr_push_talloc(ps->mem_ctx, &temp, "PERF")==(size_t)-1) {
+ return false;
+ }
+ if (!temp) {
+ return false;
+ }
memcpy(block->Signature, temp, strlen_w(temp) *2);
if(ps->bigendian_data == RPC_BIG_ENDIAN)
-/*
+/*
* Unix SMB/CIFS implementation.
* Virtual Windows Registry Layer
* Copyright (C) Gerald Carter 2002-2005
* it under the terms of the GNU General Public License as published by
* 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,
* 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, see <http://www.gnu.org/licenses/>.
*/
#define KEY_PORTS "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PORTS"
/* callback table for various registry paths below the ones we service in this module */
-
+
struct reg_dyn_tree {
/* full key path in normalized form */
const char *path;
-
+
/* callbscks for fetch/store operations */
int ( *fetch_subkeys) ( const char *path, REGSUBKEY_CTR *subkeys );
bool (*store_subkeys) ( const char *path, REGSUBKEY_CTR *subkeys );
*********************************************************************/
/***********************************************************************
- simple function to prune a pathname down to the basename of a file
+ simple function to prune a pathname down to the basename of a file
**********************************************************************/
-
-static char* dos_basename ( char *path )
+
+static const char *dos_basename(const char *path)
{
- char *p;
-
- if ( !(p = strrchr( path, '\\' )) )
+ const char *p;
+
+ if (!(p = strrchr( path, '\\'))) {
p = path;
- else
+ } else {
p++;
-
+ }
+
return p;
}
*********************************************************************
*********************************************************************/
-static int key_forms_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
+static int key_forms_fetch_keys(const char *key, REGSUBKEY_CTR *subkeys)
{
- char *p = reg_remaining_path( key + strlen(KEY_FORMS) );
-
+ char *p = reg_remaining_path(talloc_tos(), key + strlen(KEY_FORMS));
+
/* no keys below Forms */
-
- if ( p )
+
+ if (p) {
return -1;
-
+ }
+
return 0;
}
int i, num_values, form_index = 1;
nt_forms_struct *forms_list = NULL;
nt_forms_struct *form;
-
+
DEBUG(10,("print_values_forms: key=>[%s]\n", key ? key : "NULL" ));
-
+
num_values = get_ntforms( &forms_list );
-
+
DEBUG(10,("hive_forms_fetch_values: [%d] user defined forms returned\n",
num_values));
/* handle user defined forms */
-
+
for ( i=0; i<num_values; i++ ) {
form = &forms_list[i];
-
+
data[0] = form->width;
data[1] = form->length;
data[2] = form->left;
data[5] = form->bottom;
data[6] = form_index++;
data[7] = form->flag;
-
+
regval_ctr_addvalue( values, form->name, REG_BINARY, (char*)data, sizeof(data) );
}
-
+
SAFE_FREE( forms_list );
forms_list = NULL;
-
+
/* handle built-on forms */
-
+
num_values = get_builtin_ntforms( &forms_list );
-
+
DEBUG(10,("print_subpath_values_forms: [%d] built-in forms returned\n",
num_values));
-
+
for ( i=0; i<num_values; i++ ) {
form = &forms_list[i];
-
+
data[0] = form->width;
data[1] = form->length;
data[2] = form->left;
data[5] = form->bottom;
data[6] = form_index++;
data[7] = form->flag;
-
- regval_ctr_addvalue( values, form->name, REG_BINARY, (char*)data, sizeof(data) );
+
+ regval_ctr_addvalue(values, form->name, REG_BINARY, (char*)data, sizeof(data) );
}
-
- SAFE_FREE( forms_list );
-
- return regval_ctr_numvals( values );
+
+ SAFE_FREE(forms_list);
+
+ return regval_ctr_numvals(values);
}
/*********************************************************************
*********************************************************************/
/*********************************************************************
- strip off prefix for printers key. DOes return a pointer to static
+ strip off prefix for printers key. DOes return a pointer to static
memory.
*********************************************************************/
-static char* strip_printers_prefix( const char *key )
+static char *strip_printers_prefix(const char *key)
{
- char *subkeypath;
- pstring path;
-
- pstrcpy( path, key );
- normalize_reg_path( path );
+ char *subkeypath = NULL;
+ char *path = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
+
+ path = talloc_strdup(ctx, key);
+ if (!path) {
+ return NULL;
+ }
+ path = normalize_reg_path(ctx, path);
+ if (!path) {
+ return NULL;
+ }
/* normalizing the path does not change length, just key delimiters and case */
- if ( strncmp( path, KEY_WINNT_PRINTERS, strlen(KEY_WINNT_PRINTERS) ) == 0 )
- subkeypath = reg_remaining_path( key + strlen(KEY_WINNT_PRINTERS) );
- else
- subkeypath = reg_remaining_path( key + strlen(KEY_CONTROL_PRINTERS) );
-
+ if (strncmp(path, KEY_WINNT_PRINTERS, strlen(KEY_WINNT_PRINTERS)) == 0) {
+ subkeypath = reg_remaining_path(ctx, key + strlen(KEY_WINNT_PRINTERS));
+ } else {
+ subkeypath = reg_remaining_path(ctx, key + strlen(KEY_CONTROL_PRINTERS));
+ }
+
+ TALLOC_FREE(path);
return subkeypath;
}
/*********************************************************************
*********************************************************************/
-
+
static int key_printers_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
{
- int n_services = lp_numservices();
+ int n_services = lp_numservices();
int snum;
fstring sname;
int i;
char *printername, *printerdatakey;
NT_PRINTER_INFO_LEVEL *printer = NULL;
fstring *subkey_names = NULL;
-
+
DEBUG(10,("key_printers_fetch_keys: key=>[%s]\n", key ? key : "NULL" ));
-
- printers_key = strip_printers_prefix( key );
-
+
+ printers_key = strip_printers_prefix( key );
+
if ( !printers_key ) {
/* enumerate all printers */
-
+
for (snum=0; snum<n_services; snum++) {
if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
continue;
if ( strequal( lp_servicename(snum), PRINTERS_NAME ) )
continue;
-
+
fstrcpy( sname, lp_servicename(snum) );
-
+
regsubkey_ctr_addkey( subkeys, sname );
}
-
+
num_subkeys = regsubkey_ctr_numkeys( subkeys );
goto done;
}
/* get information for a specific printer */
-
+
if (!reg_split_path( printers_key, &printername, &printerdatakey )) {
return -1;
}
fstring *drivers = NULL;
int i, env_index, num_drivers;
char *keystr, *base, *subkeypath;
- pstring key2;
+ char *key2 = NULL;
int num_subkeys = -1;
int version;
+ TALLOC_CTX *ctx = talloc_tos();
DEBUG(10,("key_driver_fetch_keys key=>[%s]\n", key ? key : "NULL" ));
-
- keystr = reg_remaining_path( key + strlen(KEY_ENVIRONMENTS) );
-
+
+ keystr = reg_remaining_path(ctx, key + strlen(KEY_ENVIRONMENTS) );
+
/* list all possible architectures */
-
+
if ( !keystr ) {
- for ( num_subkeys=0; environments[num_subkeys]; num_subkeys++ )
+ for ( num_subkeys=0; environments[num_subkeys]; num_subkeys++ )
regsubkey_ctr_addkey( subkeys, environments[num_subkeys] );
return num_subkeys;
}
-
+
/* we are dealing with a subkey of "Environments */
-
- pstrcpy( key2, keystr );
+ key2 = talloc_strdup(ctx, keystr);
+ if (!key2) {
+ return -1;
+ }
keystr = key2;
- if (!reg_split_path( keystr, &base, &subkeypath )) {
+ if (!reg_split_path(keystr, &base, &subkeypath )) {
return -1;
}
-
+
/* sanity check */
-
+
for ( env_index=0; environments[env_index]; env_index++ ) {
if ( strequal( environments[env_index], base ) )
break;
}
if ( !environments[env_index] )
return -1;
-
+
/* ...\Print\Environements\...\ */
-
+
if ( !subkeypath ) {
regsubkey_ctr_addkey( subkeys, "Drivers" );
regsubkey_ctr_addkey( subkeys, "Print Processors" );
-
+
return 2;
}
-
+
/* more of the key path to process */
-
+
keystr = subkeypath;
if (!reg_split_path( keystr, &base, &subkeypath )) {
return -1;
}
-
+
/* ...\Print\Environements\...\Drivers\ */
-
+
if ( !subkeypath ) {
if ( strequal(base, "Drivers") ) {
switch ( env_index ) {
default: /* Windows NT based systems */
regsubkey_ctr_addkey( subkeys, "Version-2" );
regsubkey_ctr_addkey( subkeys, "Version-3" );
- break;
+ break;
}
-
+
return regsubkey_ctr_numkeys( subkeys );
} else if ( strequal(base, "Print Processors") ) {
if ( env_index == 1 || env_index == 5 || env_index == 6 )
- regsubkey_ctr_addkey( subkeys, "winprint" );
-
+
+
return regsubkey_ctr_numkeys( subkeys );
} else
return -1; /* bad path */
}
-
+
/* we finally get to enumerate the drivers */
-
+
/* only one possible subkey below PrintProc key */
if ( strequal(base, "Print Processors") ) {
return strequal( base, "winprint" ) ? 0 : -1;
}
-
+
/* only dealing with drivers from here on out */
keystr = subkeypath;
}
version = atoi(&base[strlen(base)-1]);
-
+
switch (env_index) {
case 0:
if ( version != 0 )
break;
}
-
+
if ( !subkeypath ) {
num_drivers = get_ntdrivers( &drivers, environments[env_index], version );
for ( i=0; i<num_drivers; i++ )
regsubkey_ctr_addkey( subkeys, drivers[i] );
-
- return regsubkey_ctr_numkeys( subkeys );
- }
-
+
+ return regsubkey_ctr_numkeys( subkeys );
+ }
+
/* if anything else left, just say if has no subkeys */
-
- DEBUG(1,("key_driver_fetch_keys unhandled key [%s] (subkey == %s\n",
+
+ DEBUG(1,("key_driver_fetch_keys unhandled key [%s] (subkey == %s\n",
key, subkeypath ));
-
+
return 0;
}
char *buffer = NULL;
int buffer_size = 0;
int i, length;
- char *filename;
+ const char *filename;
UNISTR2 data;
-
+
filename = dos_basename( info3->driverpath );
init_unistr2( &data, filename, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Driver", REG_SZ, (char*)data.buffer,
+ regval_ctr_addvalue( values, "Driver", REG_SZ, (char*)data.buffer,
data.uni_str_len*sizeof(uint16) );
-
+
filename = dos_basename( info3->configfile );
init_unistr2( &data, filename, UNI_STR_TERMINATE);
regval_ctr_addvalue( values, "Configuration File", REG_SZ, (char*)data.buffer,
data.uni_str_len*sizeof(uint16) );
-
+
filename = dos_basename( info3->datafile );
init_unistr2( &data, filename, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Data File", REG_SZ, (char*)data.buffer,
+ regval_ctr_addvalue( values, "Data File", REG_SZ, (char*)data.buffer,
data.uni_str_len*sizeof(uint16) );
-
+
filename = dos_basename( info3->helpfile );
init_unistr2( &data, filename, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Help File", REG_SZ, (char*)data.buffer,
+ regval_ctr_addvalue( values, "Help File", REG_SZ, (char*)data.buffer,
data.uni_str_len*sizeof(uint16) );
-
+
init_unistr2( &data, info3->defaultdatatype, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Data Type", REG_SZ, (char*)data.buffer,
+ regval_ctr_addvalue( values, "Data Type", REG_SZ, (char*)data.buffer,
data.uni_str_len*sizeof(uint16) );
-
+
regval_ctr_addvalue( values, "Version", REG_DWORD, (char*)&info3->cversion,
sizeof(info3->cversion) );
-
+
if ( info3->dependentfiles ) {
- /* place the list of dependent files in a single
+ /* place the list of dependent files in a single
character buffer, separating each file name by
a NULL */
-
+
for ( i=0; strcmp(info3->dependentfiles[i], ""); i++ ) {
/* strip the path to only the file's base name */
-
+
filename = dos_basename( info3->dependentfiles[i] );
-
+
length = strlen(filename);
-
+
buffer = (char *)SMB_REALLOC( buffer, buffer_size + (length + 1)*sizeof(uint16) );
if ( !buffer ) {
break;
}
-
+
init_unistr2( &data, filename, UNI_STR_TERMINATE);
memcpy( buffer+buffer_size, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
+
buffer_size += (length + 1)*sizeof(uint16);
}
-
+
/* terminated by double NULL. Add the final one here */
-
+
buffer = (char *)SMB_REALLOC( buffer, buffer_size + 2 );
if ( !buffer ) {
buffer_size = 0;
buffer[buffer_size++] = '\0';
}
}
-
+
regval_ctr_addvalue( values, "Dependent Files", REG_MULTI_SZ, buffer, buffer_size );
-
+
SAFE_FREE( buffer );
-
+
return;
}
if (!reg_split_path( key, &base, &subkeypath )) {
return -1;
}
-
+
/* no values in 'Environments\Drivers\Windows NT x86' */
-
- if ( !subkeypath )
+
+ if ( !subkeypath )
return 0;
-
+
/* We have the Architecture string and some subkey name:
Currently we only support
* Drivers
*/
fstrcpy( arch_environment, base );
-
+
keystr = subkeypath;
if (!reg_split_path( keystr, &base, &subkeypath )) {
return -1;
return 0;
/* only Drivers key can be left */
-
+
if ( !strequal(base, "Drivers") )
return -1;
-
+
if ( !subkeypath )
return 0;
-
+
/* We know that we have Architechure\Drivers with some subkey name
The subkey name has to be Version-XX */
-
+
keystr = subkeypath;
if (!reg_split_path( keystr, &base, &subkeypath )) {
return -1;
if ( !subkeypath )
return 0;
-
+
version = atoi(&base[strlen(base)-1]);
/* BEGIN PRINTER DRIVER NAME BLOCK */
-
+
keystr = subkeypath;
if (!reg_split_path( keystr, &base, &subkeypath )) {
return -1;
}
-
+
/* don't go any deeper for now */
-
+
fstrcpy( driver, base );
-
+
w_result = get_a_printer_driver( &driver_ctr, 3, driver, arch_environment, version );
if ( !W_ERROR_IS_OK(w_result) )
return -1;
-
- fill_in_driver_values( driver_ctr.info_3, values );
-
+
+ fill_in_driver_values( driver_ctr.info_3, values );
+
free_a_printer_driver( driver_ctr, 3 );
/* END PRINTER DRIVER NAME BLOCK */
-
+
DEBUG(8,("key_driver_fetch_values: Exit\n"));
-
+
return regval_ctr_numvals( values );
}
static int key_driver_fetch_values( const char *key, REGVAL_CTR *values )
{
- char *keystr;
- pstring subkey;
-
+ char *keystr = NULL;
+ char *subkey = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
+
DEBUG(8,("key_driver_fetch_values: Enter key => [%s]\n", key ? key : "NULL"));
/* no values in the Environments key */
-
- if ( !(keystr = reg_remaining_path( key + strlen(KEY_ENVIRONMENTS) )) )
+
+ if (!(keystr = reg_remaining_path(ctx, key + strlen(KEY_ENVIRONMENTS))))
return 0;
-
- pstrcpy( subkey, keystr);
-
+
+ subkey = talloc_strdup(ctx, keystr);
+ if (!subkey) {
+ return 0;
+ }
+
/* pass off to handle subkeys */
-
+
return driver_arch_fetch_values( subkey, values );
}
*********************************************************************/
static int key_print_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
-{
+{
int key_len = strlen(key);
-
+
/* no keys below 'Print' handled here */
-
+
if ( (key_len != strlen(KEY_CONTROL_PRINT)) && (key_len != strlen(KEY_WINNT_PRINT)) )
return -1;
regsubkey_ctr_addkey( subkeys, "Monitors" );
regsubkey_ctr_addkey( subkeys, "Forms" );
regsubkey_ctr_addkey( subkeys, "Printers" );
-
+
return regsubkey_ctr_numkeys( subkeys );
}
/**********************************************************************
*********************************************************************
** Structure to hold dispatch table of ops for various printer keys.
- ** Make sure to always store deeper keys along the same path first so
+ ** Make sure to always store deeper keys along the same path first so
** we ge a more specific match.
*********************************************************************
*********************************************************************/
static struct reg_dyn_tree print_registry[] = {
/* just pass the monitor onto the registry tdb */
{ KEY_MONITORS,
- ®db_fetch_keys,
+ ®db_fetch_keys,
®db_store_keys,
®db_fetch_values,
®db_store_values },
-{ KEY_FORMS,
- &key_forms_fetch_keys,
- NULL,
+{ KEY_FORMS,
+ &key_forms_fetch_keys,
+ NULL,
&key_forms_fetch_values,
NULL },
-{ KEY_CONTROL_PRINTERS,
+{ KEY_CONTROL_PRINTERS,
&key_printers_fetch_keys,
&key_printers_store_keys,
&key_printers_fetch_values,
&key_printers_fetch_values,
&key_printers_store_values },
{ KEY_PORTS,
- ®db_fetch_keys,
+ ®db_fetch_keys,
®db_store_keys,
®db_fetch_values,
®db_store_values },
-
+
{ NULL, NULL, NULL, NULL, NULL }
};
-1 on failure
**********************************************************************/
-static int match_registry_path( const char *key )
+static int match_registry_path(const char *key)
{
int i;
- pstring path;
-
+ char *path = NULL;
+ TALLOC_CTX *ctx = talloc_tos();
+
if ( !key )
return -1;
- pstrcpy( path, key );
- normalize_reg_path( path );
-
+ path = talloc_strdup(ctx, key);
+ if (!path) {
+ return -1;
+ }
+ path = normalize_reg_path(ctx, path);
+ if (!path) {
+ return -1;
+ }
+
for ( i=0; print_registry[i].path; i++ ) {
- if ( strncmp( path, print_registry[i].path, strlen(print_registry[i].path) ) == 0 )
+ if (strncmp( path, print_registry[i].path, strlen(print_registry[i].path) ) == 0 )
return i;
}
-
+
return -1;
}
static int regprint_fetch_reg_keys( const char *key, REGSUBKEY_CTR *subkeys )
{
int i = match_registry_path( key );
-
+
if ( i == -1 )
return -1;
-
+
if ( !print_registry[i].fetch_subkeys )
return -1;
-
+
return print_registry[i].fetch_subkeys( key, subkeys );
}
static bool regprint_store_reg_keys( const char *key, REGSUBKEY_CTR *subkeys )
{
int i = match_registry_path( key );
-
+
if ( i == -1 )
return False;
-
+
if ( !print_registry[i].store_subkeys )
return False;
-
+
return print_registry[i].store_subkeys( key, subkeys );
}
static int regprint_fetch_reg_values( const char *key, REGVAL_CTR *values )
{
int i = match_registry_path( key );
-
+
if ( i == -1 )
return -1;
-
- /* return 0 values by default since we know the key had
+
+ /* return 0 values by default since we know the key had
to exist because the client opened a handle */
-
+
if ( !print_registry[i].fetch_values )
return 0;
-
+
return print_registry[i].fetch_values( key, values );
}
static bool regprint_store_reg_values( const char *key, REGVAL_CTR *values )
{
int i = match_registry_path( key );
-
+
if ( i == -1 )
return False;
-
+
if ( !print_registry[i].store_values )
return False;
-
+
return print_registry[i].store_values( key, values );
}
-/*
+/*
* Table of function pointers for accessing printing data
*/
-
+
REGISTRY_OPS printing_ops = {
regprint_fetch_reg_keys,
regprint_fetch_reg_values,
regprint_store_reg_values,
NULL, NULL, NULL
};
-
-
* it under the terms of the GNU General Public License as published by
* 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,
* 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, see <http://www.gnu.org/licenses/>.
*/
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 )
+bool reg_split_path(char *path, char **base, char **new_path)
{
char *p;
-
+
*new_path = *base = NULL;
-
- if ( !path)
- return False;
-
+
+ if (!path) {
+ return false;
+ }
*base = path;
-
- p = strchr( path, '\\' );
-
+
+ p = strchr(path, '\\');
+
if ( p ) {
*p = '\0';
*new_path = p+1;
}
-
- return True;
-}
+ return true;
+}
/***********************************************************************
Utility function for splitting the base path of a registry path off
by setting base and new_path to the appropriate offsets withing the
path.
-
+
WARNING!! Does modify the original string!
***********************************************************************/
-bool reg_split_key( char *path, char **base, char **key )
+bool reg_split_key(char *path, char **base, char **key)
{
char *p;
-
+
*key = *base = NULL;
-
- if ( !path)
- return False;
-
+
+ if (!path) {
+ return false;
+ }
+
*base = path;
-
- p = strrchr( path, '\\' );
-
- if ( p ) {
+
+ p = strrchr(path, '\\');
+
+ if (p) {
*p = '\0';
*key = p+1;
}
-
- return True;
-}
+ return true;
+}
/**********************************************************************
- The full path to the registry key is used as database after the
+ 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.
+ case.
**********************************************************************/
-void normalize_reg_path( pstring keyname )
+char *normalize_reg_path(TALLOC_CTX *ctx, const char *keyname )
{
- pstring_sub( keyname, "\\", "/" );
- strupper_m( keyname );
+ char *nkeyname = talloc_string_sub(ctx, keyname, "\\", "/");
+ if (!nkeyname) {
+ return NULL;
+ }
+ strupper_m(nkeyname);
+ return nkeyname;
}
/**********************************************************************
move to next non-delimter character
*********************************************************************/
-char* reg_remaining_path( const char *key )
+char *reg_remaining_path(TALLOC_CTX *ctx, const char *key)
{
- pstring new_path;
- char *p;
-
- if ( !key || !*key )
+ char *new_path = NULL;
+ char *p = NULL;
+
+ if (!key || !*key) {
return NULL;
+ }
- pstrcpy( new_path, key );
+ new_path = talloc_strdup(ctx, key);
+ if (!new_path) {
+ return NULL;
+ }
/* normalize_reg_path( new_path ); */
-
- if ( !(p = strchr( new_path, '\\' )) )
- {
- if ( !(p = strchr( new_path, '/' )) )
+ if (!(p = strchr(new_path, '\\')) ) {
+ if (!(p = strchr( new_path, '/'))) {
p = new_path;
- else
+ } else {
p++;
- }
- else
+ }
+ } else {
p++;
-
- return talloc_strdup(talloc_tos(), p);
+ }
+
+ return p;
}
/**********************************************************************
fstring buffer;
uint16 *wp;
size_t multi_len = byte_len / 2;
-
+
if ( !multi_string || !values )
return 0;
*values = NULL;
/* just count the NULLs */
-
+
for ( i=0; (i<multi_len-1) && !(multi_string[i]==0x0 && multi_string[i+1]==0x0); i++ ) {
/* peek ahead */
if ( multi_string[i+1] == 0x0 )
if ( num_strings == 0 )
return 0;
-
+
if ( !(sz = TALLOC_ARRAY( NULL, char*, num_strings+1 )) ) {
DEBUG(0,("reg_convert_multi_sz: talloc() failed!\n"));
return -1;
}
wp = multi_string;
-
+
for ( i=0; i<num_strings; i++ ) {
rpcstr_pull( buffer, wp, sizeof(buffer), -1, STR_TERMINATE );
sz[i] = talloc_strdup( sz, buffer );
-
+
/* skip to the next string NULL and then one more */
while ( *wp )
wp++;
wp++;
}
-
+
/* tag the array off with an empty string */
sz[i] = '\0';
-
+
*values = sz;
-
+
return num_strings;
}
if ( !values || !buffer )
return 0;
-
+
/* go ahead and alloc some space */
-
+
if ( !(buf = TALLOC_ARRAY( NULL, uint16, 2 )) ) {
DEBUG(0,("regval_build_multi_sz: talloc() failed!\n"));
return 0;
}
-
+
for ( i=0; values[i]; i++ ) {
ZERO_STRUCT( sz );
/* DEBUG(0,("regval_build_multi_sz: building [%s]\n",values[i])); */
init_unistr2( &sz, values[i], UNI_STR_TERMINATE );
-
+
/* Alloc some more memory. Always add one one to account for the
double NULL termination */
-
+
b = TALLOC_REALLOC_ARRAY( NULL, buf, uint16, buf_size+sz.uni_str_len+1 );
if ( !b ) {
DEBUG(0,("regval_build_multi_sz: talloc() reallocation error!\n"));
}
buf = b;
- /* copy the unistring2 buffer and increment the size */
+ /* copy the unistring2 buffer and increment the size */
/* dump_data(1,sz.buffer,sz.uni_str_len*2); */
memcpy( buf+buf_size, sz.buffer, sz.uni_str_len*2 );
buf_size += sz.uni_str_len;
-
+
/* cleanup rather than leaving memory hanging around */
TALLOC_FREE( sz.buffer );
}
-
+
buf[buf_size++] = 0x0;
*buffer = buf;
/* return number of bytes */
return buf_size*2;
}
-
-
git.samba.org / kai / samba.git / commitdiff