ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Revert "advapi32: Fix RegEnumValueW when enumerating long values.". 

This reverts commit 443ef6e7a6.
The tests fail on all versions of Windows.
This commit is contained in:
Huw Davies 2015-06-22 21:23:54 +01:00 committed by Alexandre Julliard
parent d940ac2412
commit 645a31474c
2 changed files with 37 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
dlls/advapi32/registry.c
View File

@ -1922,47 +1922,53 @@ LSTATUS WINAPI RegEnumValueW( HKEY hkey, DWORD index, LPWSTR value, LPDWORD val_
status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation, status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
buffer, total_size, &total_size ); buffer, total_size, &total_size );
if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
/* retry with a dynamically allocated buffer */ if (value || data)
while (status == STATUS_BUFFER_OVERFLOW)
{ {
if (buf_ptr != buffer) heap_free( buf_ptr ); /* retry with a dynamically allocated buffer */
if (!(buf_ptr = heap_alloc( total_size ))) return ERROR_NOT_ENOUGH_MEMORY; while (status == STATUS_BUFFER_OVERFLOW)
info = (KEY_VALUE_FULL_INFORMATION *)buf_ptr;
status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
buf_ptr, total_size, &total_size );
}
if (status) goto done;
if (value)
{
if (info->NameLength/sizeof(WCHAR) >= *val_count)
{ {
status = STATUS_BUFFER_OVERFLOW; if (buf_ptr != buffer) heap_free( buf_ptr );
goto overflow; if (!(buf_ptr = heap_alloc( total_size )))
return ERROR_NOT_ENOUGH_MEMORY;
info = (KEY_VALUE_FULL_INFORMATION *)buf_ptr;
status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
buf_ptr, total_size, &total_size );
} }
memcpy( value, info->Name, info->NameLength );
*val_count = info->NameLength / sizeof(WCHAR);
value[*val_count] = 0;
}
if (data) if (status) goto done;
{
if (total_size - info->DataOffset > *count) if (value)
{ {
status = STATUS_BUFFER_OVERFLOW; if (info->NameLength/sizeof(WCHAR) >= *val_count)
goto overflow; {
status = STATUS_BUFFER_OVERFLOW;
goto overflow;
}
memcpy( value, info->Name, info->NameLength );
*val_count = info->NameLength / sizeof(WCHAR);
value[*val_count] = 0;
} }
memcpy( data, buf_ptr + info->DataOffset, total_size - info->DataOffset );
if (total_size - info->DataOffset <= *count-sizeof(WCHAR) && is_string(info->Type)) if (data)
{ {
/* if the type is REG_SZ and data is not 0-terminated if (total_size - info->DataOffset > *count)
* and there is enough space in the buffer NT appends a \0 */ {
WCHAR *ptr = (WCHAR *)(data + total_size - info->DataOffset); status = STATUS_BUFFER_OVERFLOW;
if (ptr > (WCHAR *)data && ptr[-1]) *ptr = 0; goto overflow;
}
memcpy( data, buf_ptr + info->DataOffset, total_size - info->DataOffset );
if (total_size - info->DataOffset <= *count-sizeof(WCHAR) && is_string(info->Type))
{
/* if the type is REG_SZ and data is not 0-terminated
* and there is enough space in the buffer NT appends a \0 */
WCHAR *ptr = (WCHAR *)(data + total_size - info->DataOffset);
if (ptr > (WCHAR *)data && ptr[-1]) *ptr = 0;
}
} }
} }
else status = STATUS_SUCCESS;
overflow: overflow:
if (type) *type = info->Type; if (type) *type = info->Type;

13
dlls/advapi32/tests/registry.c
View File

@ -522,8 +522,6 @@ static void test_enum_value(void)
static const WCHAR foobarW[] = {'f','o','o','b','a','r',0}; static const WCHAR foobarW[] = {'f','o','o','b','a','r',0};
static const WCHAR testW[] = {'T','e','s','t',0}; static const WCHAR testW[] = {'T','e','s','t',0};
static const WCHAR xxxW[] = {'x','x','x','x','x','x','x','x',0}; static const WCHAR xxxW[] = {'x','x','x','x','x','x','x','x',0};
WCHAR longW[128];
int i;
/* create the working key for new 'Test' value */ /* create the working key for new 'Test' value */
res = RegCreateKeyA( hkey_main, "TestKey", &test_key ); res = RegCreateKeyA( hkey_main, "TestKey", &test_key );
@ -712,17 +710,6 @@ static void test_enum_value(void)
ok( !memcmp( valueW, testW, sizeof(testW) ), "value is not 'Test'\n" ); ok( !memcmp( valueW, testW, sizeof(testW) ), "value is not 'Test'\n" );
ok( !memcmp( dataW, foobarW, sizeof(foobarW) ), "data is not 'foobar'\n" ); ok( !memcmp( dataW, foobarW, sizeof(foobarW) ), "data is not 'foobar'\n" );
/* tests the overflow case for the fixed "char buffer[]" in RegEnumValueW */
for (i = 0; i < sizeof(longW)/sizeof(WCHAR); i++) longW[i] = 'x';
longW[i - 1] = 0;
res = RegSetValueExW( test_key, testW, 0, REG_SZ, (const BYTE *)longW, sizeof(longW) );
ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %d\n", res );
data_count = 20;
type = 1234;
res = RegEnumValueW( test_key, 0, NULL, NULL, NULL, &type, NULL, &data_count);
ok( res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %d\n", res );
ok( data_count == sizeof(longW), "data_count set to %d\n", data_count );
cleanup: cleanup:
RegDeleteKeyA(test_key, ""); RegDeleteKeyA(test_key, "");
RegCloseKey(test_key); RegCloseKey(test_key);