diff options
| -rw-r--r-- | source3/nsswitch/wb_common.c | 41 | ||||
| -rw-r--r-- | source3/registry/reg_cachehook.c | 26 | ||||
| -rw-r--r-- | source3/registry/reg_db.c | 443 | ||||
| -rw-r--r-- | source3/registry/reg_dynamic.c | 43 | ||||
| -rw-r--r-- | source3/registry/reg_eventlog.c | 151 | ||||
| -rw-r--r-- | source3/registry/reg_objects.c | 10 | ||||
| -rw-r--r-- | source3/registry/reg_perfcount.c | 50 | ||||
| -rw-r--r-- | source3/registry/reg_printing.c | 393 | ||||
| -rw-r--r-- | source3/registry/reg_util.c | 138 |
9 files changed, 723 insertions, 572 deletions
diff --git a/source3/nsswitch/wb_common.c b/source3/nsswitch/wb_common.c index 2ae85dcb1e..49a2935bff 100644 --- a/source3/nsswitch/wb_common.c +++ b/source3/nsswitch/wb_common.c @@ -168,54 +168,51 @@ static int winbind_named_pipe_sock(const char *dir) { 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; } diff --git a/source3/registry/reg_cachehook.c b/source3/registry/reg_cachehook.c index 739facac99..289d4e50ce 100644 --- a/source3/registry/reg_cachehook.c +++ b/source3/registry/reg_cachehook.c @@ -47,18 +47,24 @@ bool reghook_cache_init( void ) 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 ); } diff --git a/source3/registry/reg_db.c b/source3/registry/reg_db.c index 4947b2ad52..7c4ea18b1e 100644 --- a/source3/registry/reg_db.c +++ b/source3/registry/reg_db.c @@ -82,10 +82,13 @@ static struct builtin_regkey_value builtin_registry_values[] = { /*********************************************************************** 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; @@ -104,109 +107,126 @@ static bool init_registry_data( void ) 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: @@ -215,7 +235,7 @@ static bool init_registry_data( void ) "failed\n"); } - return False; + return false; } /*********************************************************************** @@ -326,37 +346,42 @@ int regdb_get_seqnum(void) 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 ) { @@ -367,13 +392,13 @@ static bool regdb_store_keys_internal( const char *key, REGSUBKEY_CTR *ctr ) 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) { @@ -381,35 +406,35 @@ static bool regdb_store_keys_internal( const char *key, REGSUBKEY_CTR *ctr ) 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) { @@ -425,13 +450,13 @@ bool regdb_store_keys( const char *key, REGSUBKEY_CTR *ctr ) * 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; } /* @@ -440,28 +465,28 @@ bool regdb_store_keys( const char *key, REGSUBKEY_CTR *ctr ) 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 */ @@ -469,153 +494,182 @@ bool regdb_store_keys( const char *key, REGSUBKEY_CTR *ctr ) 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)); } @@ -626,7 +680,7 @@ static int regdb_unpack_values(REGVAL_CTR *values, uint8 *buf, int buflen) /**************************************************************************** Pack all values in all printer keys ***************************************************************************/ - + static int regdb_pack_values(REGVAL_CTR *values, uint8 *buf, int buflen) { int len = 0; @@ -640,12 +694,12 @@ static int regdb_pack_values(REGVAL_CTR *values, uint8 *buf, int buflen) 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), @@ -658,60 +712,75 @@ static int regdb_pack_values(REGVAL_CTR *values, uint8 *buf, int buflen) } /*********************************************************************** - 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) @@ -723,10 +792,10 @@ bool regdb_store_values( const char *key, REGVAL_CTR *values ) } ret = tdb_trans_store_bystring(tdb_reg->tdb, keystr, data, TDB_REPLACE); - + SAFE_FREE( old_data.dptr ); SAFE_FREE( data.dptr ); - + return ret != -1 ; } diff --git a/source3/registry/reg_dynamic.c b/source3/registry/reg_dynamic.c index e589dff2c8..e70bd178f9 100644 --- a/source3/registry/reg_dynamic.c +++ b/source3/registry/reg_dynamic.c @@ -216,16 +216,23 @@ static struct reg_dyn_values dynamic_values[] = { 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; } @@ -235,17 +242,23 @@ int fetch_dynamic_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val ) 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; +} diff --git a/source3/registry/reg_eventlog.c b/source3/registry/reg_eventlog.c index a9369b9ddf..be47d13140 100644 --- a/source3/registry/reg_eventlog.c +++ b/source3/registry/reg_eventlog.c @@ -29,44 +29,48 @@ 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; } @@ -80,7 +84,7 @@ bool eventlog_init_keys( void ) 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; } @@ -90,7 +94,7 @@ bool eventlog_init_keys( void ) 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 */ @@ -100,48 +104,57 @@ bool eventlog_init_keys( void ) 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 */ @@ -161,17 +174,16 @@ bool eventlog_init_keys( void ) 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) *********************************************************************/ @@ -184,7 +196,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename, const char **elogs = lp_eventlog_list( ); char **wrklist, **wp; - pstring evtlogpath; + char *evtlogpath = NULL; REGSUBKEY_CTR *subkeys; REGVAL_CTR *values; REGISTRY_VALUE *rval; @@ -194,6 +206,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename, bool already_in; int i; int numsources; + TALLOC_CTX *ctx = talloc_tos(); if (!elogs) { return False; @@ -208,7 +221,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename, 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 */ @@ -216,12 +229,16 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename, /* 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 ); @@ -275,7 +292,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename, 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" ) ); @@ -289,20 +306,25 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename, 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 ); @@ -314,23 +336,28 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename, 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; } @@ -347,7 +374,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename, data.uni_str_len * sizeof( uint16 ) ); regdb_store_values( evtlogpath, values ); - TALLOC_FREE( values ); + TALLOC_FREE(values); return True; } diff --git a/source3/registry/reg_objects.c b/source3/registry/reg_objects.c index fa531af10c..47122ccad2 100644 --- a/source3/registry/reg_objects.c +++ b/source3/registry/reg_objects.c @@ -421,11 +421,11 @@ uint32 regval_dword( REGISTRY_VALUE *val ) 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; } diff --git a/source3/registry/reg_perfcount.c b/source3/registry/reg_perfcount.c index 1fd9b36a51..519e0e7488 100644 --- a/source3/registry/reg_perfcount.c +++ b/source3/registry/reg_perfcount.c @@ -35,19 +35,23 @@ PERF_OBJECT_TYPE *_reg_perfcount_find_obj(PERF_DATA_BLOCK *block, int objind); /********************************************************************* *********************************************************************/ -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; } /********************************************************************* @@ -667,7 +671,7 @@ bool _reg_perfcount_get_instance_info(PERF_INSTANCE_DEFINITION *inst, { 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 */ @@ -707,9 +711,13 @@ bool _reg_perfcount_get_instance_info(PERF_INSTANCE_DEFINITION *inst, 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, @@ -891,11 +899,15 @@ static bool _reg_perfcount_init_data_block_perf(PERF_DATA_BLOCK *block, 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) diff --git a/source3/registry/reg_printing.c b/source3/registry/reg_printing.c index 47582c51f7..8c1de763bd 100644 --- a/source3/registry/reg_printing.c +++ b/source3/registry/reg_printing.c @@ -1,4 +1,4 @@ -/* +/* * Unix SMB/CIFS implementation. * Virtual Windows Registry Layer * Copyright (C) Gerald Carter 2002-2005 @@ -7,12 +7,12 @@ * 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/>. */ @@ -36,11 +36,11 @@ #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 ); @@ -55,18 +55,19 @@ struct reg_dyn_tree { *********************************************************************/ /*********************************************************************** - 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; } @@ -76,15 +77,16 @@ static char* dos_basename ( char *path ) ********************************************************************* *********************************************************************/ -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; } @@ -97,19 +99,19 @@ static int key_forms_fetch_values( const char *key, REGVAL_CTR *values ) 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; @@ -118,23 +120,23 @@ static int key_forms_fetch_values( const char *key, REGVAL_CTR *values ) 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; @@ -143,13 +145,13 @@ static int key_forms_fetch_values( const char *key, REGVAL_CTR *values ) 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); } /********************************************************************* @@ -160,34 +162,43 @@ static int key_forms_fetch_values( const char *key, REGVAL_CTR *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; @@ -196,14 +207,14 @@ static int key_printers_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys ) 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; @@ -212,18 +223,18 @@ static int key_printers_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys ) 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; } @@ -742,58 +753,61 @@ static int key_driver_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys ) 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 ) { @@ -803,21 +817,21 @@ static int key_driver_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys ) 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") ) { @@ -835,7 +849,7 @@ static int key_driver_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys ) return strequal( base, "winprint" ) ? 0 : -1; } - + /* only dealing with drivers from here on out */ keystr = subkeypath; @@ -844,7 +858,7 @@ static int key_driver_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys ) } version = atoi(&base[strlen(base)-1]); - + switch (env_index) { case 0: if ( version != 0 ) @@ -856,20 +870,20 @@ static int key_driver_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys ) 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; } @@ -882,61 +896,61 @@ static void fill_in_driver_values( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3, REGVAL 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; @@ -945,11 +959,11 @@ static void fill_in_driver_values( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3, REGVAL buffer[buffer_size++] = '\0'; } } - + regval_ctr_addvalue( values, "Dependent Files", REG_MULTI_SZ, buffer, buffer_size ); - + SAFE_FREE( buffer ); - + return; } @@ -968,12 +982,12 @@ static int driver_arch_fetch_values( char *key, REGVAL_CTR *values ) 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 @@ -982,7 +996,7 @@ static int driver_arch_fetch_values( char *key, REGVAL_CTR *values ) */ fstrcpy( arch_environment, base ); - + keystr = subkeypath; if (!reg_split_path( keystr, &base, &subkeypath )) { return -1; @@ -992,16 +1006,16 @@ static int driver_arch_fetch_values( char *key, REGVAL_CTR *values ) 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; @@ -1009,34 +1023,34 @@ static int driver_arch_fetch_values( char *key, REGVAL_CTR *values ) 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 ); } @@ -1045,20 +1059,24 @@ static int driver_arch_fetch_values( char *key, REGVAL_CTR *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 ); } @@ -1069,11 +1087,11 @@ static int key_driver_fetch_values( const char *key, REGVAL_CTR *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; @@ -1081,14 +1099,14 @@ static int key_print_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys ) 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. ********************************************************************* *********************************************************************/ @@ -1096,16 +1114,16 @@ static int key_print_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys ) 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, @@ -1126,11 +1144,11 @@ static struct reg_dyn_tree print_registry[] = { &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 } }; @@ -1146,22 +1164,29 @@ static struct reg_dyn_tree print_registry[] = { -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; } @@ -1171,13 +1196,13 @@ static int match_registry_path( const char *key ) 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 ); } @@ -1187,13 +1212,13 @@ static int regprint_fetch_reg_keys( const char *key, REGSUBKEY_CTR *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 ); } @@ -1203,16 +1228,16 @@ static bool regprint_store_reg_keys( const char *key, REGSUBKEY_CTR *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 ); } @@ -1222,20 +1247,20 @@ static int regprint_fetch_reg_values( const char *key, REGVAL_CTR *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, @@ -1243,5 +1268,3 @@ REGISTRY_OPS printing_ops = { regprint_store_reg_values, NULL, NULL, NULL }; - - diff --git a/source3/registry/reg_util.c b/source3/registry/reg_util.c index 7eb3c2a3a5..cd0982d09a 100644 --- a/source3/registry/reg_util.c +++ b/source3/registry/reg_util.c @@ -7,12 +7,12 @@ * 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/>. */ @@ -28,100 +28,106 @@ 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; } /********************************************************************** @@ -135,14 +141,14 @@ int regval_convert_multi_sz( uint16 *multi_string, size_t byte_len, char ***valu 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 ) @@ -151,29 +157,29 @@ int regval_convert_multi_sz( uint16 *multi_string, size_t byte_len, char ***valu 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; } @@ -190,22 +196,22 @@ size_t regval_build_multi_sz( char **values, uint16 **buffer ) 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")); @@ -214,15 +220,15 @@ size_t regval_build_multi_sz( char **values, uint16 **buffer ) } 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; @@ -230,5 +236,3 @@ size_t regval_build_multi_sz( char **values, uint16 **buffer ) /* return number of bytes */ return buf_size*2; } - - |