Ros-diffs October 2017

ros-diffs@reactos.org

43 participants
275 discussions

[reactos] 02/02: [NTDLL_WINETEST] Sync with Wine Staging 2.16. CORE-13762

by Amine Khaldi

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f7932ba2de71f0340daa1… commit f7932ba2de71f0340daa18db32e083383b8e680b Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Sat Oct 21 14:36:29 2017 +0100 [NTDLL_WINETEST] Sync with Wine Staging 2.16. CORE-13762 --- modules/rostests/winetests/ntdll/CMakeLists.txt | 3 +- modules/rostests/winetests/ntdll/directory.c | 590 ++++++- modules/rostests/winetests/ntdll/exception.c | 934 ++++++++++- modules/rostests/winetests/ntdll/file.c | 750 +++++---- modules/rostests/winetests/ntdll/info.c | 625 +++++++- modules/rostests/winetests/ntdll/large_int.c | 118 +- modules/rostests/winetests/ntdll/ntdll_test.h | 4 - modules/rostests/winetests/ntdll/om.c | 1104 +++++++++++-- modules/rostests/winetests/ntdll/path.c | 9 +- modules/rostests/winetests/ntdll/pipe.c | 527 ++++++- modules/rostests/winetests/ntdll/process.c | 207 +++ modules/rostests/winetests/ntdll/reg.c | 76 +- modules/rostests/winetests/ntdll/rtl.c | 405 ++++- modules/rostests/winetests/ntdll/rtlbitmap.c | 16 +- modules/rostests/winetests/ntdll/string.c | 75 +- modules/rostests/winetests/ntdll/testlist.c | 2 + modules/rostests/winetests/ntdll/threadpool.c | 1919 +++++++++++++++++++++++ modules/rostests/winetests/ntdll/time.c | 121 ++ 18 files changed, 6783 insertions(+), 702 deletions(-) diff --git a/modules/rostests/winetests/ntdll/CMakeLists.txt b/modules/rostests/winetests/ntdll/CMakeLists.txt index 4fe5a26ed3..f1055f85db 100644 --- a/modules/rostests/winetests/ntdll/CMakeLists.txt +++ b/modules/rostests/winetests/ntdll/CMakeLists.txt @@ -1,7 +1,7 @@ include_directories(BEFORE ${REACTOS_SOURCE_DIR}/sdk/include/reactos/wine) remove_definitions(-DWINVER=0x502 -D_WIN32_IE=0x600 -D_WIN32_WINNT=0x502) -add_definitions(-D__WINESRC__) +add_definitions(-D__WINESRC__ -DWINETEST_USE_DBGSTR_LONGLONG) list(APPEND SOURCE atom.c @@ -17,6 +17,7 @@ list(APPEND SOURCE path.c pipe.c port.c + process.c reg.c rtl.c rtlbitmap.c diff --git a/modules/rostests/winetests/ntdll/directory.c b/modules/rostests/winetests/ntdll/directory.c index 89b786d384..21f22ad043 100644 --- a/modules/rostests/winetests/ntdll/directory.c +++ b/modules/rostests/winetests/ntdll/directory.c @@ -34,16 +34,20 @@ #define WIN32_NO_STATUS #include "wine/test.h" +#include "winnls.h" #include "wine/winternl.h" static NTSTATUS (WINAPI *pNtClose)( PHANDLE ); static NTSTATUS (WINAPI *pNtOpenFile) ( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, ULONG, ULONG ); static NTSTATUS (WINAPI *pNtQueryDirectoryFile)(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK, PVOID,ULONG,FILE_INFORMATION_CLASS,BOOLEAN,PUNICODE_STRING,BOOLEAN); +static NTSTATUS (WINAPI *pNtQueryInformationFile)(HANDLE,PIO_STATUS_BLOCK,PVOID,LONG,FILE_INFORMATION_CLASS); +static NTSTATUS (WINAPI *pNtSetInformationFile)(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS); static BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING,LPCSTR); static BOOL (WINAPI *pRtlDosPathNameToNtPathName_U)( LPCWSTR, PUNICODE_STRING, PWSTR*, CURDIR* ); static VOID (WINAPI *pRtlInitUnicodeString)( PUNICODE_STRING, LPCWSTR ); static VOID (WINAPI *pRtlFreeUnicodeString)( PUNICODE_STRING ); +static LONG (WINAPI *pRtlCompareUnicodeString)( const UNICODE_STRING*, const UNICODE_STRING*,BOOLEAN ); static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)( LPWSTR dst, DWORD dstlen, LPDWORD reslen, LPCSTR src, DWORD srclen ); static NTSTATUS (WINAPI *pRtlWow64EnableFsRedirection)( BOOLEAN enable ); @@ -53,47 +57,56 @@ static NTSTATUS (WINAPI *pRtlWow64EnableFsRedirectionEx)( ULONG disable, ULONG * static struct testfile_s { BOOL attr_done; /* set if attributes were tested for this file already */ const DWORD attr; /* desired attribute */ - const char *name; /* filename to use */ + WCHAR name[20]; /* filename to use */ const char *target; /* what to point to (only for reparse pts) */ const char *description; /* for error messages */ int nfound; /* How many were found (expect 1) */ - WCHAR nameW[20]; /* unicode version of name (filled in later) */ } testfiles[] = { - { 0, FILE_ATTRIBUTE_NORMAL, "n.tmp", NULL, "normal" }, - { 0, FILE_ATTRIBUTE_HIDDEN, "h.tmp", NULL, "hidden" }, - { 0, FILE_ATTRIBUTE_SYSTEM, "s.tmp", NULL, "system" }, - { 0, FILE_ATTRIBUTE_DIRECTORY, "d.tmp", NULL, "directory" }, - { 0, FILE_ATTRIBUTE_DIRECTORY, ".", NULL, ". directory" }, - { 0, FILE_ATTRIBUTE_DIRECTORY, "..", NULL, ".. directory" }, - { 0, 0, NULL } + { 0, FILE_ATTRIBUTE_NORMAL, {'l','o','n','g','f','i','l','e','n','a','m','e','.','t','m','p'}, "normal" }, + { 0, FILE_ATTRIBUTE_NORMAL, {'n','.','t','m','p',}, "normal" }, + { 0, FILE_ATTRIBUTE_HIDDEN, {'h','.','t','m','p',}, "hidden" }, + { 0, FILE_ATTRIBUTE_SYSTEM, {'s','.','t','m','p',}, "system" }, + { 0, FILE_ATTRIBUTE_DIRECTORY, {'d','.','t','m','p',}, "directory" }, + { 0, FILE_ATTRIBUTE_NORMAL, {0xe9,'a','.','t','m','p'}, "normal" }, + { 0, FILE_ATTRIBUTE_NORMAL, {0xc9,'b','.','t','m','p'}, "normal" }, + { 0, FILE_ATTRIBUTE_NORMAL, {'e','a','.','t','m','p'}, "normal" }, + { 0, FILE_ATTRIBUTE_DIRECTORY, {'.'}, ". directory" }, + { 0, FILE_ATTRIBUTE_DIRECTORY, {'.','.'}, ".. directory" } }; -static const int max_test_dir_size = 20; /* size of above plus some for .. etc */ +static const int test_dir_count = sizeof(testfiles) / sizeof(testfiles[0]); +static const int max_test_dir_size = sizeof(testfiles) / sizeof(testfiles[0]) + 5; /* size of above plus some for .. etc */ + +static const WCHAR dummyW[] = {'d','u','m','m','y',0}; +static const WCHAR dotW[] = {'.',0}; +static const WCHAR dotdotW[] = {'.','.',0}; +static const WCHAR backslashW[] = {'\\',0}; /* Create a test directory full of attribute test files, clear counts */ -static void set_up_attribute_test(const char *testdirA) +static void set_up_attribute_test(const WCHAR *testdir) { int i; BOOL ret; - ret = CreateDirectoryA(testdirA, NULL); - ok(ret, "couldn't create dir '%s', error %d\n", testdirA, GetLastError()); + ret = CreateDirectoryW(testdir, NULL); + ok(ret, "couldn't create dir %s, error %d\n", wine_dbgstr_w(testdir), GetLastError()); - for (i=0; testfiles[i].name; i++) { - char buf[MAX_PATH]; - pRtlMultiByteToUnicodeN(testfiles[i].nameW, sizeof(testfiles[i].nameW), NULL, testfiles[i].name, strlen(testfiles[i].name)+1); + for (i=0; i < test_dir_count; i++) { + WCHAR buf[MAX_PATH]; - if (strcmp(testfiles[i].name, ".") == 0 || strcmp(testfiles[i].name, "..") == 0) + if (lstrcmpW(testfiles[i].name, dotW) == 0 || lstrcmpW(testfiles[i].name, dotdotW) == 0) continue; - sprintf(buf, "%s\\%s", testdirA, testfiles[i].name); + lstrcpyW( buf, testdir ); + lstrcatW( buf, backslashW ); + lstrcatW( buf, testfiles[i].name ); if (testfiles[i].attr & FILE_ATTRIBUTE_DIRECTORY) { - ret = CreateDirectoryA(buf, NULL); - ok(ret, "couldn't create dir '%s', error %d\n", buf, GetLastError()); + ret = CreateDirectoryW(buf, NULL); + ok(ret, "couldn't create dir %s, error %d\n", wine_dbgstr_w(buf), GetLastError()); } else { - HANDLE h = CreateFileA(buf, + HANDLE h = CreateFileW(buf, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, testfiles[i].attr, 0); - ok( h != INVALID_HANDLE_VALUE, "failed to create temp file '%s'\n", buf ); + ok( h != INVALID_HANDLE_VALUE, "failed to create temp file %s\n", wine_dbgstr_w(buf) ); CloseHandle(h); } } @@ -103,32 +116,34 @@ static void reset_found_files(void) { int i; - for (i = 0; testfiles[i].name; i++) + for (i = 0; i < test_dir_count; i++) testfiles[i].nfound = 0; } /* Remove the given test directory and the attribute test files, if any */ -static void tear_down_attribute_test(const char *testdirA) +static void tear_down_attribute_test(const WCHAR *testdir) { int i; - for (i=0; testfiles[i].name; i++) { + for (i = 0; i < test_dir_count; i++) { int ret; - char buf[MAX_PATH]; - if (strcmp(testfiles[i].name, ".") == 0 || strcmp(testfiles[i].name, "..") == 0) + WCHAR buf[MAX_PATH]; + if (lstrcmpW(testfiles[i].name, dotW) == 0 || lstrcmpW(testfiles[i].name, dotdotW) == 0) continue; - sprintf(buf, "%s\\%s", testdirA, testfiles[i].name); + lstrcpyW( buf, testdir ); + lstrcatW( buf, backslashW ); + lstrcatW( buf, testfiles[i].name ); if (testfiles[i].attr & FILE_ATTRIBUTE_DIRECTORY) { - ret = RemoveDirectoryA(buf); + ret = RemoveDirectoryW(buf); ok(ret || (GetLastError() == ERROR_PATH_NOT_FOUND), - "Failed to rmdir %s, error %d\n", buf, GetLastError()); + "Failed to rmdir %s, error %d\n", wine_dbgstr_w(buf), GetLastError()); } else { - ret = DeleteFileA(buf); + ret = DeleteFileW(buf); ok(ret || (GetLastError() == ERROR_PATH_NOT_FOUND), - "Failed to rm %s, error %d\n", buf, GetLastError()); + "Failed to rm %s, error %d\n", wine_dbgstr_w(buf), GetLastError()); } } - RemoveDirectoryA(testdirA); + RemoveDirectoryW(testdir); } /* Match one found file against testfiles[], increment count if found */ @@ -141,35 +156,37 @@ static void tally_test_file(FILE_BOTH_DIRECTORY_INFORMATION *dir_info) WCHAR *nameW = dir_info->FileName; int namelen = dir_info->FileNameLength / sizeof(WCHAR); - for (i=0; testfiles[i].name; i++) { - int len = strlen(testfiles[i].name); - if (namelen != len || memcmp(nameW, testfiles[i].nameW, len*sizeof(WCHAR))) + for (i = 0; i < test_dir_count; i++) { + int len = lstrlenW(testfiles[i].name); + if (namelen != len || memcmp(nameW, testfiles[i].name, len*sizeof(WCHAR))) continue; if (!testfiles[i].attr_done) { - ok (attrib == (testfiles[i].attr & attribmask), "file %s: expected %s (%x), got %x (is your linux new enough?)\n", testfiles[i].name, testfiles[i].description, testfiles[i].attr, attrib); + ok (attrib == (testfiles[i].attr & attribmask), "file %s: expected %s (%x), got %x (is your linux new enough?)\n", wine_dbgstr_w(testfiles[i].name), testfiles[i].description, testfiles[i].attr, attrib); testfiles[i].attr_done = TRUE; } testfiles[i].nfound++; break; } - ok(testfiles[i].name != NULL, "unexpected file found\n"); + ok(i < test_dir_count, "unexpected file found %s\n", wine_dbgstr_wn(dir_info->FileName, namelen)); } static void test_flags_NtQueryDirectoryFile(OBJECT_ATTRIBUTES *attr, const char *testdirA, UNICODE_STRING *mask, BOOLEAN single_entry, BOOLEAN restart_flag) { - HANDLE dirh; + UNICODE_STRING dummy_mask; + HANDLE dirh, new_dirh; IO_STATUS_BLOCK io; UINT data_pos, data_size; UINT data_len; /* length of dir data */ BYTE data[8192]; /* directory data */ FILE_BOTH_DIRECTORY_INFORMATION *dir_info; - DWORD status; + NTSTATUS status; int numfiles; int i; reset_found_files(); + pRtlInitUnicodeString( &dummy_mask, dummyW ); data_size = mask ? offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[256] ) : sizeof(data); @@ -182,12 +199,18 @@ static void test_flags_NtQueryDirectoryFile(OBJECT_ATTRIBUTES *attr, const char return; } - pNtQueryDirectoryFile( dirh, NULL, NULL, NULL, &io, data, data_size, - FileBothDirectoryInformation, single_entry, mask, restart_flag ); + U(io).Status = 0xdeadbeef; + status = pNtQueryDirectoryFile( dirh, NULL, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, single_entry, mask, restart_flag ); + ok (status == STATUS_SUCCESS, "failed to query directory; status %x\n", status); ok (U(io).Status == STATUS_SUCCESS, "failed to query directory; status %x\n", U(io).Status); data_len = io.Information; ok (data_len >= sizeof(FILE_BOTH_DIRECTORY_INFORMATION), "not enough data in directory\n"); + DuplicateHandle( GetCurrentProcess(), dirh, GetCurrentProcess(), &new_dirh, + 0, FALSE, DUPLICATE_SAME_ACCESS ); + pNtClose(dirh); + data_pos = 0; numfiles = 0; while ((data_pos < data_len) && (numfiles < max_test_dir_size)) { @@ -196,11 +219,12 @@ static void test_flags_NtQueryDirectoryFile(OBJECT_ATTRIBUTES *attr, const char tally_test_file(dir_info); if (dir_info->NextEntryOffset == 0) { - pNtQueryDirectoryFile( dirh, 0, NULL, NULL, &io, data, data_size, - FileBothDirectoryInformation, single_entry, mask, FALSE ); - if (U(io).Status == STATUS_NO_MORE_FILES) - break; - ok (U(io).Status == STATUS_SUCCESS, "failed to query directory; status %x\n", U(io).Status); + U(io).Status = 0xdeadbeef; + status = pNtQueryDirectoryFile( new_dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, single_entry, &dummy_mask, FALSE ); + ok (U(io).Status == status, "wrong status %x / %x\n", status, U(io).Status); + if (status == STATUS_NO_MORE_FILES) break; + ok (status == STATUS_SUCCESS, "failed to query directory; status %x\n", status); data_len = io.Information; if (data_len < sizeof(FILE_BOTH_DIRECTORY_INFORMATION)) break; @@ -213,33 +237,238 @@ static void test_flags_NtQueryDirectoryFile(OBJECT_ATTRIBUTES *attr, const char ok(numfiles < max_test_dir_size, "too many loops\n"); if (mask) - for (i=0; testfiles[i].name; i++) - ok(testfiles[i].nfound == (testfiles[i].nameW == mask->Buffer), + for (i = 0; i < test_dir_count; i++) + ok(testfiles[i].nfound == (testfiles[i].name == mask->Buffer), "Wrong number %d of %s files found (single_entry=%d,mask=%s)\n", testfiles[i].nfound, testfiles[i].description, single_entry, wine_dbgstr_wn(mask->Buffer, mask->Length/sizeof(WCHAR) )); else - for (i=0; testfiles[i].name; i++) + for (i = 0; i < test_dir_count; i++) ok(testfiles[i].nfound == 1, "Wrong number %d of %s files found (single_entry=%d,restart=%d)\n", testfiles[i].nfound, testfiles[i].description, single_entry, restart_flag); - pNtClose(dirh); + pNtClose(new_dirh); } -static void test_NtQueryDirectoryFile(void) +static void test_directory_sort( const WCHAR *testdir ) { OBJECT_ATTRIBUTES attr; UNICODE_STRING ntdirname; + IO_STATUS_BLOCK io; + UINT data_pos, data_len, count; + BYTE data[8192]; + WCHAR prev[MAX_PATH], name[MAX_PATH]; + UNICODE_STRING prev_str, name_str; + FILE_BOTH_DIRECTORY_INFORMATION *info; + NTSTATUS status; + HANDLE handle; + int res; + + if (!pRtlDosPathNameToNtPathName_U( testdir, &ntdirname, NULL, NULL )) + { + ok(0, "RtlDosPathNametoNtPathName_U failed\n"); + return; + } + InitializeObjectAttributes( &attr, &ntdirname, OBJ_CASE_INSENSITIVE, 0, NULL ); + status = pNtOpenFile( &handle, SYNCHRONIZE | FILE_LIST_DIRECTORY, &attr, &io, FILE_SHARE_READ, + FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT | FILE_DIRECTORY_FILE ); + ok(status == STATUS_SUCCESS, "failed to open dir %s\n", wine_dbgstr_w(testdir) ); + + U(io).Status = 0xdeadbeef; + status = pNtQueryDirectoryFile( handle, NULL, NULL, NULL, &io, data, sizeof(data), + FileBothDirectoryInformation, FALSE, NULL, TRUE ); + ok( status == STATUS_SUCCESS, "failed to query directory; status %x\n", status ); + ok( U(io).Status == STATUS_SUCCESS, "failed to query directory; status %x\n", U(io).Status ); + data_len = io.Information; + ok( data_len >= sizeof(FILE_BOTH_DIRECTORY_INFORMATION), "not enough data in directory\n" ); + data_pos = 0; + count = 0; + + while (data_pos < data_len) + { + info = (FILE_BOTH_DIRECTORY_INFORMATION *)(data + data_pos); + + memcpy( name, info->FileName, info->FileNameLength ); + name[info->FileNameLength / sizeof(WCHAR)] = 0; + switch (count) + { + case 0: /* first entry must be '.' */ + ok( !lstrcmpW( name, dotW ), "wrong name %s\n", wine_dbgstr_w( name )); + break; + case 1: /* second entry must be '..' */ + ok( !lstrcmpW( name, dotdotW ), "wrong name %s\n", wine_dbgstr_w( name )); + break; + case 2: /* nothing to compare against */ + break; + default: + pRtlInitUnicodeString( &prev_str, prev ); + pRtlInitUnicodeString( &name_str, name ); + res = pRtlCompareUnicodeString( &prev_str, &name_str, TRUE ); + ok( res < 0, "wrong result %d %s %s\n", res, wine_dbgstr_w( prev ), wine_dbgstr_w( name )); + break; + } + count++; + lstrcpyW( prev, name ); + + if (info->NextEntryOffset == 0) + { + U(io).Status = 0xdeadbeef; + status = pNtQueryDirectoryFile( handle, 0, NULL, NULL, &io, data, sizeof(data), + FileBothDirectoryInformation, FALSE, NULL, FALSE ); + ok (U(io).Status == status, "wrong status %x / %x\n", status, U(io).Status); + if (status == STATUS_NO_MORE_FILES) break; + ok( status == STATUS_SUCCESS, "failed to query directory; status %x\n", status ); + data_len = io.Information; + data_pos = 0; + } + else data_pos += info->NextEntryOffset; + } + + pNtClose( handle ); + pRtlFreeUnicodeString( &ntdirname ); +} + +static void test_NtQueryDirectoryFile_classes( HANDLE handle, UNICODE_STRING *mask ) +{ + IO_STATUS_BLOCK io; + UINT data_size; + ULONG data[256]; + NTSTATUS status; + int class; + + for (class = 0; class < FileMaximumInformation; class++) + { + U(io).Status = 0xdeadbeef; + U(io).Information = 0xdeadbeef; + data_size = 0; + memset( data, 0x55, sizeof(data) ); + + status = pNtQueryDirectoryFile( handle, 0, NULL, NULL, &io, data, data_size, + class, FALSE, mask, TRUE ); + ok( U(io).Status == 0xdeadbeef, "%u: wrong status %x\n", class, U(io).Status ); + ok( U(io).Information == 0xdeadbeef, "%u: wrong info %lx\n", class, U(io).Information ); + ok(data[0] == 0x55555555, "%u: wrong offset %x\n", class, data[0] ); + + switch (class) + { + case FileIdGlobalTxDirectoryInformation: + case FileIdExtdDirectoryInformation: + case FileIdExtdBothDirectoryInformation: + if (status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED) continue; + /* fall through */ + case FileDirectoryInformation: + case FileFullDirectoryInformation: + case FileBothDirectoryInformation: + case FileNamesInformation: + case FileIdBothDirectoryInformation: + case FileIdFullDirectoryInformation: + case FileObjectIdInformation: + case FileQuotaInformation: + case FileReparsePointInformation: + ok( status == STATUS_INFO_LENGTH_MISMATCH, "%u: wrong status %x\n", class, status ); + break; + default: + ok( status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED, + "%u: wrong status %x\n", class, status ); + continue; + } + + for (data_size = 1; data_size < sizeof(data); data_size++) + { + status = pNtQueryDirectoryFile( handle, 0, NULL, NULL, &io, data, data_size, + class, FALSE, mask, TRUE ); + if (status == STATUS_BUFFER_OVERFLOW) + { + ok( U(io).Status == STATUS_BUFFER_OVERFLOW, "%u: wrong status %x\n", class, U(io).Status ); + ok( U(io).Information == data_size, "%u: wrong info %lx\n", class, U(io).Information ); + ok(data[0] == 0, "%u: wrong offset %x\n", class, data[0] ); + } + else + { + ok( U(io).Status == 0xdeadbeef, "%u: wrong status %x\n", class, U(io).Status ); + ok( U(io).Information == 0xdeadbeef, "%u: wrong info %lx\n", class, U(io).Information ); + ok(data[0] == 0x55555555, "%u: wrong offset %x\n", class, data[0] ); + } + if (status != STATUS_INFO_LENGTH_MISMATCH) break; + } + + switch (class) + { + case FileDirectoryInformation: + ok( status == STATUS_BUFFER_OVERFLOW, "%u: wrong status %x\n", class, status ); + ok( data_size == ((offsetof( FILE_DIRECTORY_INFORMATION, FileName[1] ) + 7) & ~7), + "%u: wrong size %u\n", class, data_size ); + break; + case FileFullDirectoryInformation: + ok( status == STATUS_BUFFER_OVERFLOW, "%u: wrong status %x\n", class, status ); + ok( data_size == ((offsetof( FILE_FULL_DIRECTORY_INFORMATION, FileName[1] ) + 7) & ~7), + "%u: wrong size %u\n", class, data_size ); + break; + case FileBothDirectoryInformation: + ok( status == STATUS_BUFFER_OVERFLOW, "%u: wrong status %x\n", class, status ); + ok( data_size == ((offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[1] ) + 7) & ~7), + "%u: wrong size %u\n", class, data_size ); + break; + case FileNamesInformation: + ok( status == STATUS_BUFFER_OVERFLOW, "%u: wrong status %x\n", class, status ); + ok( data_size == ((offsetof( FILE_NAMES_INFORMATION, FileName[1] ) + 7) & ~7), + "%u: wrong size %u\n", class, data_size ); + break; + case FileIdBothDirectoryInformation: + ok( status == STATUS_BUFFER_OVERFLOW, "%u: wrong status %x\n", class, status ); + ok( data_size == ((offsetof( FILE_ID_BOTH_DIRECTORY_INFORMATION, FileName[1] ) + 7) & ~7), + "%u: wrong size %u\n", class, data_size ); + break; + case FileIdFullDirectoryInformation: + ok( status == STATUS_BUFFER_OVERFLOW, "%u: wrong status %x\n", class, status ); + ok( data_size == ((offsetof( FILE_ID_FULL_DIRECTORY_INFORMATION, FileName[1] ) + 7) & ~7), + "%u: wrong size %u\n", class, data_size ); + break; + case FileIdGlobalTxDirectoryInformation: + ok( status == STATUS_BUFFER_OVERFLOW, "%u: wrong status %x\n", class, status ); + ok( data_size == ((offsetof( FILE_ID_GLOBAL_TX_DIR_INFORMATION, FileName[1] ) + 7) & ~7), + "%u: wrong size %u\n", class, data_size ); + break; + case FileObjectIdInformation: + ok( status == STATUS_INVALID_INFO_CLASS, "%u: wrong status %x\n", class, status ); + ok( data_size == sizeof(FILE_OBJECTID_INFORMATION), "%u: wrong size %u\n", class, data_size ); + break; + case FileQuotaInformation: + ok( status == STATUS_INVALID_INFO_CLASS, "%u: wrong status %x\n", class, status ); + ok( data_size == sizeof(FILE_QUOTA_INFORMATION), "%u: wrong size %u\n", class, data_size ); + break; + case FileReparsePointInformation: + ok( status == STATUS_INVALID_INFO_CLASS, "%u: wrong status %x\n", class, status ); + ok( data_size == sizeof(FILE_REPARSE_POINT_INFORMATION), "%u: wrong size %u\n", class, data_size ); + break; + } + } +} + +static void test_NtQueryDirectoryFile(void) +{ + OBJECT_ATTRIBUTES attr; + UNICODE_STRING ntdirname, mask; char testdirA[MAX_PATH]; WCHAR testdirW[MAX_PATH]; int i; + IO_STATUS_BLOCK io; + WCHAR short_name[12]; + UINT data_size; + BYTE data[8192]; + FILE_BOTH_DIRECTORY_INFORMATION *next, *fbdi = (FILE_BOTH_DIRECTORY_INFORMATION*)data; + FILE_POSITION_INFORMATION pos_info; + FILE_NAMES_INFORMATION *names; + const WCHAR *filename = fbdi->FileName; + NTSTATUS status; + HANDLE dirh; /* Clean up from prior aborted run, if any, then set up test files */ ok(GetTempPathA(MAX_PATH, testdirA), "couldn't get temp dir\n"); strcat(testdirA, "NtQueryDirectoryFile.tmp"); - tear_down_attribute_test(testdirA); - set_up_attribute_test(testdirA); - pRtlMultiByteToUnicodeN(testdirW, sizeof(testdirW), NULL, testdirA, strlen(testdirA)+1); + tear_down_attribute_test(testdirW); + set_up_attribute_test(testdirW); + if (!pRtlDosPathNameToNtPathName_U(testdirW, &ntdirname, NULL, NULL)) { ok(0, "RtlDosPathNametoNtPathName_U failed\n"); @@ -252,21 +481,250 @@ static void test_NtQueryDirectoryFile(void) test_flags_NtQueryDirectoryFile(&attr, testdirA, NULL, TRUE, TRUE); test_flags_NtQueryDirectoryFile(&attr, testdirA, NULL, TRUE, FALSE); - for (i = 0; testfiles[i].name; i++) + for (i = 0; i < test_dir_count; i++) { - UNICODE_STRING mask; - - if (testfiles[i].nameW[0] == '.') continue; /* . and .. as masks are broken on Windows */ - mask.Buffer = testfiles[i].nameW; - mask.Length = mask.MaximumLength = lstrlenW(testfiles[i].nameW) * sizeof(WCHAR); + if (testfiles[i].name[0] == '.') continue; /* . and .. as masks are broken on Windows */ + mask.Buffer = testfiles[i].name; + mask.Length = mask.MaximumLength = lstrlenW(testfiles[i].name) * sizeof(WCHAR); test_flags_NtQueryDirectoryFile(&attr, testdirA, &mask, FALSE, TRUE); test_flags_NtQueryDirectoryFile(&attr, testdirA, &mask, FALSE, FALSE); test_flags_NtQueryDirectoryFile(&attr, testdirA, &mask, TRUE, TRUE); test_flags_NtQueryDirectoryFile(&attr, testdirA, &mask, TRUE, FALSE); } + /* short path passed as mask */ + status = pNtOpenFile(&dirh, SYNCHRONIZE | FILE_LIST_DIRECTORY, &attr, &io, FILE_SHARE_READ, + FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT | FILE_DIRECTORY_FILE); + ok(status == STATUS_SUCCESS, "failed to open dir '%s'\n", testdirA); + if (status != STATUS_SUCCESS) { + skip("can't test if we can't open the directory\n"); + return; + } + status = pNtQueryInformationFile( dirh, &io, &pos_info, sizeof(pos_info), FilePositionInformation ); + ok( status == STATUS_SUCCESS, "NtQueryInformationFile failed %x\n", status ); + ok( pos_info.CurrentByteOffset.QuadPart == 0, "wrong pos %s\n", + wine_dbgstr_longlong(pos_info.CurrentByteOffset.QuadPart)); + + pos_info.CurrentByteOffset.QuadPart = 0xbeef; + status = pNtSetInformationFile( dirh, &io, &pos_info, sizeof(pos_info), FilePositionInformation ); + ok( status == STATUS_SUCCESS, "NtQueryInformationFile failed %x\n", status ); + + status = pNtQueryInformationFile( dirh, &io, &pos_info, sizeof(pos_info), FilePositionInformation ); + ok( status == STATUS_SUCCESS, "NtQueryInformationFile failed %x\n", status ); + ok( pos_info.CurrentByteOffset.QuadPart == 0xbeef, "wrong pos %s\n", + wine_dbgstr_longlong(pos_info.CurrentByteOffset.QuadPart)); + + mask.Buffer = testfiles[0].name; + mask.Length = mask.MaximumLength = lstrlenW(testfiles[0].name) * sizeof(WCHAR); + data_size = offsetof(FILE_BOTH_DIRECTORY_INFORMATION, FileName[256]); + U(io).Status = 0xdeadbeef; + status = pNtQueryDirectoryFile(dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, TRUE, &mask, FALSE); + ok(status == STATUS_SUCCESS, "failed to query directory; status %x\n", status); + ok(U(io).Status == STATUS_SUCCESS, "failed to query directory; status %x\n", U(io).Status); + ok(fbdi->ShortName[0], "ShortName is empty\n"); + + status = pNtQueryInformationFile( dirh, &io, &pos_info, sizeof(pos_info), FilePositionInformation ); + ok( status == STATUS_SUCCESS, "NtQueryInformationFile failed %x\n", status ); + ok( pos_info.CurrentByteOffset.QuadPart == 0xbeef, "wrong pos %s\n", + wine_dbgstr_longlong(pos_info.CurrentByteOffset.QuadPart) ); + + mask.Length = mask.MaximumLength = fbdi->ShortNameLength; + memcpy(short_name, fbdi->ShortName, mask.Length); + mask.Buffer = short_name; + U(io).Status = 0xdeadbeef; + U(io).Information = 0xdeadbeef; + status = pNtQueryDirectoryFile(dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, TRUE, &mask, TRUE); + ok(status == STATUS_SUCCESS, "failed to query directory status %x\n", status); + ok(U(io).Status == STATUS_SUCCESS, "failed to query directory status %x\n", U(io).Status); + ok(U(io).Information == offsetof(FILE_BOTH_DIRECTORY_INFORMATION, FileName[lstrlenW(testfiles[0].name)]), + "wrong info %lx\n", U(io).Information); + ok(fbdi->FileNameLength == lstrlenW(testfiles[0].name)*sizeof(WCHAR) && + !memcmp(fbdi->FileName, testfiles[0].name, fbdi->FileNameLength), + "incorrect long file name: %s\n", wine_dbgstr_wn(fbdi->FileName, + fbdi->FileNameLength/sizeof(WCHAR))); + + status = pNtQueryInformationFile( dirh, &io, &pos_info, sizeof(pos_info), FilePositionInformation ); + ok( status == STATUS_SUCCESS, "NtQueryInformationFile failed %x\n", status ); + ok( pos_info.CurrentByteOffset.QuadPart == 0xbeef, "wrong pos %s\n", + wine_dbgstr_longlong(pos_info.CurrentByteOffset.QuadPart) ); + + /* tests with short buffer */ + memset( data, 0x55, data_size ); + U(io).Status = 0xdeadbeef; + U(io).Information = 0xdeadbeef; + data_size = offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[1] ); + status = pNtQueryDirectoryFile(dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, TRUE, &mask, TRUE); + ok( status == STATUS_BUFFER_OVERFLOW, "wrong status %x\n", status ); + ok( U(io).Status == STATUS_BUFFER_OVERFLOW, "wrong status %x\n", U(io).Status ); + ok( U(io).Information == data_size || broken( U(io).Information == 0), + "wrong info %lx\n", U(io).Information ); + ok( fbdi->NextEntryOffset == 0, "wrong offset %x\n", fbdi->NextEntryOffset ); + ok( fbdi->FileNameLength == lstrlenW(testfiles[0].name) * sizeof(WCHAR), + "wrong length %x\n", fbdi->FileNameLength ); + ok( filename[0] == testfiles[0].name[0], "incorrect long file name: %s\n", + wine_dbgstr_wn(fbdi->FileName, fbdi->FileNameLength/sizeof(WCHAR))); + ok( filename[1] == 0x5555, "incorrect long file name: %s\n", + wine_dbgstr_wn(fbdi->FileName, fbdi->FileNameLength/sizeof(WCHAR))); + + test_NtQueryDirectoryFile_classes( dirh, &mask ); + + /* mask may or may not be ignored when restarting the search */ + pRtlInitUnicodeString( &mask, dummyW ); + U(io).Status = 0xdeadbeef; + data_size = offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[256] ); + status = pNtQueryDirectoryFile(dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, TRUE, &mask, TRUE); + ok( status == STATUS_SUCCESS || status == STATUS_NO_MORE_FILES, "wrong status %x\n", status ); + ok( U(io).Status == status, "wrong status %x / %x\n", U(io).Status, status ); + if (!status) + ok( fbdi->FileNameLength == lstrlenW(testfiles[0].name)*sizeof(WCHAR) && + !memcmp(fbdi->FileName, testfiles[0].name, fbdi->FileNameLength), + "incorrect long file name: %s\n", + wine_dbgstr_wn(fbdi->FileName, fbdi->FileNameLength/sizeof(WCHAR))); + + pNtClose(dirh); + + status = pNtOpenFile(&dirh, SYNCHRONIZE | FILE_LIST_DIRECTORY, &attr, &io, FILE_SHARE_READ, + FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT | FILE_DIRECTORY_FILE); + ok(status == STATUS_SUCCESS, "failed to open dir '%s'\n", testdirA); + + memset( data, 0x55, data_size ); + data_size = sizeof(data); + U(io).Status = 0xdeadbeef; + U(io).Information = 0xdeadbeef; + status = pNtQueryDirectoryFile(dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, FALSE, NULL, TRUE); + ok(status == STATUS_SUCCESS, "wrong status %x\n", status); + ok(U(io).Status == STATUS_SUCCESS, "wrong status %x\n", U(io).Status); + ok(U(io).Information > 0 && U(io).Information < data_size, "wrong info %lx\n", U(io).Information); + ok( fbdi->NextEntryOffset == ((offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[1] ) + 7) & ~7), + "wrong offset %x\n", fbdi->NextEntryOffset ); + ok( fbdi->FileNameLength == sizeof(WCHAR), "wrong length %x\n", fbdi->FileNameLength ); + ok( fbdi->FileName[0] == '.', "incorrect long file name: %s\n", + wine_dbgstr_wn(fbdi->FileName, fbdi->FileNameLength/sizeof(WCHAR))); + next = (FILE_BOTH_DIRECTORY_INFORMATION *)(data + fbdi->NextEntryOffset); + ok( next->NextEntryOffset == ((offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[2] ) + 7) & ~7), + "wrong offset %x\n", next->NextEntryOffset ); + ok( next->FileNameLength == 2 * sizeof(WCHAR), "wrong length %x\n", next->FileNameLength ); + filename = next->FileName; + ok( filename[0] == '.' && filename[1] == '.', "incorrect long file name: %s\n", + wine_dbgstr_wn(next->FileName, next->FileNameLength/sizeof(WCHAR))); + + data_size = fbdi->NextEntryOffset + offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[1] ), + memset( data, 0x55, data_size ); + U(io).Status = 0xdeadbeef; + U(io).Information = 0xdeadbeef; + status = pNtQueryDirectoryFile( dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, FALSE, NULL, TRUE ); + ok( status == STATUS_SUCCESS, "wrong status %x\n", status ); + ok( U(io).Status == STATUS_SUCCESS, "wrong status %x\n", U(io).Status ); + ok( U(io).Information == offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[1] ), + "wrong info %lx\n", U(io).Information ); + ok( fbdi->NextEntryOffset == 0, "wrong offset %x\n", fbdi->NextEntryOffset ); + ok( fbdi->FileNameLength == sizeof(WCHAR), "wrong length %x\n", fbdi->FileNameLength ); + ok( fbdi->FileName[0] == '.', "incorrect long file name: %s\n", + wine_dbgstr_wn(fbdi->FileName, fbdi->FileNameLength/sizeof(WCHAR))); + next = (FILE_BOTH_DIRECTORY_INFORMATION *)&fbdi->FileName[1]; + ok( next->NextEntryOffset == 0x55555555, "wrong offset %x\n", next->NextEntryOffset ); + + data_size = fbdi->NextEntryOffset + offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[2] ), + memset( data, 0x55, data_size ); + U(io).Status = 0xdeadbeef; + U(io).Information = 0xdeadbeef; + status = pNtQueryDirectoryFile( dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, FALSE, NULL, TRUE ); + ok( status == STATUS_SUCCESS, "wrong status %x\n", status ); + ok( U(io).Status == STATUS_SUCCESS, "wrong status %x\n", U(io).Status ); + ok( U(io).Information == offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[1] ), + "wrong info %lx\n", U(io).Information ); + ok( fbdi->NextEntryOffset == 0, "wrong offset %x\n", fbdi->NextEntryOffset ); + + data_size = ((offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[1] ) + 7) & ~7) + + offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[2] ); + memset( data, 0x55, data_size ); + U(io).Status = 0xdeadbeef; + U(io).Information = 0xdeadbeef; + status = pNtQueryDirectoryFile( dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, FALSE, NULL, TRUE ); + ok( status == STATUS_SUCCESS, "wrong status %x\n", status ); + ok( U(io).Status == STATUS_SUCCESS, "wrong status %x\n", U(io).Status ); + ok( U(io).Information == data_size, "wrong info %lx / %x\n", U(io).Information, data_size ); + ok( fbdi->NextEntryOffset == ((offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[1] ) + 7) & ~7), + "wrong offset %x\n", fbdi->NextEntryOffset ); + ok( fbdi->FileNameLength == sizeof(WCHAR), "wrong length %x\n", fbdi->FileNameLength ); + ok( fbdi->FileName[0] == '.', "incorrect long file name: %s\n", + wine_dbgstr_wn(fbdi->FileName, fbdi->FileNameLength/sizeof(WCHAR))); + next = (FILE_BOTH_DIRECTORY_INFORMATION *)(data + fbdi->NextEntryOffset); + ok( next->NextEntryOffset == 0, "wrong offset %x\n", next->NextEntryOffset ); + ok( next->FileNameLength == 2 * sizeof(WCHAR), "wrong length %x\n", next->FileNameLength ); + filename = next->FileName; + ok( filename[0] == '.' && filename[1] == '.', "incorrect long file name: %s\n", + wine_dbgstr_wn(next->FileName, next->FileNameLength/sizeof(WCHAR))); + + data_size = ((offsetof( FILE_NAMES_INFORMATION, FileName[1] ) + 7) & ~7) + + offsetof( FILE_NAMES_INFORMATION, FileName[2] ); + memset( data, 0x55, data_size ); + U(io).Status = 0xdeadbeef; + U(io).Information = 0xdeadbeef; + status = pNtQueryDirectoryFile( dirh, 0, NULL, NULL, &io, data, data_size, + FileNamesInformation, FALSE, NULL, TRUE ); + ok( status == STATUS_SUCCESS, "wrong status %x\n", status ); + ok( U(io).Status == STATUS_SUCCESS, "wrong status %x\n", U(io).Status ); + ok( U(io).Information == data_size, "wrong info %lx / %x\n", U(io).Information, data_size ); + names = (FILE_NAMES_INFORMATION *)data; + ok( names->NextEntryOffset == ((offsetof( FILE_NAMES_INFORMATION, FileName[1] ) + 7) & ~7), + "wrong offset %x\n", names->NextEntryOffset ); + ok( names->FileNameLength == sizeof(WCHAR), "wrong length %x\n", names->FileNameLength ); + ok( names->FileName[0] == '.', "incorrect long file name: %s\n", + wine_dbgstr_wn(names->FileName, names->FileNameLength/sizeof(WCHAR))); + names = (FILE_NAMES_INFORMATION *)(data + names->NextEntryOffset); + ok( names->NextEntryOffset == 0, "wrong offset %x\n", names->NextEntryOffset ); + ok( names->FileNameLength == 2 * sizeof(WCHAR), "wrong length %x\n", names->FileNameLength ); + filename = names->FileName; + ok( filename[0] == '.' && filename[1] == '.', "incorrect long file name: %s\n", + wine_dbgstr_wn(names->FileName, names->FileNameLength/sizeof(WCHAR))); + + pNtClose(dirh); + + /* create new handle to change mask */ + status = pNtOpenFile(&dirh, SYNCHRONIZE | FILE_LIST_DIRECTORY, &attr, &io, FILE_SHARE_READ, + FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT | FILE_DIRECTORY_FILE); + ok(status == STATUS_SUCCESS, "failed to open dir '%s'\n", testdirA); + + pRtlInitUnicodeString( &mask, dummyW ); + U(io).Status = 0xdeadbeef; + data_size = sizeof(data); + status = pNtQueryDirectoryFile(dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, TRUE, &mask, TRUE); + ok(status == STATUS_NO_SUCH_FILE, "wrong status %x\n", status); + ok(U(io).Status == 0xdeadbeef, "wrong status %x\n", U(io).Status); + + U(io).Status = 0xdeadbeef; + status = pNtQueryDirectoryFile(dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, TRUE, NULL, FALSE); + ok(status == STATUS_NO_MORE_FILES, "wrong status %x\n", status); + ok(U(io).Status == STATUS_NO_MORE_FILES, "wrong status %x\n", U(io).Status); + + U(io).Status = 0xdeadbeef; + status = pNtQueryDirectoryFile(dirh, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, TRUE, NULL, TRUE); + ok(status == STATUS_NO_MORE_FILES, "wrong status %x\n", status); + ok(U(io).Status == STATUS_NO_MORE_FILES, "wrong status %x\n", U(io).Status); + + pNtClose(dirh); + + U(io).Status = 0xdeadbeef; + status = pNtQueryDirectoryFile( (HANDLE)0xbeef, 0, NULL, NULL, &io, data, data_size, + FileBothDirectoryInformation, TRUE, NULL, TRUE ); + ok(status == STATUS_INVALID_HANDLE, "wrong status %x\n", status); + ok(U(io).Status == 0xdeadbeef, "wrong status %x\n", U(io).Status); + done: - tear_down_attribute_test(testdirA); + test_directory_sort( testdirW ); + tear_down_attribute_test( testdirW ); pRtlFreeUnicodeString(&ntdirname); } @@ -403,6 +861,8 @@ static void test_redirection(void) ok( status == STATUS_ACCESS_VIOLATION, "RtlWow64EnableFsRedirectionEx failed with status %x\n", status ); status = pRtlWow64EnableFsRedirectionEx( TRUE, (void*)1 ); ok( status == STATUS_ACCESS_VIOLATION, "RtlWow64EnableFsRedirectionEx failed with status %x\n", status ); + status = pRtlWow64EnableFsRedirectionEx( TRUE, (void*)0xDEADBEEF ); + ok( status == STATUS_ACCESS_VIOLATION, "RtlWow64EnableFsRedirectionEx failed with status %x\n", status ); status = pRtlWow64EnableFsRedirection( FALSE ); ok( !status, "RtlWow64EnableFsRedirectionEx failed status %x\n", status ); @@ -415,6 +875,7 @@ static void test_redirection(void) START_TEST(directory) { + WCHAR sysdir[MAX_PATH]; HMODULE hntdll = GetModuleHandleA("ntdll.dll"); if (!hntdll) { @@ -425,14 +886,19 @@ START_TEST(directory) pNtClose = (void *)GetProcAddress(hntdll, "NtClose"); pNtOpenFile = (void *)GetProcAddress(hntdll, "NtOpenFile"); pNtQueryDirectoryFile = (void *)GetProcAddress(hntdll, "NtQueryDirectoryFile"); + pNtQueryInformationFile = (void *)GetProcAddress(hntdll, "NtQueryInformationFile"); + pNtSetInformationFile = (void *)GetProcAddress(hntdll, "NtSetInformationFile"); pRtlCreateUnicodeStringFromAsciiz = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeStringFromAsciiz"); pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U"); pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString"); pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString"); + pRtlCompareUnicodeString = (void *)GetProcAddress(hntdll, "RtlCompareUnicodeString"); pRtlMultiByteToUnicodeN = (void *)GetProcAddress(hntdll,"RtlMultiByteToUnicodeN"); pRtlWow64EnableFsRedirection = (void *)GetProcAddress(hntdll,"RtlWow64EnableFsRedirection"); pRtlWow64EnableFsRedirectionEx = (void *)GetProcAddress(hntdll,"RtlWow64EnableFsRedirectionEx"); + GetSystemDirectoryW( sysdir, MAX_PATH ); + test_directory_sort( sysdir ); test_NtQueryDirectoryFile(); test_NtQueryDirectoryFile_case(); test_redirection(); diff --git a/modules/rostests/winetests/ntdll/exception.c b/modules/rostests/winetests/ntdll/exception.c index 4bd400bb15..8dc2d90482 100644 --- a/modules/rostests/winetests/ntdll/exception.c +++ b/modules/rostests/winetests/ntdll/exception.c @@ -39,11 +39,11 @@ static void *code_mem; -static struct _TEB * (WINAPI *pNtCurrentTeb)(void); static NTSTATUS (WINAPI *pNtGetContextThread)(HANDLE,CONTEXT*); static NTSTATUS (WINAPI *pNtSetContextThread)(HANDLE,CONTEXT*); static NTSTATUS (WINAPI *pRtlRaiseException)(EXCEPTION_RECORD *rec); static PVOID (WINAPI *pRtlUnwind)(PVOID, PVOID, PEXCEPTION_RECORD, PVOID); +static VOID (WINAPI *pRtlCaptureContext)(CONTEXT*); static PVOID (WINAPI *pRtlAddVectoredExceptionHandler)(ULONG first, PVECTORED_EXCEPTION_HANDLER func); static ULONG (WINAPI *pRtlRemoveVectoredExceptionHandler)(PVOID handler); static PVOID (WINAPI *pRtlAddVectoredContinueHandler)(ULONG first, PVECTORED_EXCEPTION_HANDLER func); @@ -56,10 +56,72 @@ static BOOL (WINAPI *pIsWow64Process)(HANDLE, PBOOL); static NTSTATUS (WINAPI *pNtClose)(HANDLE); #if defined(__x86_64__) +typedef struct +{ + ULONG Count; + struct + { + ULONG BeginAddress; + ULONG EndAddress; + ULONG HandlerAddress; + ULONG JumpTarget; + } ScopeRecord[1]; +} SCOPE_TABLE; + +typedef struct +{ + ULONG64 ControlPc; + ULONG64 ImageBase; + PRUNTIME_FUNCTION FunctionEntry; + ULONG64 EstablisherFrame; + ULONG64 TargetIp; + PCONTEXT ContextRecord; + void* /*PEXCEPTION_ROUTINE*/ LanguageHandler; + PVOID HandlerData; + PUNWIND_HISTORY_TABLE HistoryTable; + ULONG ScopeIndex; +} DISPATCHER_CONTEXT; + +typedef struct _SETJMP_FLOAT128 +{ + unsigned __int64 DECLSPEC_ALIGN(16) Part[2]; +} SETJMP_FLOAT128; + +typedef struct _JUMP_BUFFER +{ + unsigned __int64 Frame; + unsigned __int64 Rbx; + unsigned __int64 Rsp; + unsigned __int64 Rbp; + unsigned __int64 Rsi; + unsigned __int64 Rdi; + unsigned __int64 R12; + unsigned __int64 R13; + unsigned __int64 R14; + unsigned __int64 R15; + unsigned __int64 Rip; + unsigned __int64 Spare; + SETJMP_FLOAT128 Xmm6; + SETJMP_FLOAT128 Xmm7; + SETJMP_FLOAT128 Xmm8; + SETJMP_FLOAT128 Xmm9; + SETJMP_FLOAT128 Xmm10; + SETJMP_FLOAT128 Xmm11; + SETJMP_FLOAT128 Xmm12; + SETJMP_FLOAT128 Xmm13; + SETJMP_FLOAT128 Xmm14; + SETJMP_FLOAT128 Xmm15; +} _JUMP_BUFFER; + static BOOLEAN (CDECL *pRtlAddFunctionTable)(RUNTIME_FUNCTION*, DWORD, DWORD64); static BOOLEAN (CDECL *pRtlDeleteFunctionTable)(RUNTIME_FUNCTION*); static BOOLEAN (CDECL *pRtlInstallFunctionTableCallback)(DWORD64, DWORD64, DWORD, PGET_RUNTIME_FUNCTION_CALLBACK, PVOID, PCWSTR); static PRUNTIME_FUNCTION (WINAPI *pRtlLookupFunctionEntry)(ULONG64, ULONG64*, UNWIND_HISTORY_TABLE*); +static EXCEPTION_DISPOSITION (WINAPI *p__C_specific_handler)(EXCEPTION_RECORD*, ULONG64, CONTEXT*, DISPATCHER_CONTEXT*); +static VOID (WINAPI *pRtlCaptureContext)(CONTEXT*); +static VOID (CDECL *pRtlRestoreContext)(CONTEXT*, EXCEPTION_RECORD*); +static VOID (CDECL *pRtlUnwindEx)(VOID*, VOID*, EXCEPTION_RECORD*, VOID*, CONTEXT*, UNWIND_HISTORY_TABLE*); +static int (CDECL *p_setjmp)(_JUMP_BUFFER*); #endif #ifdef __i386__ @@ -221,6 +283,11 @@ static const struct exception { { 0xf1, 0x90, 0xc3 }, /* icebp; nop; ret */ 1, 1, FALSE, STATUS_SINGLE_STEP, 0 }, + { { 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, /* mov $0xb8b8b8b8, %eax */ + 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, /* mov $0xb9b9b9b9, %ecx */ + 0xba, 0xba, 0xba, 0xba, 0xba, /* mov $0xbabababa, %edx */ + 0xcd, 0x2d, 0xc3 }, /* int $0x2d; ret */ + 17, 0, FALSE, STATUS_BREAKPOINT, 3, { 0xb8b8b8b8, 0xb9b9b9b9, 0xbabababa } }, }; static int got_exception; @@ -238,16 +305,16 @@ static void run_exception_test(void *handler, const void* context, DWORD oldaccess, oldaccess2; exc_frame.frame.Handler = handler; - exc_frame.frame.Prev = pNtCurrentTeb()->Tib.ExceptionList; + exc_frame.frame.Prev = NtCurrentTeb()->Tib.ExceptionList; exc_frame.context = context; memcpy(code_mem, code, code_size); if(access) VirtualProtect(code_mem, code_size, access, &oldaccess); - pNtCurrentTeb()->Tib.ExceptionList = &exc_frame.frame; + NtCurrentTeb()->Tib.ExceptionList = &exc_frame.frame; func(); - pNtCurrentTeb()->Tib.ExceptionList = exc_frame.frame.Prev; + NtCurrentTeb()->Tib.ExceptionList = exc_frame.frame.Prev; if(access) VirtualProtect(code_mem, code_size, oldaccess, &oldaccess2); @@ -263,7 +330,7 @@ static LONG CALLBACK rtlraiseexception_vectored_handler(EXCEPTION_POINTERS *Exce ok(rec->ExceptionAddress == (char *)code_mem + 0xb, "ExceptionAddress at %p instead of %p\n", rec->ExceptionAddress, (char *)code_mem + 0xb); - if (pNtCurrentTeb()->Peb->BeingDebugged) + if (NtCurrentTeb()->Peb->BeingDebugged) ok((void *)context->Eax == pRtlRaiseException || broken( is_wow64 && context->Eax == 0xf00f00f1 ), /* broken on vista */ "debugger managed to modify Eax to %x should be %p\n", @@ -360,11 +427,11 @@ static void run_rtlraiseexception_test(DWORD exceptioncode) record.NumberParameters = 0; frame.Handler = rtlraiseexception_handler; - frame.Prev = pNtCurrentTeb()->Tib.ExceptionList; + frame.Prev = NtCurrentTeb()->Tib.ExceptionList; memcpy(code_mem, call_one_arg_code, sizeof(call_one_arg_code)); - pNtCurrentTeb()->Tib.ExceptionList = &frame; + NtCurrentTeb()->Tib.ExceptionList = &frame; if (have_vectored_api) { vectored_handler = pRtlAddVectoredExceptionHandler(TRUE, &rtlraiseexception_vectored_handler); @@ -377,7 +444,7 @@ static void run_rtlraiseexception_test(DWORD exceptioncode) if (have_vectored_api) pRtlRemoveVectoredExceptionHandler(vectored_handler); - pNtCurrentTeb()->Tib.ExceptionList = frame.Prev; + NtCurrentTeb()->Tib.ExceptionList = frame.Prev; } static void test_rtlraiseexception(void) @@ -445,37 +512,37 @@ static void test_unwind(void) /* add first unwind handler */ frame1->Handler = unwind_handler; - frame1->Prev = pNtCurrentTeb()->Tib.ExceptionList; - pNtCurrentTeb()->Tib.ExceptionList = frame1; + frame1->Prev = NtCurrentTeb()->Tib.ExceptionList; + NtCurrentTeb()->Tib.ExceptionList = frame1; /* add second unwind handler */ frame2->Handler = unwind_handler; - frame2->Prev = pNtCurrentTeb()->Tib.ExceptionList; - pNtCurrentTeb()->Tib.ExceptionList = frame2; + frame2->Prev = NtCurrentTeb()->Tib.ExceptionList; + NtCurrentTeb()->Tib.ExceptionList = frame2; /* test unwind to current frame */ unwind_expected_eax = 0xDEAD0000; retval = func(pRtlUnwind, frame2, NULL, 0xDEAD0000); ok(retval == 0xDEAD0000, "RtlUnwind returned eax %08x instead of %08x\n", retval, 0xDEAD0000); - ok(pNtCurrentTeb()->Tib.ExceptionList == frame2, "Exception record points to %p instead of %p\n", - pNtCurrentTeb()->Tib.ExceptionList, frame2); + ok(NtCurrentTeb()->Tib.ExceptionList == frame2, "Exception record points to %p instead of %p\n", + NtCurrentTeb()->Tib.ExceptionList, frame2); /* unwind to frame1 */ unwind_expected_eax = 0xDEAD0000; retval = func(pRtlUnwind, frame1, NULL, 0xDEAD0000); ok(retval == 0xDEAD0001, "RtlUnwind returned eax %08x instead of %08x\n", retval, 0xDEAD0001); - ok(pNtCurrentTeb()->Tib.ExceptionList == frame1, "Exception record points to %p instead of %p\n", - pNtCurrentTeb()->Tib.ExceptionList, frame1); + ok(NtCurrentTeb()->Tib.ExceptionList == frame1, "Exception record points to %p instead of %p\n", + NtCurrentTeb()->Tib.ExceptionList, frame1); /* restore original handler */ - pNtCurrentTeb()->Tib.ExceptionList = frame1->Prev; + NtCurrentTeb()->Tib.ExceptionList = frame1->Prev; } static DWORD handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *frame, CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher ) { const struct exception *except = *(const struct exception **)(frame + 1); - unsigned int i, entry = except - exceptions; + unsigned int i, parameter_count, entry = except - exceptions; got_exception++; trace( "exception %u: %x flags:%x addr:%p\n", @@ -484,20 +551,23 @@ static DWORD handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *fram ok( rec->ExceptionCode == except->status || (except->alt_status != 0 && rec->ExceptionCode == except->alt_status), "%u: Wrong exception code %x/%x\n", entry, rec->ExceptionCode, except->status ); - ok( rec->ExceptionAddress == (char*)code_mem + except->offset, - "%u: Wrong exception address %p/%p\n", entry, - rec->ExceptionAddress, (char*)code_mem + except->offset ); - - if (except->alt_status == 0 || rec->ExceptionCode != except->alt_status) - { - ok( rec->NumberParameters == except->nb_params, - "%u: Wrong number of parameters %u/%u\n", entry, rec->NumberParameters, except->nb_params ); - } + ok( context->Eip == (DWORD_PTR)code_mem + except->offset, + "%u: Unexpected eip %#x/%#lx\n", entry, + context->Eip, (DWORD_PTR)code_mem + except->offset ); + ok( rec->ExceptionAddress == (char*)context->Eip || + (rec->ExceptionCode == STATUS_BREAKPOINT && rec->ExceptionAddress == (char*)context->Eip + 1), + "%u: Unexpected exception address %p/%p\n", entry, + rec->ExceptionAddress, (char*)context->Eip ); + + if (except->status == STATUS_BREAKPOINT && is_wow64) + parameter_count = 1; + else if (except->alt_status == 0 || rec->ExceptionCode != except->alt_status) + parameter_count = except->nb_params; else - { - ok( rec->NumberParameters == except->alt_nb_params, - "%u: Wrong number of parameters %u/%u\n", entry, rec->NumberParameters, except->nb_params ); - } + parameter_count = except->alt_nb_params; + + ok( rec->NumberParameters == parameter_count, + "%u: Unexpected parameter count %u/%u\n", entry, rec->NumberParameters, parameter_count ); /* Most CPUs (except Intel Core apparently) report a segment limit violation */ /* instead of page faults for accesses beyond 0xffffffff */ @@ -532,7 +602,7 @@ static DWORD handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *fram skip_params: /* don't handle exception if it's not the address we expected */ - if (rec->ExceptionAddress != (char*)code_mem + except->offset) return ExceptionContinueSearch; + if (context->Eip != (DWORD_PTR)code_mem + except->offset) return ExceptionContinueSearch; context->Eip += except->length; return ExceptionContinueExecution; @@ -754,12 +824,21 @@ static DWORD int3_handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD static const BYTE int3_code[] = { 0xCC, 0xc3 }; /* int 3, ret */ +static DWORD WINAPI hw_reg_exception_thread( void *arg ) +{ + int expect = (ULONG_PTR)arg; + got_exception = 0; + run_exception_test( bpx_handler, NULL, dummy_code, sizeof(dummy_code), 0 ); + ok( got_exception == expect, "expected %u exceptions, got %d\n", expect, got_exception ); + return 0; +} static void test_exceptions(void) { CONTEXT ctx; NTSTATUS res; struct dbgreg_test dreg_test; + HANDLE h; if (!pNtGetContextThread || !pNtSetContextThread) { @@ -813,6 +892,33 @@ static void test_exceptions(void) /* test int3 handling */ run_exception_test(int3_handler, NULL, int3_code, sizeof(int3_code), 0); + + /* test that hardware breakpoints are not inherited by created threads */ + res = pNtSetContextThread( GetCurrentThread(), &ctx ); + ok( res == STATUS_SUCCESS, "NtSetContextThread failed with %x\n", res ); + + h = CreateThread( NULL, 0, hw_reg_exception_thread, 0, 0, NULL ); + WaitForSingleObject( h, 10000 ); + CloseHandle( h ); + + h = CreateThread( NULL, 0, hw_reg_exception_thread, (void *)4, CREATE_SUSPENDED, NULL ); + ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS; + res = pNtGetContextThread( h, &ctx ); + ok( res == STATUS_SUCCESS, "NtGetContextThread failed with %x\n", res ); + ok( ctx.Dr0 == 0, "dr0 %x\n", ctx.Dr0 ); + ok( ctx.Dr7 == 0, "dr7 %x\n", ctx.Dr7 ); + ctx.Dr0 = (DWORD)code_mem; + ctx.Dr7 = 3; + res = pNtSetContextThread( h, &ctx ); + ok( res == STATUS_SUCCESS, "NtSetContextThread failed with %x\n", res ); + ResumeThread( h ); + WaitForSingleObject( h, 10000 ); + CloseHandle( h ); + + ctx.Dr0 = 0; + ctx.Dr7 = 0; + res = pNtSetContextThread( GetCurrentThread(), &ctx ); + ok( res == STATUS_SUCCESS, "NtSetContextThread failed with %x\n", res ); } static void test_debugger(void) @@ -855,7 +961,7 @@ static void test_debugger(void) if (de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT) { - if(de.u.CreateProcessInfo.lpBaseOfImage != pNtCurrentTeb()->Peb->ImageBaseAddress) + if(de.u.CreateProcessInfo.lpBaseOfImage != NtCurrentTeb()->Peb->ImageBaseAddress) { skip("child process loaded at different address, terminating it\n"); pNtTerminateProcess(pi.hProcess, 0); @@ -940,6 +1046,24 @@ static void test_debugger(void) } } else if (stage == 7 || stage == 8) + { + ok(de.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT, + "expected EXCEPTION_BREAKPOINT, got %08x\n", de.u.Exception.ExceptionRecord.ExceptionCode); + ok((char *)ctx.Eip == (char *)code_mem_address + 0x1d, + "expected Eip = %p, got 0x%x\n", (char *)code_mem_address + 0x1d, ctx.Eip); + + if (stage == 8) continuestatus = DBG_EXCEPTION_NOT_HANDLED; + } + else if (stage == 9 || stage == 10) + { + ok(de.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT, + "expected EXCEPTION_BREAKPOINT, got %08x\n", de.u.Exception.ExceptionRecord.ExceptionCode); + ok((char *)ctx.Eip == (char *)code_mem_address + 2, + "expected Eip = %p, got 0x%x\n", (char *)code_mem_address + 2, ctx.Eip); + + if (stage == 10) continuestatus = DBG_EXCEPTION_NOT_HANDLED; + } + else if (stage == 11 || stage == 12) { ok(de.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_INVALID_HANDLE, "unexpected exception code %08x, expected %08x\n", de.u.Exception.ExceptionRecord.ExceptionCode, @@ -947,7 +1071,7 @@ static void test_debugger(void) ok(de.u.Exception.ExceptionRecord.NumberParameters == 0, "unexpected number of parameters %d, expected 0\n", de.u.Exception.ExceptionRecord.NumberParameters); - if (stage == 8) continuestatus = DBG_EXCEPTION_NOT_HANDLED; + if (stage == 12) continuestatus = DBG_EXCEPTION_NOT_HANDLED; } else ok(FALSE, "unexpected stage %x\n", stage); @@ -1035,22 +1159,25 @@ static DWORD simd_fault_handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_R context->Eip += 3; /* skip addps */ return ExceptionContinueExecution; } - - /* stage 2 - divide by zero fault */ - if( rec->ExceptionCode == EXCEPTION_ILLEGAL_INSTRUCTION) - skip("system doesn't support SIMD exceptions\n"); - else { - ok( rec->ExceptionCode == STATUS_FLOAT_MULTIPLE_TRAPS, - "exception code: %#x, should be %#x\n", - rec->ExceptionCode, STATUS_FLOAT_MULTIPLE_TRAPS); - ok( rec->NumberParameters == 1 || broken(is_wow64 && rec->NumberParameters == 2), - "# of params: %i, should be 1\n", - rec->NumberParameters); - if( rec->NumberParameters == 1 ) - ok( rec->ExceptionInformation[0] == 0, "param #1: %lx, should be 0\n", rec->ExceptionInformation[0]); + else if ( *stage == 2 || *stage == 3 ) { + /* stage 2 - divide by zero fault */ + /* stage 3 - invalid operation fault */ + if( rec->ExceptionCode == EXCEPTION_ILLEGAL_INSTRUCTION) + skip("system doesn't support SIMD exceptions\n"); + else { + ok( rec->ExceptionCode == STATUS_FLOAT_MULTIPLE_TRAPS, + "exception code: %#x, should be %#x\n", + rec->ExceptionCode, STATUS_FLOAT_MULTIPLE_TRAPS); + ok( rec->NumberParameters == 1 || broken(is_wow64 && rec->NumberParameters == 2), + "# of params: %i, should be 1\n", + rec->NumberParameters); + if( rec->NumberParameters == 1 ) + ok( rec->ExceptionInformation[0] == 0, "param #1: %lx, should be 0\n", rec->ExceptionInformation[0]); + } + context->Eip += 3; /* skip divps */ } - - context->Eip += 3; /* skip divps */ + else + ok(FALSE, "unexpected stage %x\n", *stage); return ExceptionContinueExecution; } @@ -1058,6 +1185,7 @@ static DWORD simd_fault_handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_R static const BYTE simd_exception_test[] = { 0x83, 0xec, 0x4, /* sub $0x4, %esp */ 0x0f, 0xae, 0x1c, 0x24, /* stmxcsr (%esp) */ + 0x8b, 0x04, 0x24, /* mov (%esp),%eax * store mxcsr */ 0x66, 0x81, 0x24, 0x24, 0xff, 0xfd, /* andw $0xfdff,(%esp) * enable divide by */ 0x0f, 0xae, 0x14, 0x24, /* ldmxcsr (%esp) * zero exceptions */ 0x6a, 0x01, /* push $0x1 */ @@ -1068,7 +1196,22 @@ static const BYTE simd_exception_test[] = { 0x0f, 0x57, 0xc0, /* xorps %xmm0,%xmm0 * clear divisor */ 0x0f, 0x5e, 0xc8, /* divps %xmm0,%xmm1 * generate fault */ 0x83, 0xc4, 0x10, /* add $0x10,%esp */ - 0x66, 0x81, 0x0c, 0x24, 0x00, 0x02, /* orw $0x200,(%esp) * disable exceptions */ + 0x89, 0x04, 0x24, /* mov %eax,(%esp) * restore to old mxcsr */ + 0x0f, 0xae, 0x14, 0x24, /* ldmxcsr (%esp) */ + 0x83, 0xc4, 0x04, /* add $0x4,%esp */ + 0xc3, /* ret */ +}; + +static const BYTE simd_exception_test2[] = { + 0x83, 0xec, 0x4, /* sub $0x4, %esp */ + 0x0f, 0xae, 0x1c, 0x24, /* stmxcsr (%esp) */ + 0x8b, 0x04, 0x24, /* mov (%esp),%eax * store mxcsr */ + 0x66, 0x81, 0x24, 0x24, 0x7f, 0xff, /* andw $0xff7f,(%esp) * enable invalid */ + 0x0f, 0xae, 0x14, 0x24, /* ldmxcsr (%esp) * operation exceptions */ + 0x0f, 0x57, 0xc9, /* xorps %xmm1,%xmm1 * clear dividend */ + 0x0f, 0x57, 0xc0, /* xorps %xmm0,%xmm0 * clear divisor */ + 0x0f, 0x5e, 0xc8, /* divps %xmm0,%xmm1 * generate fault */ + 0x89, 0x04, 0x24, /* mov %eax,(%esp) * restore to old mxcsr */ 0x0f, 0xae, 0x14, 0x24, /* ldmxcsr (%esp) */ 0x83, 0xc4, 0x04, /* add $0x4,%esp */ 0xc3, /* ret */ @@ -1097,7 +1240,14 @@ static void test_simd_exceptions(void) got_exception = 0; run_exception_test(simd_fault_handler, &stage, simd_exception_test, sizeof(simd_exception_test), 0); - ok( got_exception == 1, "got exception: %i, should be 1\n", got_exception); + ok(got_exception == 1, "got exception: %i, should be 1\n", got_exception); + + /* generate a SIMD exception, test FPE_FLTINV */ + stage = 3; + got_exception = 0; + run_exception_test(simd_fault_handler, &stage, simd_exception_test2, + sizeof(simd_exception_test2), 0); + ok(got_exception == 1, "got exception: %i, should be 1\n", got_exception); } struct fpu_exception_info @@ -1166,7 +1316,7 @@ static void test_fpu_exceptions(void) ok(info.exception_code == EXCEPTION_FLT_STACK_CHECK, "Got exception code %#x, expected EXCEPTION_FLT_STACK_CHECK\n", info.exception_code); ok(info.exception_offset == 0x19 || - broken( is_wow64 && info.exception_offset == info.eip_offset ), + broken( info.exception_offset == info.eip_offset ), "Got exception offset %#x, expected 0x19\n", info.exception_offset); ok(info.eip_offset == 0x1b, "Got EIP offset %#x, expected 0x1b\n", info.eip_offset); @@ -1175,7 +1325,7 @@ static void test_fpu_exceptions(void) ok(info.exception_code == EXCEPTION_FLT_DIVIDE_BY_ZERO, "Got exception code %#x, expected EXCEPTION_FLT_DIVIDE_BY_ZERO\n", info.exception_code); ok(info.exception_offset == 0x17 || - broken( is_wow64 && info.exception_offset == info.eip_offset ), + broken( info.exception_offset == info.eip_offset ), "Got exception offset %#x, expected 0x17\n", info.exception_offset); ok(info.eip_offset == 0x19, "Got EIP offset %#x, expected 0x19\n", info.eip_offset); } @@ -1323,8 +1473,138 @@ static void test_dpe_exceptions(void) ok(stat == STATUS_ACCESS_DENIED, "enabling DEP while permanent: status %08x\n", stat); } +static void test_thread_context(void) +{ + CONTEXT context; + NTSTATUS status; + struct expected + { + DWORD Eax, Ebx, Ecx, Edx, Esi, Edi, Ebp, Esp, Eip, + SegCs, SegDs, SegEs, SegFs, SegGs, SegSs, EFlags, prev_frame; + } expect; + NTSTATUS (*func_ptr)( struct expected *res, void *func, void *arg1, void *arg2 ) = (void *)code_mem; + + static const BYTE call_func[] = + { + 0x55, /* pushl %ebp */ + 0x89, 0xe5, /* mov %esp,%ebp */ + 0x50, /* pushl %eax ; add a bit of offset to the stack */ + 0x50, /* pushl %eax */ + 0x50, /* pushl %eax */ + 0x50, /* pushl %eax */ + 0x8b, 0x45, 0x08, /* mov 0x8(%ebp),%eax */ + 0x8f, 0x00, /* popl (%eax) */ + 0x89, 0x58, 0x04, /* mov %ebx,0x4(%eax) */ + 0x89, 0x48, 0x08, /* mov %ecx,0x8(%eax) */ + 0x89, 0x50, 0x0c, /* mov %edx,0xc(%eax) */ + 0x89, 0x70, 0x10, /* mov %esi,0x10(%eax) */ + 0x89, 0x78, 0x14, /* mov %edi,0x14(%eax) */ + 0x89, 0x68, 0x18, /* mov %ebp,0x18(%eax) */ + 0x89, 0x60, 0x1c, /* mov %esp,0x1c(%eax) */ + 0xff, 0x75, 0x04, /* pushl 0x4(%ebp) */ + 0x8f, 0x40, 0x20, /* popl 0x20(%eax) */ + 0x8c, 0x48, 0x24, /* mov %cs,0x24(%eax) */ + 0x8c, 0x58, 0x28, /* mov %ds,0x28(%eax) */ + 0x8c, 0x40, 0x2c, /* mov %es,0x2c(%eax) */ + 0x8c, 0x60, 0x30, /* mov %fs,0x30(%eax) */ + 0x8c, 0x68, 0x34, /* mov %gs,0x34(%eax) */ + 0x8c, 0x50, 0x38, /* mov %ss,0x38(%eax) */ + 0x9c, /* pushf */ + 0x8f, 0x40, 0x3c, /* popl 0x3c(%eax) */ + 0xff, 0x75, 0x00, /* pushl 0x0(%ebp) ; previous stack frame */ + 0x8f, 0x40, 0x40, /* popl 0x40(%eax) */ + 0x8b, 0x00, /* mov (%eax),%eax */ + 0xff, 0x75, 0x14, /* pushl 0x14(%ebp) */ + 0xff, 0x75, 0x10, /* pushl 0x10(%ebp) */ + 0xff, 0x55, 0x0c, /* call *0xc(%ebp) */ + 0xc9, /* leave */ + 0xc3, /* ret */ + }; + + memcpy( func_ptr, call_func, sizeof(call_func) ); + +#define COMPARE(reg) \ + ok( context.reg == expect.reg, "wrong " #reg " %08x/%08x\n", context.reg, expect.reg ) + + memset( &context, 0xcc, sizeof(context) ); + memset( &expect, 0xcc, sizeof(expect) ); + func_ptr( &expect, pRtlCaptureContext, &context, 0 ); + trace( "expect: eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x ebp=%08x esp=%08x " + "eip=%08x cs=%04x ds=%04x es=%04x fs=%04x gs=%04x ss=%04x flags=%08x prev=%08x\n", + expect.Eax, expect.Ebx, expect.Ecx, expect.Edx, expect.Esi, expect.Edi, + expect.Ebp, expect.Esp, expect.Eip, expect.SegCs, expect.SegDs, expect.SegEs, + expect.SegFs, expect.SegGs, expect.SegSs, expect.EFlags, expect.prev_frame ); + trace( "actual: eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x ebp=%08x esp=%08x " + "eip=%08x cs=%04x ds=%04x es=%04x fs=%04x gs=%04x ss=%04x flags=%08x\n", + context.Eax, context.Ebx, context.Ecx, context.Edx, context.Esi, context.Edi, + context.Ebp, context.Esp, context.Eip, context.SegCs, context.SegDs, context.SegEs, + context.SegFs, context.SegGs, context.SegSs, context.EFlags ); + + ok( context.ContextFlags == (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS) || + broken( context.ContextFlags == 0xcccccccc ), /* <= vista */ + "wrong flags %08x\n", context.ContextFlags ); + COMPARE( Eax ); + COMPARE( Ebx ); + COMPARE( Ecx ); + COMPARE( Edx ); + COMPARE( Esi ); + COMPARE( Edi ); + COMPARE( Eip ); + COMPARE( SegCs ); + COMPARE( SegDs ); + COMPARE( SegEs ); + COMPARE( SegFs ); + COMPARE( SegGs ); + COMPARE( SegSs ); + COMPARE( EFlags ); + /* Ebp is from the previous stackframe */ + ok( context.Ebp == expect.prev_frame, "wrong Ebp %08x/%08x\n", context.Ebp, expect.prev_frame ); + /* Esp is the value on entry to the previous stackframe */ + ok( context.Esp == expect.Ebp + 8, "wrong Esp %08x/%08x\n", context.Esp, expect.Ebp + 8 ); + + memset( &context, 0xcc, sizeof(context) ); + memset( &expect, 0xcc, sizeof(expect) ); + context.ContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS; + status = func_ptr( &expect, pNtGetContextThread, (void *)GetCurrentThread(), &context ); + ok( status == STATUS_SUCCESS, "NtGetContextThread failed %08x\n", status ); + trace( "expect: eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x ebp=%08x esp=%08x " + "eip=%08x cs=%04x ds=%04x es=%04x fs=%04x gs=%04x ss=%04x flags=%08x prev=%08x\n", + expect.Eax, expect.Ebx, expect.Ecx, expect.Edx, expect.Esi, expect.Edi, + expect.Ebp, expect.Esp, expect.Eip, expect.SegCs, expect.SegDs, expect.SegEs, + expect.SegFs, expect.SegGs, expect.SegSs, expect.EFlags, expect.prev_frame ); + trace( "actual: eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x ebp=%08x esp=%08x " + "eip=%08x cs=%04x ds=%04x es=%04x fs=%04x gs=%04x ss=%04x flags=%08x\n", + context.Eax, context.Ebx, context.Ecx, context.Edx, context.Esi, context.Edi, + context.Ebp, context.Esp, context.Eip, context.SegCs, context.SegDs, context.SegEs, + context.SegFs, context.SegGs, context.SegSs, context.EFlags ); + /* Eax, Ecx, Edx, EFlags are not preserved */ + COMPARE( Ebx ); + COMPARE( Esi ); + COMPARE( Edi ); + COMPARE( Ebp ); + /* Esp is the stack upon entry to NtGetContextThread */ + ok( context.Esp == expect.Esp - 12 || context.Esp == expect.Esp - 16, + "wrong Esp %08x/%08x\n", context.Esp, expect.Esp ); + /* Eip is somewhere close to the NtGetContextThread implementation */ + ok( (char *)context.Eip >= (char *)pNtGetContextThread - 0x10000 && + (char *)context.Eip <= (char *)pNtGetContextThread + 0x10000, + "wrong Eip %08x/%08x\n", context.Eip, (DWORD)pNtGetContextThread ); + ok( *(WORD *)context.Eip == 0xc483 || *(WORD *)context.Eip == 0x08c2 || *(WORD *)context.Eip == 0x8dc3, + "expected 0xc483 or 0x08c2 or 0x8dc3, got %04x\n", *(WORD *)context.Eip ); + /* segment registers clear the high word */ + ok( context.SegCs == LOWORD(expect.SegCs), "wrong SegCs %08x/%08x\n", context.SegCs, expect.SegCs ); + ok( context.SegDs == LOWORD(expect.SegDs), "wrong SegDs %08x/%08x\n", context.SegDs, expect.SegDs ); + ok( context.SegEs == LOWORD(expect.SegEs), "wrong SegEs %08x/%08x\n", context.SegEs, expect.SegEs ); + ok( context.SegFs == LOWORD(expect.SegFs), "wrong SegFs %08x/%08x\n", context.SegFs, expect.SegFs ); + ok( context.SegGs == LOWORD(expect.SegGs), "wrong SegGs %08x/%08x\n", context.SegGs, expect.SegGs ); + ok( context.SegSs == LOWORD(expect.SegSs), "wrong SegSs %08x/%08x\n", context.SegSs, expect.SegGs ); +#undef COMPARE +} + #elif defined(__x86_64__) +#define is_wow64 0 + #define UNW_FLAG_NHANDLER 0 #define UNW_FLAG_EHANDLER 1 #define UNW_FLAG_UHANDLER 2 @@ -1598,6 +1878,131 @@ static void test_virtual_unwind(void) call_virtual_unwind( i, &tests[i] ); } +static int consolidate_dummy_called; +static PVOID CALLBACK test_consolidate_dummy(EXCEPTION_RECORD *rec) +{ + CONTEXT *ctx = (CONTEXT *)rec->ExceptionInformation[1]; + consolidate_dummy_called = 1; + ok(ctx->Rip == 0xdeadbeef, "test_consolidate_dummy failed for Rip, expected: 0xdeadbeef, got: %lx\n", ctx->Rip); + return (PVOID)rec->ExceptionInformation[2]; +} + +static void test_restore_context(void) +{ + SETJMP_FLOAT128 *fltsave; + EXCEPTION_RECORD rec; + _JUMP_BUFFER buf; + CONTEXT ctx; + int i, pass; + + if (!pRtlUnwindEx || !pRtlRestoreContext || !pRtlCaptureContext || !p_setjmp) + { + skip("RtlUnwindEx/RtlCaptureContext/RtlRestoreContext/_setjmp not found\n"); + return; + } + + /* RtlRestoreContext(NULL, NULL); crashes on Windows */ + + /* test simple case of capture and restore context */ + pass = 0; + InterlockedIncrement(&pass); /* interlocked to prevent compiler from moving after capture */ + pRtlCaptureContext(&ctx); + if (InterlockedIncrement(&pass) == 2) /* interlocked to prevent compiler from moving before capture */ + { + pRtlRestoreContext(&ctx, NULL); + ok(0, "shouldn't be reached\n"); + } + else + ok(pass < 4, "unexpected pass %d\n", pass); + + /* test with jmp using RltRestoreContext */ + pass = 0; + InterlockedIncrement(&pass); + RtlCaptureContext(&ctx); + InterlockedIncrement(&pass); /* only called once */ + p_setjmp(&buf); + InterlockedIncrement(&pass); + if (pass == 3) + { + rec.ExceptionCode = STATUS_LONGJUMP; + rec.NumberParameters = 1; + rec.ExceptionInformation[0] = (DWORD64)&buf; + + /* uses buf.Rip instead of ctx.Rip */ + pRtlRestoreContext(&ctx, &rec); + ok(0, "shouldn't be reached\n"); + } + else if (pass == 4) + { + ok(buf.Rbx == ctx.Rbx, "longjmp failed for Rbx, expected: %lx, got: %lx\n", buf.Rbx, ctx.Rbx); + ok(buf.Rsp == ctx.Rsp, "longjmp failed for Rsp, expected: %lx, got: %lx\n", buf.Rsp, ctx.Rsp); + ok(buf.Rbp == ctx.Rbp, "longjmp failed for Rbp, expected: %lx, got: %lx\n", buf.Rbp, ctx.Rbp); + ok(buf.Rsi == ctx.Rsi, "longjmp failed for Rsi, expected: %lx, got: %lx\n", buf.Rsi, ctx.Rsi); + ok(buf.Rdi == ctx.Rdi, "longjmp failed for Rdi, expected: %lx, got: %lx\n", buf.Rdi, ctx.Rdi); + ok(buf.R12 == ctx.R12, "longjmp failed for R12, expected: %lx, got: %lx\n", buf.R12, ctx.R12); + ok(buf.R13 == ctx.R13, "longjmp failed for R13, expected: %lx, got: %lx\n", buf.R13, ctx.R13); + ok(buf.R14 == ctx.R14, "longjmp failed for R14, expected: %lx, got: %lx\n", buf.R14, ctx.R14); + ok(buf.R15 == ctx.R15, "longjmp failed for R15, expected: %lx, got: %lx\n", buf.R15, ctx.R15); + + fltsave = &buf.Xmm6; + for (i = 0; i < 10; i++) + { + ok(fltsave[i].Part[0] == ctx.u.FltSave.XmmRegisters[i + 6].Low, + "longjmp failed for Xmm%d, expected %lx, got %lx\n", i + 6, + fltsave[i].Part[0], ctx.u.FltSave.XmmRegisters[i + 6].Low); + + ok(fltsave[i].Part[1] == ctx.u.FltSave.XmmRegisters[i + 6].High, + "longjmp failed for Xmm%d, expected %lx, got %lx\n", i + 6, + fltsave[i].Part[1], ctx.u.FltSave.XmmRegisters[i + 6].High); + } + } + else + ok(0, "unexpected pass %d\n", pass); + + /* test with jmp through RtlUnwindEx */ + pass = 0; + InterlockedIncrement(&pass); + pRtlCaptureContext(&ctx); + InterlockedIncrement(&pass); /* only called once */ + p_setjmp(&buf); + InterlockedIncrement(&pass); + if (pass == 3) + { + rec.ExceptionCode = STATUS_LONGJUMP; + rec.NumberParameters = 1; + rec.ExceptionInformation[0] = (DWORD64)&buf; + + /* uses buf.Rip instead of bogus 0xdeadbeef */ + pRtlUnwindEx((void*)buf.Rsp, (void*)0xdeadbeef, &rec, NULL, &ctx, NULL); + ok(0, "shouldn't be reached\n"); + } + else + ok(pass == 4, "unexpected pass %d\n", pass); + + + /* test with consolidate */ + pass = 0; + InterlockedIncrement(&pass); + RtlCaptureContext(&ctx); + InterlockedIncrement(&pass); + if (pass == 2) + { + rec.ExceptionCode = STATUS_UNWIND_CONSOLIDATE; + rec.NumberParameters = 3; + rec.ExceptionInformation[0] = (DWORD64)test_consolidate_dummy; + rec.ExceptionInformation[1] = (DWORD64)&ctx; + rec.ExceptionInformation[2] = ctx.Rip; + ctx.Rip = 0xdeadbeef; + + pRtlRestoreContext(&ctx, &rec); + ok(0, "shouldn't be reached\n"); + } + else if (pass == 3) + ok(consolidate_dummy_called, "test_consolidate_dummy not called\n"); + else + ok(0, "unexpected pass %d\n", pass); +} + static RUNTIME_FUNCTION* CALLBACK dynamic_unwind_callback( DWORD64 pc, PVOID context ) { static const int code_offset = 1024; @@ -1714,9 +2119,155 @@ static void test_dynamic_unwind(void) } +static int termination_handler_called; +static void WINAPI termination_handler(ULONG flags, ULONG64 frame) +{ + termination_handler_called++; + + ok(flags == 1 || broken(flags == 0x401), "flags = %x\n", flags); + ok(frame == 0x1234, "frame = %p\n", (void*)frame); +} + +static void test___C_specific_handler(void) +{ + DISPATCHER_CONTEXT dispatch; + EXCEPTION_RECORD rec; + CONTEXT context; + ULONG64 frame; + EXCEPTION_DISPOSITION ret; + SCOPE_TABLE scope_table; + + if (!p__C_specific_handler) + { + win_skip("__C_specific_handler not available\n"); + return; + } + + memset(&rec, 0, sizeof(rec)); + rec.ExceptionFlags = 2; /* EH_UNWINDING */ + frame = 0x1234; + memset(&dispatch, 0, sizeof(dispatch)); + dispatch.ImageBase = (ULONG_PTR)GetModuleHandleA(NULL); + dispatch.ControlPc = dispatch.ImageBase + 0x200; + dispatch.HandlerData = &scope_table; + dispatch.ContextRecord = &context; + scope_table.Count = 1; + scope_table.ScopeRecord[0].BeginAddress = 0x200; + scope_table.ScopeRecord[0].EndAddress = 0x400; + scope_table.ScopeRecord[0].HandlerAddress = (ULONG_PTR)termination_handler-dispatch.ImageBase; + scope_table.ScopeRecord[0].JumpTarget = 0; + memset(&context, 0, sizeof(context)); + + termination_handler_called = 0; + ret = p__C_specific_handler(&rec, frame, &context, &dispatch); + ok(ret == ExceptionContinueSearch, "__C_specific_handler returned %x\n", ret); + ok(termination_handler_called == 1, "termination_handler_called = %d\n", + termination_handler_called); + ok(dispatch.ScopeIndex == 1, "dispatch.ScopeIndex = %d\n", dispatch.ScopeIndex); + + ret = p__C_specific_handler(&rec, frame, &context, &dispatch); + ok(ret == ExceptionContinueSearch, "__C_specific_handler returned %x\n", ret); + ok(termination_handler_called == 1, "termination_handler_called = %d\n", + termination_handler_called); + ok(dispatch.ScopeIndex == 1, "dispatch.ScopeIndex = %d\n", dispatch.ScopeIndex); +} + #endif /* __x86_64__ */ #if defined(__i386__) || defined(__x86_64__) + +static DWORD WINAPI register_check_thread(void *arg) +{ + NTSTATUS status; + CONTEXT ctx; + + memset(&ctx, 0, sizeof(ctx)); + ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS; + + status = pNtGetContextThread(GetCurrentThread(), &ctx); + ok(status == STATUS_SUCCESS, "NtGetContextThread failed with %x\n", status); + ok(!ctx.Dr0, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr0); + ok(!ctx.Dr1, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr1); + ok(!ctx.Dr2, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr2); + ok(!ctx.Dr3, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr3); + ok(!ctx.Dr6, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr6); + ok(!ctx.Dr7, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr7); + + return 0; +} + +static void test_debug_registers(void) +{ + static const struct + { + ULONG_PTR dr0, dr1, dr2, dr3, dr6, dr7; + } + tests[] = + { + { 0x42424240, 0, 0x126bb070, 0x0badbad0, 0, 0xffff0115 }, + { 0x42424242, 0, 0x100f0fe7, 0x0abebabe, 0, 0x115 }, + }; + NTSTATUS status; + CONTEXT ctx; + HANDLE thread; + int i; + + for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) + { + memset(&ctx, 0, sizeof(ctx)); + ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS; + ctx.Dr0 = tests[i].dr0; + ctx.Dr1 = tests[i].dr1; + ctx.Dr2 = tests[i].dr2; + ctx.Dr3 = tests[i].dr3; + ctx.Dr6 = tests[i].dr6; + ctx.Dr7 = tests[i].dr7; + + status = pNtSetContextThread(GetCurrentThread(), &ctx); + ok(status == STATUS_SUCCESS, "NtGetContextThread failed with %08x\n", status); + + memset(&ctx, 0, sizeof(ctx)); + ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS; + + status = pNtGetContextThread(GetCurrentThread(), &ctx); + ok(status == STATUS_SUCCESS, "NtGetContextThread failed with %08x\n", status); + ok(ctx.Dr0 == tests[i].dr0, "test %d: expected %lx, got %lx\n", i, tests[i].dr0, (DWORD_PTR)ctx.Dr0); + ok(ctx.Dr1 == tests[i].dr1, "test %d: expected %lx, got %lx\n", i, tests[i].dr1, (DWORD_PTR)ctx.Dr1); + ok(ctx.Dr2 == tests[i].dr2, "test %d: expected %lx, got %lx\n", i, tests[i].dr2, (DWORD_PTR)ctx.Dr2); + ok(ctx.Dr3 == tests[i].dr3, "test %d: expected %lx, got %lx\n", i, tests[i].dr3, (DWORD_PTR)ctx.Dr3); + ok((ctx.Dr6 & 0xf00f) == tests[i].dr6, "test %d: expected %lx, got %lx\n", i, tests[i].dr6, (DWORD_PTR)ctx.Dr6); + ok((ctx.Dr7 & ~0xdc00) == tests[i].dr7, "test %d: expected %lx, got %lx\n", i, tests[i].dr7, (DWORD_PTR)ctx.Dr7); + } + + memset(&ctx, 0, sizeof(ctx)); + ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS; + ctx.Dr0 = 0xffffffff; + ctx.Dr1 = 0xffffffff; + ctx.Dr2 = 0xffffffff; + ctx.Dr3 = 0xffffffff; + ctx.Dr6 = 0xffffffff; + ctx.Dr7 = 0x00000400; + status = pNtSetContextThread(GetCurrentThread(), &ctx); + ok(status == STATUS_SUCCESS, "NtSetContextThread failed with %x\n", status); + + thread = CreateThread(NULL, 0, register_check_thread, NULL, CREATE_SUSPENDED, NULL); + ok(thread != INVALID_HANDLE_VALUE, "CreateThread failed with %d\n", GetLastError()); + + ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS; + status = pNtGetContextThread(thread, &ctx); + ok(status == STATUS_SUCCESS, "NtGetContextThread failed with %x\n", status); + ok(!ctx.Dr0, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr0); + ok(!ctx.Dr1, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr1); + ok(!ctx.Dr2, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr2); + ok(!ctx.Dr3, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr3); + ok(!ctx.Dr6, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr6); + ok(!ctx.Dr7, "expected 0, got %lx\n", (DWORD_PTR)ctx.Dr7); + + ResumeThread(thread); + WaitForSingleObject(thread, 10000); + CloseHandle(thread); +} + static DWORD outputdebugstring_exceptions; static LONG CALLBACK outputdebugstring_vectored_handler(EXCEPTION_POINTERS *ExceptionInfo) @@ -1750,6 +2301,7 @@ static void test_outputdebugstring(DWORD numexc) outputdebugstring_exceptions = 0; OutputDebugStringA("Hello World"); + ok(outputdebugstring_exceptions == numexc, "OutputDebugStringA generated %d exceptions, expected %d\n", outputdebugstring_exceptions, numexc); @@ -1805,6 +2357,236 @@ static void test_ripevent(DWORD numexc) pRtlRemoveVectoredExceptionHandler(vectored_handler); } +static DWORD debug_service_exceptions; + +static LONG CALLBACK debug_service_handler(EXCEPTION_POINTERS *ExceptionInfo) +{ + EXCEPTION_RECORD *rec = ExceptionInfo->ExceptionRecord; + trace("vect. handler %08x addr:%p\n", rec->ExceptionCode, rec->ExceptionAddress); + + ok(rec->ExceptionCode == EXCEPTION_BREAKPOINT, "ExceptionCode is %08x instead of %08x\n", + rec->ExceptionCode, EXCEPTION_BREAKPOINT); + +#ifdef __i386__ + ok(ExceptionInfo->ContextRecord->Eip == (DWORD)code_mem + 0x1c, + "expected Eip = %x, got %x\n", (DWORD)code_mem + 0x1c, ExceptionInfo->ContextRecord->Eip); + ok(rec->NumberParameters == (is_wow64 ? 1 : 3), + "ExceptionParameters is %d instead of %d\n", rec->NumberParameters, is_wow64 ? 1 : 3); + ok(rec->ExceptionInformation[0] == ExceptionInfo->ContextRecord->Eax, + "expected ExceptionInformation[0] = %x, got %lx\n", + ExceptionInfo->ContextRecord->Eax, rec->ExceptionInformation[0]); + if (!is_wow64) + { + ok(rec->ExceptionInformation[1] == 0x11111111, + "got ExceptionInformation[1] = %lx\n", rec->ExceptionInformation[1]); + ok(rec->ExceptionInformation[2] == 0x22222222, + "got ExceptionInformation[2] = %lx\n", rec->ExceptionInformation[2]); + } +#else + ok(ExceptionInfo->ContextRecord->Rip == (DWORD_PTR)code_mem + 0x2f, + "expected Rip = %lx, got %lx\n", (DWORD_PTR)code_mem + 0x2f, ExceptionInfo->ContextRecord->Rip); + ok(rec->NumberParameters == 1, + "ExceptionParameters is %d instead of 1\n", rec->NumberParameters); + ok(rec->ExceptionInformation[0] == ExceptionInfo->ContextRecord->Rax, + "expected ExceptionInformation[0] = %lx, got %lx\n", + ExceptionInfo->ContextRecord->Rax, rec->ExceptionInformation[0]); +#endif + + debug_service_exceptions++; + return (rec->ExceptionCode == EXCEPTION_BREAKPOINT) ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_CONTINUE_SEARCH; +} + +#ifdef __i386__ + +static const BYTE call_debug_service_code[] = { + 0x53, /* pushl %ebx */ + 0x57, /* pushl %edi */ + 0x8b, 0x44, 0x24, 0x0c, /* movl 12(%esp),%eax */ + 0xb9, 0x11, 0x11, 0x11, 0x11, /* movl $0x11111111,%ecx */ + 0xba, 0x22, 0x22, 0x22, 0x22, /* movl $0x22222222,%edx */ + 0xbb, 0x33, 0x33, 0x33, 0x33, /* movl $0x33333333,%ebx */ + 0xbf, 0x44, 0x44, 0x44, 0x44, /* movl $0x44444444,%edi */ + 0xcd, 0x2d, /* int $0x2d */ + 0xeb, /* jmp $+17 */ + 0x0f, 0x1f, 0x00, /* nop */ + 0x31, 0xc0, /* xorl %eax,%eax */ + 0xeb, 0x0c, /* jmp $+14 */ + 0x90, 0x90, 0x90, 0x90, /* nop */ + 0x90, 0x90, 0x90, 0x90, + 0x90, + 0x31, 0xc0, /* xorl %eax,%eax */ + 0x40, /* incl %eax */ + 0x5f, /* popl %edi */ + 0x5b, /* popl %ebx */ + 0xc3, /* ret */ +}; + +#else + +static const BYTE call_debug_service_code[] = { + 0x53, /* push %rbx */ + 0x57, /* push %rdi */ + 0x48, 0x89, 0xc8, /* movl %rcx,%rax */ + 0x48, 0xb9, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, /* movabs $0x1111111111111111,%rcx */ + 0x48, 0xba, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* movabs $0x2222222222222222,%rdx */ + 0x48, 0xbb, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, /* movabs $0x3333333333333333,%rbx */ + 0x48, 0xbf, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, /* movabs $0x4444444444444444,%rdi */ + 0xcd, 0x2d, /* int $0x2d */ + 0xeb, /* jmp $+17 */ + 0x0f, 0x1f, 0x00, /* nop */ + 0x48, 0x31, 0xc0, /* xor %rax,%rax */ + 0xeb, 0x0e, /* jmp $+16 */ + 0x90, 0x90, 0x90, 0x90, /* nop */ + 0x90, 0x90, 0x90, 0x90, + 0x48, 0x31, 0xc0, /* xor %rax,%rax */ + 0x48, 0xff, 0xc0, /* inc %rax */ + 0x5f, /* pop %rdi */ + 0x5b, /* pop %rbx */ + 0xc3, /* ret */ +}; + +#endif + +static void test_debug_service(DWORD numexc) +{ + DWORD (CDECL *func)(DWORD_PTR) = code_mem; + DWORD expected_exc, expected_ret; + void *vectored_handler; + DWORD ret; + + /* code will return 0 if execution resumes immediately after "int $0x2d", otherwise 1 */ + memcpy(code_mem, call_debug_service_code, sizeof(call_debug_service_code)); + + vectored_handler = pRtlAddVectoredExceptionHandler(TRUE, &debug_service_handler); + ok(vectored_handler != 0, "RtlAddVectoredExceptionHandler failed\n"); + + expected_exc = numexc; + expected_ret = (numexc != 0); + + /* BREAKPOINT_BREAK */ + debug_service_exceptions = 0; + ret = func(0); + ok(debug_service_exceptions == expected_exc, + "BREAKPOINT_BREAK generated %u exceptions, expected %u\n", + debug_service_exceptions, expected_exc); + ok(ret == expected_ret, + "BREAKPOINT_BREAK returned %u, expected %u\n", ret, expected_ret); + + /* BREAKPOINT_PROMPT */ + debug_service_exceptions = 0; + ret = func(2); + ok(debug_service_exceptions == expected_exc, + "BREAKPOINT_PROMPT generated %u exceptions, expected %u\n", + debug_service_exceptions, expected_exc); + ok(ret == expected_ret, + "BREAKPOINT_PROMPT returned %u, expected %u\n", ret, expected_ret); + + /* invalid debug service */ + debug_service_exceptions = 0; + ret = func(6); + ok(debug_service_exceptions == expected_exc, + "invalid debug service generated %u exceptions, expected %u\n", + debug_service_exceptions, expected_exc); + ok(ret == expected_ret, + "invalid debug service returned %u, expected %u\n", ret, expected_ret); + + expected_exc = (is_wow64 ? numexc : 0); + expected_ret = (is_wow64 && numexc); + + /* BREAKPOINT_PRINT */ + debug_service_exceptions = 0; + ret = func(1); + ok(debug_service_exceptions == expected_exc, + "BREAKPOINT_PRINT generated %u exceptions, expected %u\n", + debug_service_exceptions, expected_exc); + ok(ret == expected_ret, + "BREAKPOINT_PRINT returned %u, expected %u\n", ret, expected_ret); + + /* BREAKPOINT_LOAD_SYMBOLS */ + debug_service_exceptions = 0; + ret = func(3); + ok(debug_service_exceptions == expected_exc, + "BREAKPOINT_LOAD_SYMBOLS generated %u exceptions, expected %u\n", + debug_service_exceptions, expected_exc); + ok(ret == expected_ret, + "BREAKPOINT_LOAD_SYMBOLS returned %u, expected %u\n", ret, expected_ret); + + /* BREAKPOINT_UNLOAD_SYMBOLS */ + debug_service_exceptions = 0; + ret = func(4); + ok(debug_service_exceptions == expected_exc, + "BREAKPOINT_UNLOAD_SYMBOLS generated %u exceptions, expected %u\n", + debug_service_exceptions, expected_exc); + ok(ret == expected_ret, + "BREAKPOINT_UNLOAD_SYMBOLS returned %u, expected %u\n", ret, expected_ret); + + /* BREAKPOINT_COMMAND_STRING */ + debug_service_exceptions = 0; + ret = func(5); + ok(debug_service_exceptions == expected_exc || broken(debug_service_exceptions == numexc), + "BREAKPOINT_COMMAND_STRING generated %u exceptions, expected %u\n", + debug_service_exceptions, expected_exc); + ok(ret == expected_ret || broken(ret == (numexc != 0)), + "BREAKPOINT_COMMAND_STRING returned %u, expected %u\n", ret, expected_ret); + + pRtlRemoveVectoredExceptionHandler(vectored_handler); +} + +static DWORD breakpoint_exceptions; + +static LONG CALLBACK breakpoint_handler(EXCEPTION_POINTERS *ExceptionInfo) +{ + EXCEPTION_RECORD *rec = ExceptionInfo->ExceptionRecord; + trace("vect. handler %08x addr:%p\n", rec->ExceptionCode, rec->ExceptionAddress); + + ok(rec->ExceptionCode == EXCEPTION_BREAKPOINT, "ExceptionCode is %08x instead of %08x\n", + rec->ExceptionCode, EXCEPTION_BREAKPOINT); + +#ifdef __i386__ + ok(ExceptionInfo->ContextRecord->Eip == (DWORD)code_mem + 1, + "expected Eip = %x, got %x\n", (DWORD)code_mem + 1, ExceptionInfo->ContextRecord->Eip); + ok(rec->NumberParameters == (is_wow64 ? 1 : 3), + "ExceptionParameters is %d instead of %d\n", rec->NumberParameters, is_wow64 ? 1 : 3); + ok(rec->ExceptionInformation[0] == 0, + "got ExceptionInformation[0] = %lx\n", rec->ExceptionInformation[0]); + ExceptionInfo->ContextRecord->Eip = (DWORD)code_mem + 2; +#else + ok(ExceptionInfo->ContextRecord->Rip == (DWORD_PTR)code_mem + 1, + "expected Rip = %lx, got %lx\n", (DWORD_PTR)code_mem + 1, ExceptionInfo->ContextRecord->Rip); + ok(rec->NumberParameters == 1, + "ExceptionParameters is %d instead of 1\n", rec->NumberParameters); + ok(rec->ExceptionInformation[0] == 0, + "got ExceptionInformation[0] = %lx\n", rec->ExceptionInformation[0]); + ExceptionInfo->ContextRecord->Rip = (DWORD_PTR)code_mem + 2; +#endif + + breakpoint_exceptions++; + return (rec->ExceptionCode == EXCEPTION_BREAKPOINT) ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_CONTINUE_SEARCH; +} + +static const BYTE breakpoint_code[] = { + 0xcd, 0x03, /* int $0x3 */ + 0xc3, /* ret */ +}; + +static void test_breakpoint(DWORD numexc) +{ + DWORD (CDECL *func)(void) = code_mem; + void *vectored_handler; + + memcpy(code_mem, breakpoint_code, sizeof(breakpoint_code)); + + vectored_handler = pRtlAddVectoredExceptionHandler(TRUE, &breakpoint_handler); + ok(vectored_handler != 0, "RtlAddVectoredExceptionHandler failed\n"); + + breakpoint_exceptions = 0; + func(); + ok(breakpoint_exceptions == numexc, "int $0x3 generated %u exceptions, expected %u\n", + breakpoint_exceptions, numexc); + + pRtlRemoveVectoredExceptionHandler(vectored_handler); +} + static DWORD invalid_handle_exceptions; static LONG CALLBACK invalid_handle_vectored_handler(EXCEPTION_POINTERS *ExceptionInfo) @@ -1893,6 +2675,10 @@ static void test_vectored_continue_handler(void) START_TEST(exception) { HMODULE hntdll = GetModuleHandleA("ntdll.dll"); +#if defined(__x86_64__) + HMODULE hmsvcrt = LoadLibraryA("msvcrt.dll"); +#endif + #ifdef __REACTOS__ if (!winetest_interactive && !strcmp(winetest_platform, "windows")) @@ -1907,13 +2693,13 @@ START_TEST(exception) return; } - pNtCurrentTeb = (void *)GetProcAddress( hntdll, "NtCurrentTeb" ); pNtGetContextThread = (void *)GetProcAddress( hntdll, "NtGetContextThread" ); pNtSetContextThread = (void *)GetProcAddress( hntdll, "NtSetContextThread" ); pNtReadVirtualMemory = (void *)GetProcAddress( hntdll, "NtReadVirtualMemory" ); pNtClose = (void *)GetProcAddress( hntdll, "NtClose" ); pRtlUnwind = (void *)GetProcAddress( hntdll, "RtlUnwind" ); pRtlRaiseException = (void *)GetProcAddress( hntdll, "RtlRaiseException" ); + pRtlCaptureContext = (void *)GetProcAddress( hntdll, "RtlCaptureContext" ); pNtTerminateProcess = (void *)GetProcAddress( hntdll, "NtTerminateProcess" ); pRtlAddVectoredExceptionHandler = (void *)GetProcAddress( hntdll, "RtlAddVectoredExceptionHandler" ); @@ -1930,11 +2716,6 @@ START_TEST(exception) pIsWow64Process = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsWow64Process"); #ifdef __i386__ - if (!pNtCurrentTeb) - { - skip( "NtCurrentTeb not found\n" ); - return; - } if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) is_wow64 = FALSE; if (pRtlAddVectoredExceptionHandler && pRtlRemoveVectoredExceptionHandler) @@ -1955,7 +2736,7 @@ START_TEST(exception) } /* child must be run under a debugger */ - if (!pNtCurrentTeb()->Peb->BeingDebugged) + if (!NtCurrentTeb()->Peb->BeingDebugged) { ok(FALSE, "child process not being debugged?\n"); return; @@ -1980,8 +2761,16 @@ START_TEST(exception) test_stage = 6; test_ripevent(1); test_stage = 7; - test_closehandle(0); + test_debug_service(0); test_stage = 8; + test_debug_service(1); + test_stage = 9; + test_breakpoint(0); + test_stage = 10; + test_breakpoint(1); + test_stage = 11; + test_closehandle(0); + test_stage = 12; test_closehandle(1); } else @@ -1994,8 +2783,11 @@ START_TEST(exception) test_unwind(); test_exceptions(); test_rtlraiseexception(); + test_debug_registers(); test_outputdebugstring(1); test_ripevent(1); + test_debug_service(1); + test_breakpoint(1); test_closehandle(0); test_vectored_continue_handler(); test_debugger(); @@ -2003,6 +2795,7 @@ START_TEST(exception) test_fpu_exceptions(); test_dpe_exceptions(); test_prot_fault(); + test_thread_context(); #elif defined(__x86_64__) pRtlAddFunctionTable = (void *)GetProcAddress( hntdll, @@ -2013,12 +2806,27 @@ START_TEST(exception) "RtlInstallFunctionTableCallback" ); pRtlLookupFunctionEntry = (void *)GetProcAddress( hntdll, "RtlLookupFunctionEntry" ); - + p__C_specific_handler = (void *)GetProcAddress( hntdll, + "__C_specific_handler" ); + pRtlCaptureContext = (void *)GetProcAddress( hntdll, + "RtlCaptureContext" ); + pRtlRestoreContext = (void *)GetProcAddress( hntdll, + "RtlRestoreContext" ); + pRtlUnwindEx = (void *)GetProcAddress( hntdll, + "RtlUnwindEx" ); + p_setjmp = (void *)GetProcAddress( hmsvcrt, + "_setjmp" ); + + test_debug_registers(); test_outputdebugstring(1); test_ripevent(1); + test_debug_service(1); + test_breakpoint(1); test_closehandle(0); test_vectored_continue_handler(); test_virtual_unwind(); + test___C_specific_handler(); + test_restore_context(); if (pRtlAddFunctionTable && pRtlDeleteFunctionTable && pRtlInstallFunctionTableCallback && pRtlLookupFunctionEntry) test_dynamic_unwind(); @@ -2027,5 +2835,5 @@ START_TEST(exception) #endif - VirtualFree(code_mem, 0, MEM_FREE); + VirtualFree(code_mem, 0, MEM_RELEASE); } diff --git a/modules/rostests/winetests/ntdll/file.c b/modules/rostests/winetests/ntdll/file.c index 0387398e5d..3316399c2f 100644 --- a/modules/rostests/winetests/ntdll/file.c +++ b/modules/rostests/winetests/ntdll/file.c @@ -94,6 +94,7 @@ static NTSTATUS (WINAPI *pNtWriteFile)(HANDLE hFile, HANDLE hEvent, static NTSTATUS (WINAPI *pNtCancelIoFile)(HANDLE hFile, PIO_STATUS_BLOCK io_status); static NTSTATUS (WINAPI *pNtCancelIoFileEx)(HANDLE hFile, PIO_STATUS_BLOCK iosb, PIO_STATUS_BLOCK io_status); static NTSTATUS (WINAPI *pNtClose)( PHANDLE ); +static NTSTATUS (WINAPI *pNtFsControlFile) (HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, PVOID apc_context, PIO_STATUS_BLOCK io, ULONG code, PVOID in_buffer, ULONG in_size, PVOID out_buffer, ULONG out_size); static NTSTATUS (WINAPI *pNtCreateIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG); static NTSTATUS (WINAPI *pNtOpenIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES); @@ -106,6 +107,7 @@ static NTSTATUS (WINAPI *pNtQueryDirectoryFile)(HANDLE,HANDLE,PIO_APC_ROUTINE,PV PVOID,ULONG,FILE_INFORMATION_CLASS,BOOLEAN,PUNICODE_STRING,BOOLEAN); static NTSTATUS (WINAPI *pNtQueryVolumeInformationFile)(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS); static NTSTATUS (WINAPI *pNtQueryFullAttributesFile)(const OBJECT_ATTRIBUTES*, FILE_NETWORK_OPEN_INFORMATION*); +static NTSTATUS (WINAPI *pNtFlushBuffersFile)(HANDLE, IO_STATUS_BLOCK*); static NTSTATUS (WINAPI *pNtQueryEaFile)(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,BOOLEAN,PVOID,ULONG,PULONG,BOOLEAN); static inline BOOL is_signaled( HANDLE obj ) @@ -113,31 +115,8 @@ static inline BOOL is_signaled( HANDLE obj ) return WaitForSingleObject( obj, 0 ) == WAIT_OBJECT_0; } -static const char* debugstr_longlong(ULONGLONG ll) -{ - static char str[17]; - if (sizeof(ll) > sizeof(unsigned long) && ll >> 32) - sprintf(str, "%lx%08lx", (unsigned long)(ll >> 32), (unsigned long)ll); - else - sprintf(str, "%lx", (unsigned long)ll); - return str; -} - -#define PIPENAME "\\\\.\\pipe\\ntdll_tests_file.c" #define TEST_BUF_LEN 3 -static BOOL create_pipe( HANDLE *read, HANDLE *write, ULONG flags, ULONG size ) -{ - *read = CreateNamedPipeA(PIPENAME, PIPE_ACCESS_INBOUND | flags, PIPE_TYPE_BYTE | PIPE_WAIT, - 1, size, size, NMPWAIT_USE_DEFAULT_WAIT, NULL); - ok(*read != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n"); - - *write = CreateFileA(PIPENAME, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0); - ok(*write != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError()); - - return TRUE; -} - static HANDLE create_temp_file( ULONG flags ) { char path[MAX_PATH], buffer[MAX_PATH]; @@ -198,18 +177,22 @@ static void WINAPI apc( void *arg, IO_STATUS_BLOCK *iosb, ULONG reserved ) static void create_file_test(void) { + static const WCHAR notepadW[] = {'n','o','t','e','p','a','d','.','e','x','e',0}; static const WCHAR systemrootW[] = {'\\','S','y','s','t','e','m','R','o','o','t', '\\','f','a','i','l','i','n','g',0}; + static const WCHAR systemrootExplorerW[] = {'\\','S','y','s','t','e','m','R','o','o','t', + '\\','e','x','p','l','o','r','e','r','.','e','x','e',0}; static const WCHAR questionmarkInvalidNameW[] = {'a','f','i','l','e','?',0}; static const WCHAR pipeInvalidNameW[] = {'a','|','b',0}; static const WCHAR pathInvalidNtW[] = {'\\','\\','?','\\',0}; static const WCHAR pathInvalidNt2W[] = {'\\','?','?','\\',0}; static const WCHAR pathInvalidDosW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\',0}; static const char testdata[] = "Hello World"; + static const WCHAR sepW[] = {'\\',0}; FILE_NETWORK_OPEN_INFORMATION info; NTSTATUS status; HANDLE dir, file; - WCHAR path[MAX_PATH]; + WCHAR path[MAX_PATH], temp[MAX_PATH]; OBJECT_ATTRIBUTES attr; IO_STATUS_BLOCK io; UNICODE_STRING nameW; @@ -389,6 +372,25 @@ static void create_file_test(void) status = pNtQueryFullAttributesFile( &attr, &info ); ok( status == STATUS_OBJECT_NAME_INVALID, "query %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status ); + + GetWindowsDirectoryW( path, MAX_PATH ); + path[2] = 0; + ok( QueryDosDeviceW( path, temp, MAX_PATH ), + "QueryDosDeviceW failed with error %u\n", GetLastError() ); + lstrcatW( temp, sepW ); + lstrcatW( temp, path+3 ); + lstrcatW( temp, sepW ); + lstrcatW( temp, notepadW ); + + pRtlInitUnicodeString( &nameW, temp ); + status = pNtQueryFullAttributesFile( &attr, &info ); + ok( status == STATUS_SUCCESS, + "query %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status ); + + pRtlInitUnicodeString( &nameW, systemrootExplorerW ); + status = pNtQueryFullAttributesFile( &attr, &info ); + ok( status == STATUS_SUCCESS, + "query %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status ); } static void open_file_test(void) @@ -660,268 +662,14 @@ static void delete_file_test(void) static void read_file_test(void) { const char text[] = "foobar"; - HANDLE handle, read, write; + HANDLE handle; + IO_STATUS_BLOCK iosb; NTSTATUS status; - IO_STATUS_BLOCK iosb, iosb2; - DWORD written; int apc_count = 0; char buffer[128]; LARGE_INTEGER offset; HANDLE event = CreateEventA( NULL, TRUE, FALSE, NULL ); - BOOL ret; - - buffer[0] = 1; - - if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return; - - /* try read with no data */ - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - ok( is_signaled( read ), "read handle is not signaled\n" ); - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL ); - ok( status == STATUS_PENDING, "wrong status %x\n", status ); - ok( !is_signaled( read ), "read handle is signaled\n" ); - ok( !is_signaled( event ), "event is signaled\n" ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - ret = WriteFile( write, buffer, 1, &written, NULL ); - ok(ret && written == 1, "WriteFile error %d\n", GetLastError()); - /* iosb updated here by async i/o */ - Sleep(1); /* FIXME: needed for wine to run the i/o apc */ - ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information ); - ok( !is_signaled( read ), "read handle is signaled\n" ); - ok( is_signaled( event ), "event is not signaled\n" ); - ok( !apc_count, "apc was called\n" ); - apc_count = 0; - SleepEx( 1, FALSE ); /* non-alertable sleep */ - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( apc_count == 1, "apc not called\n" ); - - /* with no event, the pipe handle itself gets signaled */ - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - ok( !is_signaled( read ), "read handle is signaled\n" ); - status = pNtReadFile( read, 0, apc, &apc_count, &iosb, buffer, 1, NULL, NULL ); - ok( status == STATUS_PENDING, "wrong status %x\n", status ); - ok( !is_signaled( read ), "read handle is signaled\n" ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - ret = WriteFile( write, buffer, 1, &written, NULL ); - ok(ret && written == 1, "WriteFile error %d\n", GetLastError()); - /* iosb updated here by async i/o */ - Sleep(1); /* FIXME: needed for wine to run the i/o apc */ - ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information ); - ok( is_signaled( read ), "read handle is not signaled\n" ); - ok( !apc_count, "apc was called\n" ); - apc_count = 0; - SleepEx( 1, FALSE ); /* non-alertable sleep */ - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( apc_count == 1, "apc not called\n" ); - /* now read with data ready */ - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - ResetEvent( event ); - ret = WriteFile( write, buffer, 1, &written, NULL ); - ok(ret && written == 1, "WriteFile error %d\n", GetLastError()); - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL ); - ok( status == STATUS_SUCCESS, "wrong status %x\n", status ); - ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information ); - ok( is_signaled( event ), "event is not signaled\n" ); - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, FALSE ); /* non-alertable sleep */ - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( apc_count == 1, "apc not called\n" ); - - /* try read with no data */ - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - ok( is_signaled( event ), "event is not signaled\n" ); /* check that read resets the event */ - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL ); - ok( status == STATUS_PENDING, "wrong status %x\n", status ); - ok( !is_signaled( event ), "event is signaled\n" ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - ret = WriteFile( write, buffer, 1, &written, NULL ); - ok(ret && written == 1, "WriteFile error %d\n", GetLastError()); - /* partial read is good enough */ - Sleep(1); /* FIXME: needed for wine to run the i/o apc */ - ok( is_signaled( event ), "event is not signaled\n" ); - ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( apc_count == 1, "apc was not called\n" ); - - /* read from disconnected pipe */ - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - CloseHandle( write ); - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL ); - ok( status == STATUS_PIPE_BROKEN, "wrong status %x\n", status ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !is_signaled( event ), "event is signaled\n" ); - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( !apc_count, "apc was called\n" ); - CloseHandle( read ); - - /* read from closed handle */ - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - SetEvent( event ); - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL ); - ok( status == STATUS_INVALID_HANDLE, "wrong status %x\n", status ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( is_signaled( event ), "event is not signaled\n" ); /* not reset on invalid handle */ - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( !apc_count, "apc was called\n" ); - - /* disconnect while async read is in progress */ - if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return; - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL ); - ok( status == STATUS_PENDING, "wrong status %x\n", status ); - ok( !is_signaled( event ), "event is signaled\n" ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - CloseHandle( write ); - Sleep(1); /* FIXME: needed for wine to run the i/o apc */ - ok( U(iosb).Status == STATUS_PIPE_BROKEN, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information ); - ok( is_signaled( event ), "event is not signaled\n" ); - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( apc_count == 1, "apc was not called\n" ); - CloseHandle( read ); - - if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return; - ret = DuplicateHandle(GetCurrentProcess(), read, GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS); - ok(ret, "Failed to duplicate handle: %d\n", GetLastError()); - - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL ); - ok( status == STATUS_PENDING, "wrong status %x\n", status ); - ok( !is_signaled( event ), "event is signaled\n" ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - /* Cancel by other handle */ - status = pNtCancelIoFile( read, &iosb2 ); - ok(status == STATUS_SUCCESS, "failed to cancel by different handle: %x\n", status); - Sleep(1); /* FIXME: needed for wine to run the i/o apc */ - ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information ); - ok( is_signaled( event ), "event is not signaled\n" ); - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( apc_count == 1, "apc was not called\n" ); - - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL ); - ok( status == STATUS_PENDING, "wrong status %x\n", status ); - ok( !is_signaled( event ), "event is signaled\n" ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - /* Close queued handle */ - CloseHandle( read ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - status = pNtCancelIoFile( read, &iosb2 ); - ok(status == STATUS_INVALID_HANDLE, "cancelled by closed handle?\n"); - status = pNtCancelIoFile( handle, &iosb2 ); - ok(status == STATUS_SUCCESS, "failed to cancel: %x\n", status); - Sleep(1); /* FIXME: needed for wine to run the i/o apc */ - ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information ); - ok( is_signaled( event ), "event is not signaled\n" ); - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( apc_count == 1, "apc was not called\n" ); - CloseHandle( handle ); - CloseHandle( write ); - - if (pNtCancelIoFileEx) - { - /* Basic Cancel Ex */ - if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return; - - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL ); - ok( status == STATUS_PENDING, "wrong status %x\n", status ); - ok( !is_signaled( event ), "event is signaled\n" ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - status = pNtCancelIoFileEx( read, &iosb, &iosb2 ); - ok(status == STATUS_SUCCESS, "Failed to cancel I/O\n"); - Sleep(1); /* FIXME: needed for wine to run the i/o apc */ - ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information ); - ok( is_signaled( event ), "event is not signaled\n" ); - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( apc_count == 1, "apc was not called\n" ); - - /* Duplicate iosb */ - apc_count = 0; - U(iosb).Status = 0xdeadbabe; - iosb.Information = 0xdeadbeef; - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL ); - ok( status == STATUS_PENDING, "wrong status %x\n", status ); - ok( !is_signaled( event ), "event is signaled\n" ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL ); - ok( status == STATUS_PENDING, "wrong status %x\n", status ); - ok( !is_signaled( event ), "event is signaled\n" ); - ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information ); - ok( !apc_count, "apc was called\n" ); - status = pNtCancelIoFileEx( read, &iosb, &iosb2 ); - ok(status == STATUS_SUCCESS, "Failed to cancel I/O\n"); - Sleep(1); /* FIXME: needed for wine to run the i/o apc */ - ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status ); - ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information ); - ok( is_signaled( event ), "event is not signaled\n" ); - ok( !apc_count, "apc was called\n" ); - SleepEx( 1, TRUE ); /* alertable sleep */ - ok( apc_count == 2, "apc was not called\n" ); - - CloseHandle( read ); - CloseHandle( write ); - } - - /* now try a real file */ if (!(handle = create_temp_file( FILE_FLAG_OVERLAPPED ))) return; apc_count = 0; U(iosb).Status = 0xdeadbabe; @@ -1297,7 +1045,7 @@ static void test_iocp_fileio(HANDLE h) ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey ); ok( ioSb.Information == 0, "Invalid ioSb.Information: %ld\n", ioSb.Information ); /* wine sends wrong status here */ - todo_wine ok( U(ioSb).Status == STATUS_PIPE_BROKEN, "Invalid ioSb.Status: %x\n", U(ioSb).Status); + ok( U(ioSb).Status == STATUS_PIPE_BROKEN, "Invalid ioSb.Status: %x\n", U(ioSb).Status); ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue ); } } @@ -1315,6 +1063,7 @@ static void test_iocp_fileio(HANDLE h) { OVERLAPPED o = {0,}; BYTE send_buf[TEST_BUF_LEN], recv_buf[TEST_BUF_LEN]; + int apc_count = 0; DWORD read; long count; @@ -1343,6 +1092,58 @@ static void test_iocp_fileio(HANDLE h) } count = get_pending_msgs(h); ok( !count, "Unexpected msg count: %ld\n", count ); + + /* using APCs on handle with associated completion port is not allowed */ + res = NtReadFile( hPipeSrv, NULL, apc, &apc_count, &iosb, recv_buf, sizeof(recv_buf), NULL, NULL ); + ok(res == STATUS_INVALID_PARAMETER, "NtReadFile returned %x\n", res); + } + + CloseHandle( hPipeSrv ); + CloseHandle( hPipeClt ); + + /* test associating a completion port with a handle after an async using APC is queued */ + hPipeSrv = CreateNamedPipeA( pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024, 1000, NULL ); + ok( hPipeSrv != INVALID_HANDLE_VALUE, "Cannot create named pipe\n" ); + if (hPipeSrv == INVALID_HANDLE_VALUE ) + return; + hPipeClt = CreateFileA( pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL ); + ok( hPipeClt != INVALID_HANDLE_VALUE, "Cannot connect to pipe\n" ); + if (hPipeClt != INVALID_HANDLE_VALUE) + { + BYTE send_buf[TEST_BUF_LEN], recv_buf[TEST_BUF_LEN]; + int apc_count = 0; + DWORD read; + long count; + + memset( send_buf, 0, TEST_BUF_LEN ); + memset( recv_buf, 0xde, TEST_BUF_LEN ); + count = get_pending_msgs(h); + ok( !count, "Unexpected msg count: %ld\n", count ); + + res = NtReadFile( hPipeSrv, NULL, apc, &apc_count, &iosb, recv_buf, sizeof(recv_buf), NULL, NULL ); + ok(res == STATUS_PENDING, "NtReadFile returned %x\n", res); + + U(iosb).Status = 0xdeadbeef; + res = pNtSetInformationFile( hPipeSrv, &iosb, &fci, sizeof(fci), FileCompletionInformation ); + ok( res == STATUS_SUCCESS, "NtSetInformationFile failed: %x\n", res ); + ok( U(iosb).Status == STATUS_SUCCESS, "iosb.Status invalid: %x\n", U(iosb).Status ); + count = get_pending_msgs(h); + ok( !count, "Unexpected msg count: %ld\n", count ); + + WriteFile( hPipeClt, send_buf, TEST_BUF_LEN, &read, NULL ); + + ok(!apc_count, "apc_count = %u\n", apc_count); + count = get_pending_msgs(h); + ok( !count, "Unexpected msg count: %ld\n", count ); + + SleepEx(1, TRUE); /* alertable sleep */ + ok(apc_count == 1, "apc was not called\n"); + count = get_pending_msgs(h); + ok( !count, "Unexpected msg count: %ld\n", count ); + + /* using APCs on handle with associated completion port is not allowed */ + res = NtReadFile( hPipeSrv, NULL, apc, &apc_count, &iosb, recv_buf, sizeof(recv_buf), NULL, NULL ); + ok(res == STATUS_INVALID_PARAMETER, "NtReadFile returned %x\n", res); } CloseHandle( hPipeSrv ); @@ -1371,10 +1172,10 @@ static void test_file_full_size_information(void) /* Test for FileFsSizeInformation */ ok(fsi.TotalAllocationUnits.QuadPart > 0, "[fsi] TotalAllocationUnits expected positive, got 0x%s\n", - debugstr_longlong(fsi.TotalAllocationUnits.QuadPart)); + wine_dbgstr_longlong(fsi.TotalAllocationUnits.QuadPart)); ok(fsi.AvailableAllocationUnits.QuadPart > 0, "[fsi] AvailableAllocationUnits expected positive, got 0x%s\n", - debugstr_longlong(fsi.AvailableAllocationUnits.QuadPart)); + wine_dbgstr_longlong(fsi.AvailableAllocationUnits.QuadPart)); /* Assume file system is NTFS */ ok(fsi.BytesPerSector == 512, "[fsi] BytesPerSector expected 512, got %d\n",fsi.BytesPerSector); @@ -1382,21 +1183,21 @@ static void test_file_full_size_information(void) ok(ffsi.TotalAllocationUnits.QuadPart > 0, "[ffsi] TotalAllocationUnits expected positive, got negative value 0x%s\n", - debugstr_longlong(ffsi.TotalAllocationUnits.QuadPart)); + wine_dbgstr_longlong(ffsi.TotalAllocationUnits.QuadPart)); ok(ffsi.CallerAvailableAllocationUnits.QuadPart > 0, "[ffsi] CallerAvailableAllocationUnits expected positive, got negative value 0x%s\n", - debugstr_longlong(ffsi.CallerAvailableAllocationUnits.QuadPart)); + wine_dbgstr_longlong(ffsi.CallerAvailableAllocationUnits.QuadPart)); ok(ffsi.ActualAvailableAllocationUnits.QuadPart > 0, "[ffsi] ActualAvailableAllocationUnits expected positive, got negative value 0x%s\n", - debugstr_longlong(ffsi.ActualAvailableAllocationUnits.QuadPart)); + wine_dbgstr_longlong(ffsi.ActualAvailableAllocationUnits.QuadPart)); ok(ffsi.TotalAllocationUnits.QuadPart == fsi.TotalAllocationUnits.QuadPart, "[ffsi] TotalAllocationUnits error fsi:0x%s, ffsi:0x%s\n", - debugstr_longlong(fsi.TotalAllocationUnits.QuadPart), - debugstr_longlong(ffsi.TotalAllocationUnits.QuadPart)); + wine_dbgstr_longlong(fsi.TotalAllocationUnits.QuadPart), + wine_dbgstr_longlong(ffsi.TotalAllocationUnits.QuadPart)); ok(ffsi.CallerAvailableAllocationUnits.QuadPart == fsi.AvailableAllocationUnits.QuadPart, "[ffsi] CallerAvailableAllocationUnits error fsi:0x%s, ffsi: 0x%s\n", - debugstr_longlong(fsi.AvailableAllocationUnits.QuadPart), - debugstr_longlong(ffsi.CallerAvailableAllocationUnits.QuadPart)); + wine_dbgstr_longlong(fsi.AvailableAllocationUnits.QuadPart), + wine_dbgstr_longlong(ffsi.CallerAvailableAllocationUnits.QuadPart)); /* Assume file system is NTFS */ ok(ffsi.BytesPerSector == 512, "[ffsi] BytesPerSector expected 512, got %d\n",ffsi.BytesPerSector); @@ -1592,7 +1393,7 @@ static void test_file_rename_information(void) res = pNtQueryInformationFile( handle, &io, fni, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR), FileNameInformation ); ok( res == STATUS_SUCCESS, "res expected STATUS_SUCCESS, got %x\n", res ); fni->FileName[ fni->FileNameLength / sizeof(WCHAR) ] = 0; - ok( !lstrcmpW(fni->FileName, newpath + 2), "FileName expected %s, got %s\n", + ok( !lstrcmpiW(fni->FileName, newpath + 2), "FileName expected %s, got %s\n", wine_dbgstr_w(newpath + 2), wine_dbgstr_w(fni->FileName) ); HeapFree( GetProcessHeap(), 0, fni ); @@ -1762,7 +1563,7 @@ static void test_file_rename_information(void) res = pNtQueryInformationFile( handle, &io, fni, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR), FileNameInformation ); ok( res == STATUS_SUCCESS, "res expected STATUS_SUCCESS, got %x\n", res ); fni->FileName[ fni->FileNameLength / sizeof(WCHAR) ] = 0; - ok( !lstrcmpW(fni->FileName, newpath + 2), "FileName expected %s, got %s\n", + ok( !lstrcmpiW(fni->FileName, newpath + 2), "FileName expected %s, got %s\n", wine_dbgstr_w(newpath + 2), wine_dbgstr_w(fni->FileName) ); HeapFree( GetProcessHeap(), 0, fni ); @@ -2168,7 +1969,7 @@ static void test_file_rename_information(void) res = pNtQueryInformationFile( handle, &io, fni, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR), FileNameInformation ); ok( res == STATUS_SUCCESS, "res expected STATUS_SUCCESS, got %x\n", res ); fni->FileName[ fni->FileNameLength / sizeof(WCHAR) ] = 0; - ok( !lstrcmpW(fni->FileName, newpath + 2), "FileName expected %s, got %s\n", + ok( !lstrcmpiW(fni->FileName, newpath + 2), "FileName expected %s, got %s\n", wine_dbgstr_w(newpath + 2), wine_dbgstr_w(fni->FileName) ); HeapFree( GetProcessHeap(), 0, fni ); @@ -2181,6 +1982,7 @@ static void test_file_rename_information(void) static void test_file_link_information(void) { + static const WCHAR pipeW[] = {'\\','\\','.','\\','p','i','p','e','\\','w','i','n','e','_','t','e','s','t',0}; static const WCHAR foo_txtW[] = {'\\','f','o','o','.','t','x','t',0}; static const WCHAR fooW[] = {'f','o','o',0}; WCHAR tmp_path[MAX_PATH], oldpath[MAX_PATH + 16], newpath[MAX_PATH + 16], *filename, *p; @@ -2224,7 +2026,7 @@ static void test_file_link_information(void) res = pNtQueryInformationFile( handle, &io, fni, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR), FileNameInformation ); ok( res == STATUS_SUCCESS, "res expected STATUS_SUCCESS, got %x\n", res ); fni->FileName[ fni->FileNameLength / sizeof(WCHAR) ] = 0; - ok( !lstrcmpW(fni->FileName, oldpath + 2), "FileName expected %s, got %s\n", + ok( !lstrcmpiW(fni->FileName, oldpath + 2), "FileName expected %s, got %s\n", wine_dbgstr_w(oldpath + 2), wine_dbgstr_w(fni->FileName) ); HeapFree( GetProcessHeap(), 0, fni ); @@ -2394,7 +2196,7 @@ static void test_file_link_information(void) res = pNtQueryInformationFile( handle, &io, fni, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR), FileNameInformation ); ok( res == STATUS_SUCCESS, "res expected STATUS_SUCCESS, got %x\n", res ); fni->FileName[ fni->FileNameLength / sizeof(WCHAR) ] = 0; - ok( !lstrcmpW(fni->FileName, oldpath + 2), "FileName expected %s, got %s\n", + ok( !lstrcmpiW(fni->FileName, oldpath + 2), "FileName expected %s, got %s\n", wine_dbgstr_w(oldpath + 2), wine_dbgstr_w(fni->FileName) ); HeapFree( GetProcessHeap(), 0, fni ); @@ -2797,12 +2599,36 @@ static void test_file_link_information(void) res = pNtQueryInformationFile( handle, &io, fni, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR), FileNameInformation ); ok( res == STATUS_SUCCESS, "res expected STATUS_SUCCESS, got %x\n", res ); fni->FileName[ fni->FileNameLength / sizeof(WCHAR) ] = 0; - ok( !lstrcmpW(fni->FileName, oldpath + 2), "FileName expected %s, got %s\n", + ok( !lstrcmpiW(fni->FileName, oldpath + 2), "FileName expected %s, got %s\n", wine_dbgstr_w(oldpath + 2), wine_dbgstr_w(fni->FileName) ); HeapFree( GetProcessHeap(), 0, fni ); CloseHandle( handle ); CloseHandle( handle2 ); + + handle = CreateEventA( NULL, FALSE, FALSE, "wine_test_event" ); + ok( !!handle, "Failed to create event: %u\n", GetLastError()); + + fni = HeapAlloc( GetProcessHeap(), 0, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR) ); + res = pNtQueryInformationFile( handle, &io, fni, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR), FileNameInformation ); + ok( res == STATUS_OBJECT_TYPE_MISMATCH, "res expected STATUS_OBJECT_TYPE_MISMATCH, got %x\n", res ); + HeapFree( GetProcessHeap(), 0, fni ); + + CloseHandle( handle ); + + handle = CreateNamedPipeW( pipeW, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE|PIPE_READMODE_BYTE, 10, 512, 512, 0, NULL); + ok( handle != INVALID_HANDLE_VALUE, "Failed to create named pipe: %u\n", GetLastError()); + + fni = HeapAlloc( GetProcessHeap(), 0, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR) ); + res = pNtQueryInformationFile( handle, &io, fni, sizeof(FILE_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR), FileNameInformation ); + ok( res == STATUS_SUCCESS, "res expected STATUS_SUCCESS, got %x\n", res ); + fni->FileName[ fni->FileNameLength / sizeof(WCHAR) ] = 0; + ok( !lstrcmpiW(fni->FileName, pipeW + 8), "FileName expected %s, got %s\n", + wine_dbgstr_w(pipeW + 8), wine_dbgstr_w(fni->FileName) ); + HeapFree( GetProcessHeap(), 0, fni ); + + CloseHandle( handle ); + HeapFree( GetProcessHeap(), 0, fli ); delete_object( oldpath ); delete_object( newpath ); @@ -3349,6 +3175,213 @@ static void test_file_all_name_information(void) HeapFree( GetProcessHeap(), 0, file_name ); } +static void test_file_completion_information(void) +{ + static const char buf[] = "testdata"; + FILE_IO_COMPLETION_NOTIFICATION_INFORMATION info; + OVERLAPPED ov, *pov; + IO_STATUS_BLOCK io; + NTSTATUS status; + DWORD num_bytes; + HANDLE port, h; + ULONG_PTR key; + BOOL ret; + int i; + + if (!(h = create_temp_file(0))) return; + + status = pNtSetInformationFile(h, &io, &info, sizeof(info) - 1, FileIoCompletionNotificationInformation); + ok(status == STATUS_INFO_LENGTH_MISMATCH || status == STATUS_INVALID_INFO_CLASS /* XP */, + "expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status); + if (status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED) + { + win_skip("FileIoCompletionNotificationInformation class not supported\n"); + CloseHandle(h); + return; + } + + info.Flags = FILE_SKIP_COMPLETION_PORT_ON_SUCCESS; + status = pNtSetInformationFile(h, &io, &info, sizeof(info), FileIoCompletionNotificationInformation); + ok(status == STATUS_INVALID_PARAMETER, "expected STATUS_INVALID_PARAMETER, got %08x\n", status); + + CloseHandle(h); + if (!(h = create_temp_file(FILE_FLAG_OVERLAPPED))) return; + + info.Flags = FILE_SKIP_SET_EVENT_ON_HANDLE; + status = pNtSetInformationFile(h, &io, &info, sizeof(info), FileIoCompletionNotificationInformation); + ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status); + + info.Flags = FILE_SKIP_SET_USER_EVENT_ON_FAST_IO; + status = pNtSetInformationFile(h, &io, &info, sizeof(info), FileIoCompletionNotificationInformation); + ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status); + + CloseHandle(h); + if (!(h = create_temp_file(FILE_FLAG_OVERLAPPED))) return; + + info.Flags = ~0U; + status = pNtQueryInformationFile(h, &io, &info, sizeof(info), FileIoCompletionNotificationInformation); + ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status); + ok(!(info.Flags & FILE_SKIP_COMPLETION_PORT_ON_SUCCESS), "got %08x\n", info.Flags); + + memset(&ov, 0, sizeof(ov)); + ov.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL); + port = CreateIoCompletionPort(h, NULL, 0xdeadbeef, 0); + ok(port != NULL, "CreateIoCompletionPort failed, error %u\n", GetLastError()); + + for (i = 0; i < 10; i++) + { + SetLastError(0xdeadbeef); + ret = WriteFile(h, buf, sizeof(buf), &num_bytes, &ov); + if (ret || GetLastError() != ERROR_IO_PENDING) break; + ret = GetOverlappedResult(h, &ov, &num_bytes, TRUE); + ok(ret, "GetOverlappedResult failed, error %u\n", GetLastError()); + ret = GetQueuedCompletionStatus(port, &num_bytes, &key, &pov, 1000); + ok(ret, "GetQueuedCompletionStatus failed, error %u\n", GetLastError()); + ret = FALSE; + } + if (ret) + { + ok(num_bytes == sizeof(buf), "expected sizeof(buf), got %u\n", num_bytes); + + key = 0; + pov = NULL; + ret = GetQueuedCompletionStatus(port, &num_bytes, &key, &pov, 1000); + ok(ret, "GetQueuedCompletionStatus failed, error %u\n", GetLastError()); + ok(key == 0xdeadbeef, "expected 0xdeadbeef, got %lx\n", key); + ok(pov == &ov, "expected %p, got %p\n", &ov, pov); + } + else + win_skip("WriteFile never returned TRUE\n"); + + info.Flags = FILE_SKIP_COMPLETION_PORT_ON_SUCCESS; + status = pNtSetInformationFile(h, &io, &info, sizeof(info), FileIoCompletionNotificationInformation); + ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status); + + info.Flags = 0; + status = pNtQueryInformationFile(h, &io, &info, sizeof(info), FileIoCompletionNotificationInformation); + ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status); + ok((info.Flags & FILE_SKIP_COMPLETION_PORT_ON_SUCCESS) != 0, "got %08x\n", info.Flags); + + for (i = 0; i < 10; i++) + { + SetLastError(0xdeadbeef); + ret = WriteFile(h, buf, sizeof(buf), &num_bytes, &ov); + if (ret || GetLastError() != ERROR_IO_PENDING) break; + ret = GetOverlappedResult(h, &ov, &num_bytes, TRUE); + ok(ret, "GetOverlappedResult failed, error %u\n", GetLastError()); + ret = FALSE; + } + if (ret) + { + ok(num_bytes == sizeof(buf), "expected sizeof(buf), got %u\n", num_bytes); + + pov = (void *)0xdeadbeef; + ret = GetQueuedCompletionStatus(port, &num_bytes, &key, &pov, 500); + ok(!ret, "GetQueuedCompletionStatus succeeded\n"); + ok(pov == NULL, "expected NULL, got %p\n", pov); + } + else + win_skip("WriteFile never returned TRUE\n"); + + info.Flags = 0; + status = pNtSetInformationFile(h, &io, &info, sizeof(info), FileIoCompletionNotificationInformation); + ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status); + + info.Flags = 0; + status = pNtQueryInformationFile(h, &io, &info, sizeof(info), FileIoCompletionNotificationInformation); + ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status); + ok((info.Flags & FILE_SKIP_COMPLETION_PORT_ON_SUCCESS) != 0, "got %08x\n", info.Flags); + + for (i = 0; i < 10; i++) + { + SetLastError(0xdeadbeef); + ret = WriteFile(h, buf, sizeof(buf), &num_bytes, &ov); + if (ret || GetLastError() != ERROR_IO_PENDING) break; + ret = GetOverlappedResult(h, &ov, &num_bytes, TRUE); + ok(ret, "GetOverlappedResult failed, error %u\n", GetLastError()); + ret = GetQueuedCompletionStatus(port, &num_bytes, &key, &pov, 1000); + ok(ret, "GetQueuedCompletionStatus failed, error %u\n", GetLastError()); + ret = FALSE; + } + if (ret) + { + ok(num_bytes == sizeof(buf), "expected sizeof(buf), got %u\n", num_bytes); + + pov = (void *)0xdeadbeef; + ret = GetQueuedCompletionStatus(port, &num_bytes, &key, &pov, 1000); + ok(!ret, "GetQueuedCompletionStatus succeeded\n"); + ok(pov == NULL, "expected NULL, got %p\n", pov); + } + else + win_skip("WriteFile never returned TRUE\n"); + + CloseHandle(ov.hEvent); + CloseHandle(port); + CloseHandle(h); +} + +static void test_file_id_information(void) +{ + BY_HANDLE_FILE_INFORMATION info; + FILE_ID_INFORMATION fid; + IO_STATUS_BLOCK io; + NTSTATUS status; + DWORD *dwords; + HANDLE h; + BOOL ret; + + if (!(h = create_temp_file(0))) return; + + memset( &fid, 0x11, sizeof(fid) ); + status = pNtQueryInformationFile( h, &io, &fid, sizeof(fid), FileIdInformation ); + if (status == STATUS_NOT_IMPLEMENTED || status == STATUS_INVALID_INFO_CLASS) + { + win_skip( "FileIdInformation not supported\n" ); + CloseHandle( h ); + return; + } + + memset( &info, 0x22, sizeof(info) ); + ret = GetFileInformationByHandle( h, &info ); + ok( ret, "GetFileInformationByHandle failed\n" ); + + dwords = (DWORD *)&fid.VolumeSerialNumber; + ok( dwords[0] == info.dwVolumeSerialNumber, "expected %08x, got %08x\n", + info.dwVolumeSerialNumber, dwords[0] ); + ok( dwords[1] != 0x11111111, "expected != 0x11111111\n" ); + + dwords = (DWORD *)&fid.FileId; + ok( dwords[0] == info.nFileIndexLow, "expected %08x, got %08x\n", info.nFileIndexLow, dwords[0] ); + ok( dwords[1] == info.nFileIndexHigh, "expected %08x, got %08x\n", info.nFileIndexHigh, dwords[1] ); + ok( dwords[2] == 0, "expected 0, got %08x\n", dwords[2] ); + ok( dwords[3] == 0, "expected 0, got %08x\n", dwords[3] ); + + CloseHandle( h ); +} + +static void test_file_access_information(void) +{ + FILE_ACCESS_INFORMATION info; + IO_STATUS_BLOCK io; + NTSTATUS status; + HANDLE h; + + if (!(h = create_temp_file(0))) return; + + status = pNtQueryInformationFile( h, &io, &info, sizeof(info) - 1, FileAccessInformation ); + ok( status == STATUS_INFO_LENGTH_MISMATCH, "expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status ); + + status = pNtQueryInformationFile( (HANDLE)0xdeadbeef, &io, &info, sizeof(info), FileAccessInformation ); + ok( status == STATUS_INVALID_HANDLE, "expected STATUS_INVALID_HANDLE, got %08x\n", status ); + + memset(&info, 0x11, sizeof(info)); + status = pNtQueryInformationFile( h, &io, &info, sizeof(info), FileAccessInformation ); + ok( status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status ); + ok( info.AccessFlags == 0x13019f, "got %08x\n", info.AccessFlags ); + + CloseHandle( h ); +} + static void test_query_volume_information_file(void) { NTSTATUS status; @@ -3616,13 +3649,15 @@ static void test_read_write(void) { static const char contents[14] = "1234567890abcd"; char buf[256]; - HANDLE hfile; + HANDLE hfile, event; OVERLAPPED ovl; IO_STATUS_BLOCK iob; DWORD ret, bytes, status, off; LARGE_INTEGER offset; LONG i; + event = CreateEventA( NULL, TRUE, FALSE, NULL ); + U(iob).Status = -1; iob.Information = -1; offset.QuadPart = 0; @@ -3631,6 +3666,22 @@ static void test_read_write(void) ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status); ok(iob.Information == -1, "expected -1, got %lu\n", iob.Information); + U(iob).Status = -1; + iob.Information = -1; + offset.QuadPart = 0; + status = pNtReadFile(INVALID_HANDLE_VALUE, 0, NULL, NULL, &iob, NULL, sizeof(buf), &offset, NULL); + ok(status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, "expected STATUS_OBJECT_TYPE_MISMATCH, got %#x\n", status); + ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status); + ok(iob.Information == -1, "expected -1, got %lu\n", iob.Information); + + U(iob).Status = -1; + iob.Information = -1; + offset.QuadPart = 0; + status = pNtWriteFile(INVALID_HANDLE_VALUE, 0, NULL, NULL, &iob, buf, sizeof(buf), &offset, NULL); + ok(status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, "expected STATUS_OBJECT_TYPE_MISMATCH, got %#x\n", status); + ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status); + ok(iob.Information == -1, "expected -1, got %lu\n", iob.Information); + U(iob).Status = -1; iob.Information = -1; offset.QuadPart = 0; @@ -3649,6 +3700,15 @@ static void test_read_write(void) ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status); ok(iob.Information == -1, "expected -1, got %lu\n", iob.Information); + U(iob).Status = -1; + iob.Information = -1; + SetEvent(event); + status = pNtWriteFile(hfile, event, NULL, NULL, &iob, NULL, sizeof(contents), NULL, NULL); + ok(status == STATUS_INVALID_USER_BUFFER, "expected STATUS_INVALID_USER_BUFFER, got %#x\n", status); + ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status); + ok(iob.Information == -1, "expected -1, got %lu\n", iob.Information); + ok(!is_signaled(event), "event is not signaled\n"); + U(iob).Status = -1; iob.Information = -1; status = pNtReadFile(hfile, 0, NULL, NULL, &iob, NULL, sizeof(contents), NULL, NULL); @@ -3656,6 +3716,24 @@ static void test_read_write(void) ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status); ok(iob.Information == -1, "expected -1, got %lu\n", iob.Information); + U(iob).Status = -1; + iob.Information = -1; + SetEvent(event); + status = pNtReadFile(hfile, event, NULL, NULL, &iob, NULL, sizeof(contents), NULL, NULL); + ok(status == STATUS_ACCESS_VIOLATION, "expected STATUS_ACCESS_VIOLATION, got %#x\n", status); + ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status); + ok(iob.Information == -1, "expected -1, got %lu\n", iob.Information); + ok(is_signaled(event), "event is not signaled\n"); + + U(iob).Status = -1; + iob.Information = -1; + SetEvent(event); + status = pNtReadFile(hfile, event, NULL, NULL, &iob, (void*)0xdeadbeef, sizeof(contents), NULL, NULL); + ok(status == STATUS_ACCESS_VIOLATION, "expected STATUS_ACCESS_VIOLATION, got %#x\n", status); + ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status); + ok(iob.Information == -1, "expected -1, got %lu\n", iob.Information); + ok(is_signaled(event), "event is not signaled\n"); + U(iob).Status = -1; iob.Information = -1; status = pNtWriteFile(hfile, 0, NULL, NULL, &iob, contents, 7, NULL, NULL); @@ -4321,7 +4399,78 @@ static void test_read_write(void) off = SetFilePointer(hfile, 0, NULL, FILE_CURRENT); ok(off == 0, "expected 0, got %u\n", off); + CloseHandle(event); + CloseHandle(hfile); +} + +static void test_ioctl(void) +{ + HANDLE event = CreateEventA(NULL, TRUE, FALSE, NULL); + IO_STATUS_BLOCK iosb; + HANDLE file; + NTSTATUS status; + + file = create_temp_file(FILE_FLAG_OVERLAPPED); + ok(file != INVALID_HANDLE_VALUE, "could not create temp file\n"); + + SetEvent(event); + status = pNtFsControlFile(file, event, NULL, NULL, &iosb, 0xdeadbeef, 0, 0, 0, 0); + todo_wine + ok(status == STATUS_INVALID_DEVICE_REQUEST, "NtFsControlFile returned %x\n", status); + ok(!is_signaled(event), "event is signaled\n"); + + status = pNtFsControlFile(file, (HANDLE)0xdeadbeef, NULL, NULL, &iosb, 0xdeadbeef, 0, 0, 0, 0); + ok(status == STATUS_INVALID_HANDLE, "NtFsControlFile returned %x\n", status); + + CloseHandle(event); + CloseHandle(file); +} + +static void test_flush_buffers_file(void) +{ + char path[MAX_PATH], buffer[MAX_PATH]; + HANDLE hfile, hfileread; + NTSTATUS status; + IO_STATUS_BLOCK io_status_block; + + GetTempPathA(MAX_PATH, path); + GetTempFileNameA(path, "foo", 0, buffer); + hfile = CreateFileA(buffer, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL, 0); + ok(hfile != INVALID_HANDLE_VALUE, "failed to create temp file.\n" ); + + hfileread = CreateFileA(buffer, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, + OPEN_EXISTING, 0, NULL); + ok(hfileread != INVALID_HANDLE_VALUE, "could not open temp file, error %d.\n", GetLastError()); + + status = pNtFlushBuffersFile(hfile, NULL); + todo_wine + ok(status == STATUS_ACCESS_VIOLATION, "expected STATUS_ACCESS_VIOLATION, got %#x.\n", status); + + status = pNtFlushBuffersFile(hfile, (IO_STATUS_BLOCK *)0xdeadbeaf); + todo_wine + ok(status == STATUS_ACCESS_VIOLATION, "expected STATUS_ACCESS_VIOLATION, got %#x.\n", status); + + status = pNtFlushBuffersFile(hfile, &io_status_block); + ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %#x.\n", status); + + status = pNtFlushBuffersFile(hfileread, &io_status_block); + ok(status == STATUS_ACCESS_DENIED, "expected STATUS_ACCESS_DENIED, got %#x.\n", status); + + status = pNtFlushBuffersFile(NULL, &io_status_block); + ok(status == STATUS_INVALID_HANDLE, "expected STATUS_INVALID_HANDLE, got %#x.\n", status); + + CloseHandle(hfileread); CloseHandle(hfile); + hfile = CreateFileA(buffer, FILE_APPEND_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, + OPEN_EXISTING, 0, NULL); + ok(hfile != INVALID_HANDLE_VALUE, "could not open temp file, error %d.\n", GetLastError()); + + status = pNtFlushBuffersFile(hfile, &io_status_block); + ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %#x.\n", status); + + CloseHandle(hfile); + DeleteFileA(buffer); } static void test_query_ea(void) @@ -4601,6 +4750,7 @@ START_TEST(file) pNtCancelIoFile = (void *)GetProcAddress(hntdll, "NtCancelIoFile"); pNtCancelIoFileEx = (void *)GetProcAddress(hntdll, "NtCancelIoFileEx"); pNtClose = (void *)GetProcAddress(hntdll, "NtClose"); + pNtFsControlFile = (void *)GetProcAddress(hntdll, "NtFsControlFile"); pNtCreateIoCompletion = (void *)GetProcAddress(hntdll, "NtCreateIoCompletion"); pNtOpenIoCompletion = (void *)GetProcAddress(hntdll, "NtOpenIoCompletion"); pNtQueryIoCompletion = (void *)GetProcAddress(hntdll, "NtQueryIoCompletion"); @@ -4611,6 +4761,7 @@ START_TEST(file) pNtQueryDirectoryFile = (void *)GetProcAddress(hntdll, "NtQueryDirectoryFile"); pNtQueryVolumeInformationFile = (void *)GetProcAddress(hntdll, "NtQueryVolumeInformationFile"); pNtQueryFullAttributesFile = (void *)GetProcAddress(hntdll, "NtQueryFullAttributesFile"); + pNtFlushBuffersFile = (void *)GetProcAddress(hntdll, "NtFlushBuffersFile"); pNtQueryEaFile = (void *)GetProcAddress(hntdll, "NtQueryEaFile"); test_read_write(); @@ -4632,8 +4783,13 @@ START_TEST(file) test_file_rename_information(); test_file_link_information(); test_file_disposition_information(); + test_file_completion_information(); + test_file_id_information(); + test_file_access_information(); test_query_volume_information_file(); test_query_attribute_information_file(); + test_ioctl(); + test_flush_buffers_file(); test_query_ea(); test_junction_points(); } diff --git a/modules/rostests/winetests/ntdll/info.c b/modules/rostests/winetests/ntdll/info.c index c0e2b1ac5d..d03d26c0b9 100755 --- a/modules/rostests/winetests/ntdll/info.c +++ b/modules/rostests/winetests/ntdll/info.c @@ -22,7 +22,9 @@ #include <winnls.h> #include <stdio.h> +static NTSTATUS (WINAPI * pRtlDowncaseUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN); static NTSTATUS (WINAPI * pNtQuerySystemInformation)(SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG); +static NTSTATUS (WINAPI * pNtQuerySystemInformationEx)(SYSTEM_INFORMATION_CLASS, void*, ULONG, void*, ULONG, ULONG*); static NTSTATUS (WINAPI * pNtPowerInformation)(POWER_INFORMATION_LEVEL, PVOID, ULONG, PVOID, ULONG); static NTSTATUS (WINAPI * pNtQueryInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG); static NTSTATUS (WINAPI * pNtQueryInformationThread)(HANDLE, THREADINFOCLASS, PVOID, ULONG, PULONG); @@ -36,6 +38,7 @@ static NTSTATUS (WINAPI * pNtUnmapViewOfSection)(HANDLE,PVOID); static NTSTATUS (WINAPI * pNtClose)(HANDLE); static ULONG (WINAPI * pNtGetCurrentProcessorNumber)(void); static BOOL (WINAPI * pIsWow64Process)(HANDLE, PBOOL); +static BOOL (WINAPI * pGetLogicalProcessorInformationEx)(LOGICAL_PROCESSOR_RELATIONSHIP,SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*,DWORD*); static BOOL is_wow64; @@ -56,12 +59,15 @@ static BOOL InitFunctionPtrs(void) { /* All needed functions are NT based, so using GetModuleHandle is a good check */ HMODULE hntdll = GetModuleHandleA("ntdll"); + HMODULE hkernel32 = GetModuleHandleA("kernel32"); + if (!hntdll) { win_skip("Not running on NT\n"); return FALSE; } + NTDLL_GET_PROC(RtlDowncaseUnicodeString); NTDLL_GET_PROC(NtQuerySystemInformation); NTDLL_GET_PROC(NtPowerInformation); NTDLL_GET_PROC(NtQueryInformationProcess); @@ -78,8 +84,16 @@ static BOOL InitFunctionPtrs(void) /* not present before XP */ pNtGetCurrentProcessorNumber = (void *) GetProcAddress(hntdll, "NtGetCurrentProcessorNumber"); - pIsWow64Process = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsWow64Process"); + pIsWow64Process = (void *)GetProcAddress(hkernel32, "IsWow64Process"); if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) is_wow64 = FALSE; + + /* starting with Win7 */ + pNtQuerySystemInformationEx = (void *) GetProcAddress(hntdll, "NtQuerySystemInformationEx"); + if (!pNtQuerySystemInformationEx) + win_skip("NtQuerySystemInformationEx() is not supported, some tests will be skipped.\n"); + + pGetLogicalProcessorInformationEx = (void *) GetProcAddress(hkernel32, "GetLogicalProcessorInformationEx"); + return TRUE; } @@ -288,7 +302,7 @@ static void test_query_process(void) /* test ReturnLength */ ReturnLength = 0; status = pNtQuerySystemInformation(SystemProcessInformation, NULL, 0, &ReturnLength); - ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_LENGTH_MISMATCH got %08x\n", status); + ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH got %08x\n", status); ok( ReturnLength > 0 || broken(ReturnLength == 0) /* NT4, Win2K */, "Expected a ReturnLength to show the needed length\n"); @@ -474,13 +488,15 @@ static void test_query_module(void) static void test_query_handle(void) { NTSTATUS status; - ULONG ReturnLength; + ULONG ExpectedLength, ReturnLength; ULONG SystemInformationLength = sizeof(SYSTEM_HANDLE_INFORMATION); SYSTEM_HANDLE_INFORMATION* shi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength); - HANDLE event_handle; + HANDLE EventHandle; + BOOL found; + INT i; - event_handle = CreateEventA(NULL, FALSE, FALSE, NULL); - ok( event_handle != NULL, "CreateEventA failed %u\n", GetLastError() ); + EventHandle = CreateEventA(NULL, FALSE, FALSE, NULL); + ok( EventHandle != NULL, "CreateEventA failed %u\n", GetLastError() ); /* Request the needed length : a SystemInformationLength greater than one struct sets ReturnLength */ ReturnLength = 0xdeadbeef; @@ -490,34 +506,116 @@ static void test_query_handle(void) SystemInformationLength = ReturnLength; shi = HeapReAlloc(GetProcessHeap(), 0, shi , SystemInformationLength); + memset(shi, 0x55, SystemInformationLength); ReturnLength = 0xdeadbeef; status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength); - if (status != STATUS_INFO_LENGTH_MISMATCH) /* vista */ + while (status == STATUS_INFO_LENGTH_MISMATCH) /* Vista / 2008 */ { - ULONG ExpectedLength = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION, Handle[shi->Count]); - unsigned int i; - BOOL found = FALSE; + SystemInformationLength *= 2; + shi = HeapReAlloc(GetProcessHeap(), 0, shi, SystemInformationLength); + memset(shi, 0x55, SystemInformationLength); + status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength); + } + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status ); + ExpectedLength = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION, Handle[shi->Count]); + ok( ReturnLength == ExpectedLength || broken(ReturnLength == ExpectedLength - sizeof(DWORD)), /* Vista / 2008 */ + "Expected length %u, got %u\n", ExpectedLength, ReturnLength ); + ok( shi->Count > 1, "Expected more than 1 handle, got %u\n", shi->Count ); + ok( shi->Handle[1].HandleValue != 0x5555 || broken( shi->Handle[1].HandleValue == 0x5555 ), /* Vista / 2008 */ + "Uninitialized second handle\n" ); + if (shi->Handle[1].HandleValue == 0x5555) + { + win_skip("Skipping broken SYSTEM_HANDLE_INFORMATION\n"); + CloseHandle(EventHandle); + goto done; + } + + for (i = 0, found = FALSE; i < shi->Count && !found; i++) + found = (shi->Handle[i].OwnerPid == GetCurrentProcessId()) && + ((HANDLE)(ULONG_PTR)shi->Handle[i].HandleValue == EventHandle); + ok( found, "Expected to find event handle %p (pid %x) in handle list\n", EventHandle, GetCurrentProcessId() ); - ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status ); - ok( ReturnLength == ExpectedLength, "Expected length %u, got %u\n", ExpectedLength, ReturnLength ); - ok( shi->Count > 1, "Expected more than 1 handles, got %u\n", shi->Count ); + if (!found) for (i = 0; i < shi->Count; i++) - { - if (shi->Handle[i].OwnerPid == GetCurrentProcessId() && - (HANDLE)(ULONG_PTR)shi->Handle[i].HandleValue == event_handle) - { - found = TRUE; - break; - } - } - ok( found, "Expected to find event handle in handle list\n" ); + trace( "%d: handle %x pid %x\n", i, shi->Handle[i].HandleValue, shi->Handle[i].OwnerPid ); + + CloseHandle(EventHandle); + + ReturnLength = 0xdeadbeef; + status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength); + while (status == STATUS_INFO_LENGTH_MISMATCH) /* Vista / 2008 */ + { + SystemInformationLength *= 2; + shi = HeapReAlloc(GetProcessHeap(), 0, shi, SystemInformationLength); + status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength); } + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status ); + for (i = 0, found = FALSE; i < shi->Count && !found; i++) + found = (shi->Handle[i].OwnerPid == GetCurrentProcessId()) && + ((HANDLE)(ULONG_PTR)shi->Handle[i].HandleValue == EventHandle); + ok( !found, "Unexpectedly found event handle in handle list\n" ); status = pNtQuerySystemInformation(SystemHandleInformation, NULL, SystemInformationLength, &ReturnLength); ok( status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %08x\n", status ); - CloseHandle(event_handle); +done: + HeapFree( GetProcessHeap(), 0, shi); +} + +static void test_query_handle_ex(void) +{ + NTSTATUS status; + ULONG ExpectedLength, ReturnLength; + ULONG SystemInformationLength = sizeof(SYSTEM_HANDLE_INFORMATION_EX); + SYSTEM_HANDLE_INFORMATION_EX* shi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength); + HANDLE EventHandle; + BOOL found; + INT i; + + EventHandle = CreateEventA(NULL, FALSE, FALSE, NULL); + ok( EventHandle != NULL, "CreateEventA failed %u\n", GetLastError() ); + + ReturnLength = 0xdeadbeef; + status = pNtQuerySystemInformation(SystemExtendedHandleInformation, shi, SystemInformationLength, &ReturnLength); + ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status); + ok( ReturnLength != 0xdeadbeef, "Expected valid ReturnLength\n" ); + + SystemInformationLength = ReturnLength; + shi = HeapReAlloc(GetProcessHeap(), 0, shi , SystemInformationLength); + memset(shi, 0x55, SystemInformationLength); + + ReturnLength = 0xdeadbeef; + status = pNtQuerySystemInformation(SystemExtendedHandleInformation, shi, SystemInformationLength, &ReturnLength); + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status ); + ExpectedLength = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION_EX, Handle[shi->Count]); + ok( ReturnLength == ExpectedLength, "Expected length %u, got %u\n", ExpectedLength, ReturnLength ); + ok( shi->Count > 1, "Expected more than 1 handle, got %u\n", (DWORD)shi->Count ); + + for (i = 0, found = FALSE; i < shi->Count && !found; i++) + found = (shi->Handle[i].UniqueProcessId == GetCurrentProcessId()) && + ((HANDLE)(ULONG_PTR)shi->Handle[i].HandleValue == EventHandle); + ok( found, "Expected to find event handle %p (pid %x) in handle list\n", EventHandle, GetCurrentProcessId() ); + + if (!found) + { + for (i = 0; i < shi->Count; i++) + trace( "%d: handle %x pid %x\n", i, (DWORD)shi->Handle[i].HandleValue, (DWORD)shi->Handle[i].UniqueProcessId ); + } + + CloseHandle(EventHandle); + + ReturnLength = 0xdeadbeef; + status = pNtQuerySystemInformation(SystemExtendedHandleInformation, shi, SystemInformationLength, &ReturnLength); + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status ); + for (i = 0, found = FALSE; i < shi->Count && !found; i++) + found = (shi->Handle[i].UniqueProcessId == GetCurrentProcessId()) && + ((HANDLE)(ULONG_PTR)shi->Handle[i].HandleValue == EventHandle); + ok( !found, "Unexpectedly found event handle in handle list\n" ); + + status = pNtQuerySystemInformation(SystemExtendedHandleInformation, NULL, SystemInformationLength, &ReturnLength); + ok( status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %08x\n", status ); + HeapFree( GetProcessHeap(), 0, shi); } @@ -684,6 +782,110 @@ static void test_query_logicalproc(void) HeapFree(GetProcessHeap(), 0, slpi); } +static void test_query_logicalprocex(void) +{ + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *infoex, *infoex2; + DWORD relationship, len2, len; + NTSTATUS status; + BOOL ret; + + if (!pNtQuerySystemInformationEx) + return; + + len = 0; + relationship = RelationProcessorCore; + status = pNtQuerySystemInformationEx(SystemLogicalProcessorInformationEx, &relationship, sizeof(relationship), NULL, 0, &len); + ok(status == STATUS_INFO_LENGTH_MISMATCH, "got 0x%08x\n", status); + ok(len > 0, "got %u\n", len); + + len = 0; + relationship = RelationAll; + status = pNtQuerySystemInformationEx(SystemLogicalProcessorInformationEx, &relationship, sizeof(relationship), NULL, 0, &len); + ok(status == STATUS_INFO_LENGTH_MISMATCH, "got 0x%08x\n", status); + ok(len > 0, "got %u\n", len); + + len2 = 0; + ret = pGetLogicalProcessorInformationEx(RelationAll, NULL, &len2); + ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %d, error %d\n", ret, GetLastError()); + ok(len == len2, "got %u, expected %u\n", len2, len); + + if (len && len == len2) { + int j, i; + + infoex = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); + infoex2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); + + status = pNtQuerySystemInformationEx(SystemLogicalProcessorInformationEx, &relationship, sizeof(relationship), infoex, len, &len); + ok(status == STATUS_SUCCESS, "got 0x%08x\n", status); + + ret = pGetLogicalProcessorInformationEx(RelationAll, infoex2, &len2); + ok(ret, "got %d, error %d\n", ret, GetLastError()); + ok(!memcmp(infoex, infoex2, len), "returned info data mismatch\n"); + + for(i = 0; status == STATUS_SUCCESS && i < len; ){ + SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *ex = (void*)(((char *)infoex) + i); + + ok(ex->Relationship >= RelationProcessorCore && ex->Relationship <= RelationGroup, + "Got invalid relationship value: 0x%x\n", ex->Relationship); + if (!ex->Size) + { + ok(0, "got infoex[%u].Size=0\n", i); + break; + } + + trace("infoex[%u].Size: %u\n", i, ex->Size); + switch(ex->Relationship){ + case RelationProcessorCore: + case RelationProcessorPackage: + trace("infoex[%u].Relationship: 0x%x (Core == 0x0 or Package == 0x3)\n", i, ex->Relationship); + trace("infoex[%u].Processor.Flags: 0x%x\n", i, ex->Processor.Flags); +#ifndef __REACTOS__ + trace("infoex[%u].Processor.EfficiencyClass: 0x%x\n", i, ex->Processor.EfficiencyClass); +#endif + trace("infoex[%u].Processor.GroupCount: 0x%x\n", i, ex->Processor.GroupCount); + for(j = 0; j < ex->Processor.GroupCount; ++j){ + trace("infoex[%u].Processor.GroupMask[%u].Mask: 0x%lx\n", i, j, ex->Processor.GroupMask[j].Mask); + trace("infoex[%u].Processor.GroupMask[%u].Group: 0x%x\n", i, j, ex->Processor.GroupMask[j].Group); + } + break; + case RelationNumaNode: + trace("infoex[%u].Relationship: 0x%x (NumaNode)\n", i, ex->Relationship); + trace("infoex[%u].NumaNode.NodeNumber: 0x%x\n", i, ex->NumaNode.NodeNumber); + trace("infoex[%u].NumaNode.GroupMask.Mask: 0x%lx\n", i, ex->NumaNode.GroupMask.Mask); + trace("infoex[%u].NumaNode.GroupMask.Group: 0x%x\n", i, ex->NumaNode.GroupMask.Group); + break; + case RelationCache: + trace("infoex[%u].Relationship: 0x%x (Cache)\n", i, ex->Relationship); + trace("infoex[%u].Cache.Level: 0x%x\n", i, ex->Cache.Level); + trace("infoex[%u].Cache.Associativity: 0x%x\n", i, ex->Cache.Associativity); + trace("infoex[%u].Cache.LineSize: 0x%x\n", i, ex->Cache.LineSize); + trace("infoex[%u].Cache.CacheSize: 0x%x\n", i, ex->Cache.CacheSize); + trace("infoex[%u].Cache.Type: 0x%x\n", i, ex->Cache.Type); + trace("infoex[%u].Cache.GroupMask.Mask: 0x%lx\n", i, ex->Cache.GroupMask.Mask); + trace("infoex[%u].Cache.GroupMask.Group: 0x%x\n", i, ex->Cache.GroupMask.Group); + break; + case RelationGroup: + trace("infoex[%u].Relationship: 0x%x (Group)\n", i, ex->Relationship); + trace("infoex[%u].Group.MaximumGroupCount: 0x%x\n", i, ex->Group.MaximumGroupCount); + trace("infoex[%u].Group.ActiveGroupCount: 0x%x\n", i, ex->Group.ActiveGroupCount); + for(j = 0; j < ex->Group.ActiveGroupCount; ++j){ + trace("infoex[%u].Group.GroupInfo[%u].MaximumProcessorCount: 0x%x\n", i, j, ex->Group.GroupInfo[j].MaximumProcessorCount); + trace("infoex[%u].Group.GroupInfo[%u].ActiveProcessorCount: 0x%x\n", i, j, ex->Group.GroupInfo[j].ActiveProcessorCount); + trace("infoex[%u].Group.GroupInfo[%u].ActiveProcessorMask: 0x%lx\n", i, j, ex->Group.GroupInfo[j].ActiveProcessorMask); + } + break; + default: + break; + } + + i += ex->Size; + } + + HeapFree(GetProcessHeap(), 0, infoex); + HeapFree(GetProcessHeap(), 0, infoex2); + } +} + static void test_query_processor_power_info(void) { NTSTATUS status; @@ -904,12 +1106,32 @@ static void test_query_process_basic(void) ok( pbi.UniqueProcessId > 0, "Expected a ProcessID > 0, got 0\n"); } +static void dump_vm_counters(const char *header, const VM_COUNTERS *pvi) +{ + trace("%s:\n", header); + trace("PeakVirtualSize : %lu\n", pvi->PeakVirtualSize); + trace("VirtualSize : %lu\n", pvi->VirtualSize); + trace("PageFaultCount : %u\n", pvi->PageFaultCount); + trace("PeakWorkingSetSize : %lu\n", pvi->PeakWorkingSetSize); + trace("WorkingSetSize : %lu\n", pvi->WorkingSetSize); + trace("QuotaPeakPagedPoolUsage : %lu\n", pvi->QuotaPeakPagedPoolUsage); + trace("QuotaPagedPoolUsage : %lu\n", pvi->QuotaPagedPoolUsage); + trace("QuotaPeakNonPagePoolUsage : %lu\n", pvi->QuotaPeakNonPagedPoolUsage); + trace("QuotaNonPagePoolUsage : %lu\n", pvi->QuotaNonPagedPoolUsage); + trace("PagefileUsage : %lu\n", pvi->PagefileUsage); + trace("PeakPagefileUsage : %lu\n", pvi->PeakPagefileUsage); +} + static void test_query_process_vm(void) { NTSTATUS status; ULONG ReturnLength; VM_COUNTERS pvi; ULONG old_size = FIELD_OFFSET(VM_COUNTERS,PrivatePageCount); + HANDLE process; + SIZE_T prev_size; + const SIZE_T alloc_size = 16 * 1024 * 1024; + void *ptr; status = pNtQueryInformationProcess(NULL, ProcessVmCounters, NULL, sizeof(pvi), NULL); ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE, @@ -935,11 +1157,72 @@ static void test_query_process_vm(void) ok( ReturnLength == old_size || ReturnLength == sizeof(pvi), "Inconsistent length %d\n", ReturnLength); /* Check if we have some return values */ - trace("WorkingSetSize : %ld\n", pvi.WorkingSetSize); - todo_wine - { - ok( pvi.WorkingSetSize > 0, "Expected a WorkingSetSize > 0\n"); - } + dump_vm_counters("VM counters for GetCurrentProcess", &pvi); + ok( pvi.WorkingSetSize > 0, "Expected a WorkingSetSize > 0\n"); + ok( pvi.PagefileUsage > 0, "Expected a PagefileUsage > 0\n"); + + process = OpenProcess(PROCESS_VM_READ, FALSE, GetCurrentProcessId()); + status = pNtQueryInformationProcess(process, ProcessVmCounters, &pvi, sizeof(pvi), NULL); + ok( status == STATUS_ACCESS_DENIED, "Expected STATUS_ACCESS_DENIED, got %08x\n", status); + CloseHandle(process); + + process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, GetCurrentProcessId()); + status = pNtQueryInformationProcess(process, ProcessVmCounters, &pvi, sizeof(pvi), NULL); + ok( status == STATUS_SUCCESS || broken(!process) /* XP */, "Expected STATUS_SUCCESS, got %08x\n", status); + CloseHandle(process); + + memset(&pvi, 0, sizeof(pvi)); + process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId()); + status = pNtQueryInformationProcess(process, ProcessVmCounters, &pvi, sizeof(pvi), NULL); + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); + + /* Check if we have some return values */ + dump_vm_counters("VM counters for GetCurrentProcessId", &pvi); + ok( pvi.WorkingSetSize > 0, "Expected a WorkingSetSize > 0\n"); + ok( pvi.PagefileUsage > 0, "Expected a PagefileUsage > 0\n"); + + CloseHandle(process); + + /* Check if we have real counters */ + status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL); + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); + prev_size = pvi.VirtualSize; + if (winetest_debug > 1) + dump_vm_counters("VM counters before VirtualAlloc", &pvi); + ptr = VirtualAlloc(NULL, alloc_size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); + ok( ptr != NULL, "VirtualAlloc failed, err %u\n", GetLastError()); + status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL); + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); + if (winetest_debug > 1) + dump_vm_counters("VM counters after VirtualAlloc", &pvi); + todo_wine ok( pvi.VirtualSize >= prev_size + alloc_size, + "Expected to be greater than %lu, got %lu\n", prev_size + alloc_size, pvi.VirtualSize); + VirtualFree( ptr, 0, MEM_RELEASE); + + status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL); + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); + prev_size = pvi.VirtualSize; + if (winetest_debug > 1) + dump_vm_counters("VM counters before VirtualAlloc", &pvi); + ptr = VirtualAlloc(NULL, alloc_size, MEM_RESERVE, PAGE_READWRITE); + ok( ptr != NULL, "VirtualAlloc failed, err %u\n", GetLastError()); + status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL); + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); + if (winetest_debug > 1) + dump_vm_counters("VM counters after VirtualAlloc(MEM_RESERVE)", &pvi); + todo_wine ok( pvi.VirtualSize >= prev_size + alloc_size, + "Expected to be greater than %lu, got %lu\n", prev_size + alloc_size, pvi.VirtualSize); + prev_size = pvi.VirtualSize; + + ptr = VirtualAlloc(ptr, alloc_size, MEM_COMMIT, PAGE_READWRITE); + ok( ptr != NULL, "VirtualAlloc failed, err %u\n", GetLastError()); + status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL); + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); + if (winetest_debug > 1) + dump_vm_counters("VM counters after VirtualAlloc(MEM_COMMIT)", &pvi); + ok( pvi.VirtualSize == prev_size, + "Expected to equal to %lu, got %lu\n", prev_size, pvi.VirtualSize); + VirtualFree( ptr, 0, MEM_RELEASE); } static void test_query_process_io(void) @@ -975,7 +1258,7 @@ static void test_query_process_io(void) ok( sizeof(pii) == ReturnLength, "Inconsistent length %d\n", ReturnLength); /* Check if we have some return values */ - trace("OtherOperationCount : 0x%x%08x\n", (DWORD)(pii.OtherOperationCount >> 32), (DWORD)pii.OtherOperationCount); + trace("OtherOperationCount : 0x%s\n", wine_dbgstr_longlong(pii.OtherOperationCount)); todo_wine { ok( pii.OtherOperationCount > 0, "Expected an OtherOperationCount > 0\n"); @@ -1070,7 +1353,7 @@ static void test_query_process_debug_port(int argc, char **argv) status = pNtQueryInformationProcess(NULL, ProcessDebugPort, &debug_port, sizeof(debug_port), NULL); - ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_ACCESS_VIOLATION, got %#x.\n", status); + ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %#x.\n", status); status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort, &debug_port, sizeof(debug_port) - 1, NULL); @@ -1111,6 +1394,40 @@ static void test_query_process_debug_port(int argc, char **argv) ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError()); } +static void test_query_process_priority(void) +{ + PROCESS_PRIORITY_CLASS priority[2]; + ULONG ReturnLength; + DWORD orig_priority; + NTSTATUS status; + BOOL ret; + + status = pNtQueryInformationProcess(NULL, ProcessPriorityClass, NULL, sizeof(priority[0]), NULL); + ok(status == STATUS_ACCESS_VIOLATION || broken(status == STATUS_INVALID_HANDLE) /* w2k3 */, + "Expected STATUS_ACCESS_VIOLATION, got %08x\n", status); + + status = pNtQueryInformationProcess(NULL, ProcessPriorityClass, &priority, sizeof(priority[0]), NULL); + ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status); + + status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessPriorityClass, &priority, 1, &ReturnLength); + ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status); + + status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessPriorityClass, &priority, sizeof(priority), &ReturnLength); + ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status); + + orig_priority = GetPriorityClass(GetCurrentProcess()); + ret = SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS); + ok(ret, "Failed to set priority class: %u\n", GetLastError()); + + status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessPriorityClass, &priority, sizeof(priority[0]), &ReturnLength); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); + ok(priority[0].PriorityClass == PROCESS_PRIOCLASS_BELOW_NORMAL, + "Expected PROCESS_PRIOCLASS_BELOW_NORMAL, got %u\n", priority[0].PriorityClass); + + ret = SetPriorityClass(GetCurrentProcess(), orig_priority); + ok(ret, "Failed to reset priority class: %u\n", GetLastError()); +} + static void test_query_process_handlecount(void) { NTSTATUS status; @@ -1293,27 +1610,27 @@ static void test_query_process_debug_object_handle(int argc, char **argv) static void test_query_process_debug_flags(int argc, char **argv) { + static const DWORD test_flags[] = { DEBUG_PROCESS, + DEBUG_ONLY_THIS_PROCESS, + DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS, + CREATE_SUSPENDED }; DWORD debug_flags = 0xdeadbeef; char cmdline[MAX_PATH]; PROCESS_INFORMATION pi; STARTUPINFOA si = { 0 }; NTSTATUS status; + DEBUG_EVENT ev; + DWORD result; BOOL ret; + int i, j; - sprintf(cmdline, "%s %s %s", argv[0], argv[1], "debuggee"); - - si.cb = sizeof(si); - ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS, NULL, NULL, &si, &pi); - ok(ret, "CreateProcess failed, last error %#x.\n", GetLastError()); - if (!ret) return; + /* test invalid arguments */ + status = pNtQueryInformationProcess(NULL, ProcessDebugFlags, NULL, 0, NULL); + ok(status == STATUS_INFO_LENGTH_MISMATCH || broken(status == STATUS_INVALID_INFO_CLASS) /* WOW64 */, + "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status); - status = pNtQueryInformationProcess(NULL, ProcessDebugFlags, - NULL, 0, NULL); - ok(status == STATUS_INFO_LENGTH_MISMATCH || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status); - - status = pNtQueryInformationProcess(NULL, ProcessDebugFlags, - NULL, sizeof(debug_flags), NULL); - ok(status == STATUS_INVALID_HANDLE || status == STATUS_ACCESS_VIOLATION || broken(status == STATUS_INVALID_INFO_CLASS) /* W7PROX64 (32-bit) */, + status = pNtQueryInformationProcess(NULL, ProcessDebugFlags, NULL, sizeof(debug_flags), NULL); + ok(status == STATUS_INVALID_HANDLE || status == STATUS_ACCESS_VIOLATION || broken(status == STATUS_INVALID_INFO_CLASS) /* WOW64 */, "Expected STATUS_INVALID_HANDLE, got %#x.\n", status); status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags, @@ -1322,45 +1639,123 @@ static void test_query_process_debug_flags(int argc, char **argv) status = pNtQueryInformationProcess(NULL, ProcessDebugFlags, &debug_flags, sizeof(debug_flags), NULL); - ok(status == STATUS_INVALID_HANDLE || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected STATUS_ACCESS_VIOLATION, got %#x.\n", status); + ok(status == STATUS_INVALID_HANDLE || broken(status == STATUS_INVALID_INFO_CLASS) /* WOW64 */, + "Expected STATUS_INVALID_HANDLE, got %#x.\n", status); status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags, &debug_flags, sizeof(debug_flags) - 1, NULL); - ok(status == STATUS_INFO_LENGTH_MISMATCH || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status); + ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status); status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags, &debug_flags, sizeof(debug_flags) + 1, NULL); - ok(status == STATUS_INFO_LENGTH_MISMATCH || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status); + ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status); + /* test ProcessDebugFlags of current process */ status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags, &debug_flags, sizeof(debug_flags), NULL); - ok(!status || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "NtQueryInformationProcess failed, status %#x.\n", status); - ok(debug_flags == TRUE|| broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected flag TRUE, got %x.\n", debug_flags); - - status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags, - &debug_flags, sizeof(debug_flags), NULL); - ok(!status || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "NtQueryInformationProcess failed, status %#x.\n", status); - ok(debug_flags == FALSE || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected flag FALSE, got %x.\n", debug_flags); + ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status); + ok(debug_flags == TRUE, "Expected flag TRUE, got %x.\n", debug_flags); - for (;;) + for (i = 0; i < sizeof(test_flags)/sizeof(test_flags[0]); i++) { - DEBUG_EVENT ev; + DWORD expected_flags = !(test_flags[i] & DEBUG_ONLY_THIS_PROCESS); + sprintf(cmdline, "%s %s %s", argv[0], argv[1], "debuggee"); - ret = WaitForDebugEvent(&ev, INFINITE); - ok(ret, "WaitForDebugEvent failed, last error %#x.\n", GetLastError()); - if (!ret) break; + si.cb = sizeof(si); + ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, test_flags[i], NULL, NULL, &si, &pi); + ok(ret, "CreateProcess failed, last error %#x.\n", GetLastError()); - if (ev.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) break; + if (!(test_flags[i] & (DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS))) + { + /* test ProcessDebugFlags before attaching with debugger */ + status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags, + &debug_flags, sizeof(debug_flags), NULL); + ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status); + ok(debug_flags == TRUE, "Expected flag TRUE, got %x.\n", debug_flags); + + ret = DebugActiveProcess(pi.dwProcessId); + ok(ret, "DebugActiveProcess failed, last error %#x.\n", GetLastError()); + expected_flags = FALSE; + } - ret = ContinueDebugEvent(ev.dwProcessId, ev.dwThreadId, DBG_CONTINUE); - ok(ret, "ContinueDebugEvent failed, last error %#x.\n", GetLastError()); - if (!ret) break; - } + /* test ProcessDebugFlags after attaching with debugger */ + status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags, + &debug_flags, sizeof(debug_flags), NULL); + ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status); + ok(debug_flags == expected_flags, "Expected flag %x, got %x.\n", expected_flags, debug_flags); - ret = CloseHandle(pi.hThread); - ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError()); - ret = CloseHandle(pi.hProcess); - ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError()); + if (!(test_flags[i] & CREATE_SUSPENDED)) + { + /* Continue a couple of times to make sure the process is fully initialized, + * otherwise Windows XP deadlocks in the following DebugActiveProcess(). */ + for (;;) + { + ret = WaitForDebugEvent(&ev, 1000); + ok(ret, "WaitForDebugEvent failed, last error %#x.\n", GetLastError()); + if (!ret) break; + + if (ev.dwDebugEventCode == LOAD_DLL_DEBUG_EVENT) break; + + ret = ContinueDebugEvent(ev.dwProcessId, ev.dwThreadId, DBG_CONTINUE); + ok(ret, "ContinueDebugEvent failed, last error %#x.\n", GetLastError()); + if (!ret) break; + } + + result = SuspendThread(pi.hThread); + ok(result == 0, "Expected 0, got %u.\n", result); + } + + ret = DebugActiveProcessStop(pi.dwProcessId); + ok(ret, "DebugActiveProcessStop failed, last error %#x.\n", GetLastError()); + + /* test ProcessDebugFlags after detaching debugger */ + status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags, + &debug_flags, sizeof(debug_flags), NULL); + ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status); + ok(debug_flags == expected_flags, "Expected flag %x, got %x.\n", expected_flags, debug_flags); + + ret = DebugActiveProcess(pi.dwProcessId); + ok(ret, "DebugActiveProcess failed, last error %#x.\n", GetLastError()); + + /* test ProcessDebugFlags after re-attaching debugger */ + status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags, + &debug_flags, sizeof(debug_flags), NULL); + ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status); + ok(debug_flags == FALSE, "Expected flag FALSE, got %x.\n", debug_flags); + + result = ResumeThread(pi.hThread); + todo_wine ok(result == 2, "Expected 2, got %u.\n", result); + + /* Wait until the process is terminated. On Windows XP the process randomly + * gets stuck in a non-continuable exception, so stop after 100 iterations. + * On Windows 2003, the debugged process disappears (or stops?) without + * any EXIT_PROCESS_DEBUG_EVENT after a couple of events. */ + for (j = 0; j < 100; j++) + { + ret = WaitForDebugEvent(&ev, 1000); + ok(ret || broken(GetLastError() == ERROR_SEM_TIMEOUT), + "WaitForDebugEvent failed, last error %#x.\n", GetLastError()); + if (!ret) break; + + if (ev.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) break; + + ret = ContinueDebugEvent(ev.dwProcessId, ev.dwThreadId, DBG_CONTINUE); + ok(ret, "ContinueDebugEvent failed, last error %#x.\n", GetLastError()); + if (!ret) break; + } + ok(j < 100 || broken(j >= 100) /* Win XP */, "Expected less than 100 debug events.\n"); + + /* test ProcessDebugFlags after process has terminated */ + status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags, + &debug_flags, sizeof(debug_flags), NULL); + ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status); + ok(debug_flags == FALSE, "Expected flag FALSE, got %x.\n", debug_flags); + + ret = CloseHandle(pi.hThread); + ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError()); + ret = CloseHandle(pi.hProcess); + ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError()); + } } static void test_readvirtualmemory(void) @@ -1439,7 +1834,7 @@ static void test_mapprotection(void) status = pNtSetInformationProcess( GetCurrentProcess(), ProcessExecuteFlags, &flags, sizeof(flags) ); ok( (status == STATUS_SUCCESS) || (status == STATUS_INVALID_INFO_CLASS), "Expected STATUS_SUCCESS, got %08x\n", status); - size.u.LowPart = 0x1000; + size.u.LowPart = 0x2000; size.u.HighPart = 0; status = pNtCreateSection ( &h, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_WRITE | SECTION_MAP_EXECUTE, @@ -1453,7 +1848,7 @@ static void test_mapprotection(void) offset.u.LowPart = 0; offset.u.HighPart = 0; - count = 0x1000; + count = 0x2000; addr = NULL; status = pNtMapViewOfSection ( h, GetCurrentProcess(), &addr, 0, 0, &offset, &count, ViewShare, 0, PAGE_READWRITE); ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); @@ -1476,7 +1871,7 @@ static void test_mapprotection(void) ok( retlen == sizeof(info), "Expected STATUS_SUCCESS, got %08x\n", status); ok((info.Protect & ~PAGE_NOCACHE) == PAGE_READWRITE, "addr.Protect is not PAGE_READWRITE, but 0x%x\n", info.Protect); - status = pNtUnmapViewOfSection (GetCurrentProcess(), addr); + status = pNtUnmapViewOfSection( GetCurrentProcess(), (char *)addr + 0x1050 ); ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); pNtClose (h); @@ -1488,12 +1883,17 @@ static void test_queryvirtualmemory(void) { NTSTATUS status; SIZE_T readcount; + static const WCHAR windowsW[] = {'w','i','n','d','o','w','s'}; static const char teststring[] = "test string"; static char datatestbuf[42] = "abc"; static char rwtestbuf[42]; MEMORY_BASIC_INFORMATION mbi; char stackbuf[42]; HMODULE module; + char buffer_name[sizeof(MEMORY_SECTION_NAME) + MAX_PATH * sizeof(WCHAR)]; + MEMORY_SECTION_NAME *msn = (MEMORY_SECTION_NAME *)buffer_name; + BOOL found; + int i; module = GetModuleHandleA( "ntdll.dll" ); trace("Check flags of the PE header of NTDLL.DLL at %p\n", module); @@ -1567,6 +1967,43 @@ static void test_queryvirtualmemory(void) "mbi.Protect is 0x%x\n", mbi.Protect); } else skip( "bss is outside of module\n" ); /* this can happen on Mac OS */ + + trace("Check section name of NTDLL.DLL with invalid size\n"); + module = GetModuleHandleA( "ntdll.dll" ); + memset(msn, 0, sizeof(*msn)); + readcount = 0; + status = pNtQueryVirtualMemory(NtCurrentProcess(), module, MemorySectionName, msn, sizeof(*msn), &readcount); + ok( status == STATUS_BUFFER_OVERFLOW, "Expected STATUS_BUFFER_OVERFLOW, got %08x\n", status); + ok( readcount > 0, "Expected readcount to be > 0\n"); + + trace("Check section name of NTDLL.DLL with invalid size\n"); + module = GetModuleHandleA( "ntdll.dll" ); + memset(msn, 0, sizeof(*msn)); + readcount = 0; + status = pNtQueryVirtualMemory(NtCurrentProcess(), module, MemorySectionName, msn, sizeof(*msn) - 1, &readcount); + ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status); + ok( readcount > 0, "Expected readcount to be > 0\n"); + + trace("Check section name of NTDLL.DLL\n"); + module = GetModuleHandleA( "ntdll.dll" ); + memset(msn, 0x55, sizeof(*msn)); + memset(buffer_name, 0x77, sizeof(buffer_name)); + readcount = 0; + status = pNtQueryVirtualMemory(NtCurrentProcess(), module, MemorySectionName, msn, sizeof(buffer_name), &readcount); + ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); + ok( readcount > 0, "Expected readcount to be > 0\n"); + trace ("Section Name: %s\n", wine_dbgstr_w(msn->SectionFileName.Buffer)); + pRtlDowncaseUnicodeString( &msn->SectionFileName, &msn->SectionFileName, FALSE ); + for (found = FALSE, i = (msn->SectionFileName.Length - sizeof(windowsW)) / sizeof(WCHAR); i >= 0; i--) + found |= !memcmp( &msn->SectionFileName.Buffer[i], windowsW, sizeof(windowsW) ); + ok( found, "Section name does not contain \"Windows\"\n"); + + trace("Check section name of non mapped memory\n"); + memset(msn, 0, sizeof(*msn)); + readcount = 0; + status = pNtQueryVirtualMemory(NtCurrentProcess(), &buffer_name, MemorySectionName, msn, sizeof(buffer_name), &readcount); + ok( status == STATUS_INVALID_ADDRESS, "Expected STATUS_INVALID_ADDRESS, got %08x\n", status); + ok( readcount == 0 || broken(readcount != 0) /* wow64 */, "Expected readcount to be 0\n"); } static void test_affinity(void) @@ -1780,6 +2217,39 @@ static void test_thread_start_address(void) CloseHandle(thread); } +static void test_query_data_alignment(void) +{ + ULONG ReturnLength; + NTSTATUS status; + DWORD value; + + value = 0xdeadbeef; + status = pNtQuerySystemInformation(SystemRecommendedSharedDataAlignment, &value, sizeof(value), &ReturnLength); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status); + ok(sizeof(value) == ReturnLength, "Inconsistent length %u\n", ReturnLength); + ok(value == 64, "Expected 64, got %u\n", value); +} + +static void test_working_set_limit(void) +{ + DWORD_PTR lower = 0, upper = ~(DWORD_PTR)0; + MEMORY_BASIC_INFORMATION mbi; + SIZE_T readcount; + NTSTATUS status; + + while (lower != upper) + { + DWORD_PTR check = (lower >> 1) + (upper >> 1) + (lower & upper & 1); + status = pNtQueryVirtualMemory(NtCurrentProcess(), (void *)check, MemoryBasicInformation, + &mbi, sizeof(MEMORY_BASIC_INFORMATION), &readcount); + if (status == STATUS_INVALID_PARAMETER) upper = check; + else lower = check + 1; + } + + trace("working set limit is %p\n", (void *)upper); + ok(upper != ~(DWORD_PTR)0, "expected != ~(DWORD_PTR)0\n"); +} + START_TEST(info) { char **argv; @@ -1825,6 +2295,10 @@ START_TEST(info) trace("Starting test_query_handle()\n"); test_query_handle(); + /* 0x40 SystemHandleInformation */ + trace("Starting test_query_handle_ex()\n"); + test_query_handle_ex(); + /* 0x15 SystemCacheInformation */ trace("Starting test_query_cache()\n"); test_query_cache(); @@ -1844,6 +2318,7 @@ START_TEST(info) /* 0x49 SystemLogicalProcessorInformation */ trace("Starting test_query_logicalproc()\n"); test_query_logicalproc(); + test_query_logicalprocex(); /* NtPowerInformation */ @@ -1873,6 +2348,10 @@ START_TEST(info) trace("Starting test_process_debug_port()\n"); test_query_process_debug_port(argc, argv); + /* 0x12 ProcessPriorityClass */ + trace("Starting test_query_process_priority()\n"); + test_query_process_priority(); + /* 0x14 ProcessHandleCount */ trace("Starting test_query_process_handlecount()\n"); test_query_process_handlecount(); @@ -1911,4 +2390,10 @@ START_TEST(info) trace("Starting test_thread_start_address()\n"); test_thread_start_address(); + + trace("Starting test_query_data_alignment()\n"); + test_query_data_alignment(); + + trace("Starting test_working_set_limit()\n"); + test_working_set_limit(); } diff --git a/modules/rostests/winetests/ntdll/large_int.c b/modules/rostests/winetests/ntdll/large_int.c index f13ae882d0..4562e6768e 100755 --- a/modules/rostests/winetests/ntdll/large_int.c +++ b/modules/rostests/winetests/ntdll/large_int.c @@ -33,6 +33,8 @@ static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING); static NTSTATUS (WINAPI *pRtlInt64ToUnicodeString)(ULONGLONG, ULONG, UNICODE_STRING *); static NTSTATUS (WINAPI *pRtlLargeIntegerToChar)(ULONGLONG *, ULONG, ULONG, PCHAR); static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN); +static void (WINAPI *p_alldvrm)(LONGLONG, LONGLONG); +static void (WINAPI *p_aulldvrm)(ULONGLONG, ULONGLONG); static void InitFunctionPtrs(void) @@ -45,6 +47,8 @@ static void InitFunctionPtrs(void) pRtlInt64ToUnicodeString = (void *)GetProcAddress(hntdll, "RtlInt64ToUnicodeString"); pRtlLargeIntegerToChar = (void *)GetProcAddress(hntdll, "RtlLargeIntegerToChar"); pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString"); + p_alldvrm = (void *)GetProcAddress(hntdll, "_alldvrm"); + p_aulldvrm = (void *)GetProcAddress(hntdll, "_aulldvrm"); } /* if */ } @@ -113,10 +117,9 @@ static void test_RtlExtendedMagicDivide(void) for (i = 0; i < NB_MAGIC_DIVIDE; i++) { result = pRtlExtendedMagicDivide(magic_divide[i].a, magic_divide[i].b, magic_divide[i].shift); ok(result == magic_divide[i].result, - "call failed: RtlExtendedMagicDivide(0x%x%08x, 0x%x%08x, %d) has result 0x%x%08x, expected 0x%x%08x\n", - (DWORD)(magic_divide[i].a >> 32), (DWORD)magic_divide[i].a, (DWORD)(magic_divide[i].b >> 32), - (DWORD)magic_divide[i].b, magic_divide[i].shift, (DWORD)(result >> 32), (DWORD)result, - (DWORD)(magic_divide[i].result >> 32), (DWORD)magic_divide[i].result); + "call failed: RtlExtendedMagicDivide(0x%s, 0x%s, %d) has result 0x%s, expected 0x%s\n", + wine_dbgstr_longlong(magic_divide[i].a), wine_dbgstr_longlong(magic_divide[i].b), magic_divide[i].shift, + wine_dbgstr_longlong(result), wine_dbgstr_longlong(magic_divide[i].result)); } } @@ -332,14 +335,12 @@ static void one_RtlInt64ToUnicodeString_test(int test_num, const largeint2str_t } /* if */ } else { ok(result == largeint2str->result, - "(test %d): RtlInt64ToUnicodeString(0x%x%08x, %d, [out]) has result %x, expected: %x\n", - test_num, (DWORD)(largeint2str->value >> 32), (DWORD)largeint2str->value, - largeint2str->base, result, largeint2str->result); + "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) has result %x, expected: %x\n", + test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base, result, largeint2str->result); if (result == STATUS_SUCCESS) { ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0', - "(test %d): RtlInt64ToUnicodeString(0x%x%08x, %d, [out]) string \"%s\" is not NULL terminated\n", - test_num, (DWORD)(largeint2str->value >> 32), (DWORD)largeint2str->value, - largeint2str->base, ansi_str.Buffer); + "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) string \"%s\" is not NULL terminated\n", + test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base, ansi_str.Buffer); } /* if */ } /* if */ ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, @@ -347,12 +348,12 @@ static void one_RtlInt64ToUnicodeString_test(int test_num, const largeint2str_t test_num, (DWORD)(largeint2str->value >>32), (DWORD)largeint2str->value, largeint2str->base, ansi_str.Buffer, expected_ansi_str.Buffer); ok(unicode_string.Length == expected_unicode_string.Length, - "(test %d): RtlInt64ToUnicodeString(0x%x%08x, %d, [out]) string has Length %d, expected: %d\n", - test_num, (DWORD)(largeint2str->value >> 32), (DWORD)largeint2str->value, largeint2str->base, + "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) string has Length %d, expected: %d\n", + test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base, unicode_string.Length, expected_unicode_string.Length); ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength, - "(test %d): RtlInt64ToUnicodeString(0x%x%08x, %d, [out]) string has MaximumLength %d, expected: %d\n", - test_num, (DWORD)(largeint2str->value >> 32), (DWORD)largeint2str->value, largeint2str->base, + "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) string has MaximumLength %d, expected: %d\n", + test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base, unicode_string.MaximumLength, expected_unicode_string.MaximumLength); pRtlFreeAnsiString(&expected_ansi_str); pRtlFreeAnsiString(&ansi_str); @@ -392,12 +393,12 @@ static void one_RtlLargeIntegerToChar_test(int test_num, const largeint2str_t *l result = pRtlLargeIntegerToChar(&value, largeint2str->base, largeint2str->MaximumLength, dest_str); } /* if */ ok(result == largeint2str->result, - "(test %d): RtlLargeIntegerToChar(0x%x%08x, %d, %d, [out]) has result %x, expected: %x\n", - test_num, (DWORD)(largeint2str->value >> 32), (DWORD)largeint2str->value, largeint2str->base, + "(test %d): RtlLargeIntegerToChar(0x%s, %d, %d, [out]) has result %x, expected: %x\n", + test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base, largeint2str->MaximumLength, result, largeint2str->result); ok(memcmp(dest_str, largeint2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0, - "(test %d): RtlLargeIntegerToChar(0x%x%08x, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n", - test_num, (DWORD)(largeint2str->value >> 32), (DWORD)largeint2str->value, largeint2str->base, + "(test %d): RtlLargeIntegerToChar(0x%s, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n", + test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base, largeint2str->MaximumLength, dest_str, largeint2str->Buffer); } @@ -415,30 +416,89 @@ static void test_RtlLargeIntegerToChar(void) value = largeint2str[0].value; result = pRtlLargeIntegerToChar(&value, 20, largeint2str[0].MaximumLength, NULL); ok(result == STATUS_INVALID_PARAMETER, - "(test a): RtlLargeIntegerToChar(0x%x%08x, %d, %d, NULL) has result %x, expected: %x\n", - (DWORD)(largeint2str[0].value >> 32), (DWORD)largeint2str[0].value, 20, + "(test a): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %x, expected: %x\n", + wine_dbgstr_longlong(largeint2str[0].value), 20, largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER); result = pRtlLargeIntegerToChar(&value, 20, 0, NULL); ok(result == STATUS_INVALID_PARAMETER, - "(test b): RtlLargeIntegerToChar(0x%x%08x, %d, %d, NULL) has result %x, expected: %x\n", - (DWORD)(largeint2str[0].value >> 32), (DWORD)largeint2str[0].value, 20, + "(test b): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %x, expected: %x\n", + wine_dbgstr_longlong(largeint2str[0].value), 20, largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER); result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, 0, NULL); ok(result == STATUS_BUFFER_OVERFLOW, - "(test c): RtlLargeIntegerToChar(0x%x%08x, %d, %d, NULL) has result %x, expected: %x\n", - (DWORD)(largeint2str[0].value >> 32), (DWORD)largeint2str[0].value, - largeint2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW); + "(test c): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %x, expected: %x\n", + wine_dbgstr_longlong(largeint2str[0].value), largeint2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW); result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, largeint2str[0].MaximumLength, NULL); ok(result == STATUS_ACCESS_VIOLATION, - "(test d): RtlLargeIntegerToChar(0x%x%08x, %d, %d, NULL) has result %x, expected: %x\n", - (DWORD)(largeint2str[0].value >> 32), (DWORD)largeint2str[0].value, + "(test d): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %x, expected: %x\n", + wine_dbgstr_longlong(largeint2str[0].value), largeint2str[0].base, largeint2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION); } +#ifdef __i386__ + +#include "pshpack1.h" +struct lldvrm_thunk +{ + BYTE push_ebx; /* pushl %ebx */ + DWORD push_esp1; /* pushl 24(%esp) */ + DWORD push_esp2; /* pushl 24(%esp) */ + DWORD push_esp3; /* pushl 24(%esp) */ + DWORD push_esp4; /* pushl 24(%esp) */ + DWORD call; /* call 24(%esp) */ + WORD mov_ecx_eax; /* movl %ecx,%eax */ + WORD mov_ebx_edx; /* movl %ebx,%edx */ + BYTE pop_ebx; /* popl %ebx */ + BYTE ret; /* ret */ +}; +#include "poppack.h" + +static void test__alldvrm(void) +{ + struct lldvrm_thunk *thunk = VirtualAlloc(NULL, sizeof(*thunk), MEM_COMMIT, PAGE_EXECUTE_READWRITE); + ULONGLONG (CDECL *call_lldvrm_func)(void *func, ULONGLONG, ULONGLONG) = (void *)thunk; + ULONGLONG ret; + + memset(thunk, 0x90, sizeof(*thunk)); + thunk->push_ebx = 0x53; /* pushl %ebx */ + thunk->push_esp1 = 0x182474ff; /* pushl 24(%esp) */ + thunk->push_esp2 = 0x182474ff; /* pushl 24(%esp) */ + thunk->push_esp3 = 0x182474ff; /* pushl 24(%esp) */ + thunk->push_esp4 = 0x182474ff; /* pushl 24(%esp) */ + thunk->call = 0x182454ff; /* call 24(%esp) */ + thunk->pop_ebx = 0x5b; /* popl %ebx */ + thunk->ret = 0xc3; /* ret */ + + ret = call_lldvrm_func(p_alldvrm, 0x0123456701234567ULL, 3); + ok(ret == 0x61172255b66c77ULL, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret); + ret = call_lldvrm_func(p_alldvrm, 0x0123456701234567ULL, -3); + ok(ret == 0xff9ee8ddaa499389ULL, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret); + + ret = call_lldvrm_func(p_aulldvrm, 0x0123456701234567ULL, 3); + ok(ret == 0x61172255b66c77ULL, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret); + ret = call_lldvrm_func(p_aulldvrm, 0x0123456701234567ULL, -3); + ok(ret == 0, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret); + + thunk->mov_ecx_eax = 0xc889; + thunk->mov_ebx_edx = 0xda89; + + ret = call_lldvrm_func(p_alldvrm, 0x0123456701234567ULL, 3); + ok(ret == 2, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret); + ret = call_lldvrm_func(p_alldvrm, 0x0123456701234567ULL, -3); + ok(ret == 2, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret); + + ret = call_lldvrm_func(p_aulldvrm, 0x0123456701234567ULL, 3); + ok(ret == 2, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret); + ret = call_lldvrm_func(p_aulldvrm, 0x0123456701234567ULL, -3); + ok(ret == 0x123456701234567ULL, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret); +} +#endif /* __i386__ */ + + START_TEST(large_int) { InitFunctionPtrs(); @@ -449,4 +509,8 @@ START_TEST(large_int) test_RtlInt64ToUnicodeString(); if (pRtlLargeIntegerToChar) test_RtlLargeIntegerToChar(); + +#ifdef __i386__ + test__alldvrm(); +#endif /* __i386__ */ } diff --git a/modules/rostests/winetests/ntdll/ntdll_test.h b/modules/rostests/winetests/ntdll/ntdll_test.h index 8d88308315..84ed6a4a71 100755 --- a/modules/rostests/winetests/ntdll/ntdll_test.h +++ b/modules/rostests/winetests/ntdll/ntdll_test.h @@ -20,10 +20,6 @@ #include <stdarg.h> -#ifndef _WIN32_WINNT -#define _WIN32_WINNT 0x500 /* For NTSTATUS */ -#endif - #include "ntstatus.h" #define WIN32_NO_STATUS #include "windef.h" diff --git a/modules/rostests/winetests/ntdll/om.c b/modules/rostests/winetests/ntdll/om.c index 65e9260a1e..651db0a1ee 100644 --- a/modules/rostests/winetests/ntdll/om.c +++ b/modules/rostests/winetests/ntdll/om.c @@ -33,12 +33,25 @@ static NTSTATUS (WINAPI *pNtCreateEvent) ( PHANDLE, ACCESS_MASK, const POBJECT_A static NTSTATUS (WINAPI *pNtOpenEvent) ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES); static NTSTATUS (WINAPI *pNtPulseEvent) ( HANDLE, PULONG ); static NTSTATUS (WINAPI *pNtQueryEvent) ( HANDLE, EVENT_INFORMATION_CLASS, PVOID, ULONG, PULONG ); +static NTSTATUS (WINAPI *pNtCreateJobObject)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES ); +static NTSTATUS (WINAPI *pNtOpenJobObject)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES ); +static NTSTATUS (WINAPI *pNtCreateKey)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG, + const UNICODE_STRING *, ULONG, PULONG ); +static NTSTATUS (WINAPI *pNtOpenKey)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES ); +static NTSTATUS (WINAPI *pNtDeleteKey)( HANDLE ); +static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, + ULONG, ULONG, ULONG, PLARGE_INTEGER ); static NTSTATUS (WINAPI *pNtCreateMutant)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, BOOLEAN ); static NTSTATUS (WINAPI *pNtOpenMutant) ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES ); +static NTSTATUS (WINAPI *pNtQueryMutant) ( HANDLE, MUTANT_INFORMATION_CLASS, PVOID, ULONG, PULONG ); +static NTSTATUS (WINAPI *pNtReleaseMutant)( HANDLE, PLONG ); static NTSTATUS (WINAPI *pNtCreateSemaphore)( PHANDLE, ACCESS_MASK,const POBJECT_ATTRIBUTES,LONG,LONG ); +static NTSTATUS (WINAPI *pNtOpenSemaphore)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES ); static NTSTATUS (WINAPI *pNtCreateTimer) ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, TIMER_TYPE ); +static NTSTATUS (WINAPI *pNtOpenTimer)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES ); static NTSTATUS (WINAPI *pNtCreateSection)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, const PLARGE_INTEGER, ULONG, ULONG, HANDLE ); +static NTSTATUS (WINAPI *pNtOpenSection)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES ); static NTSTATUS (WINAPI *pNtOpenFile) ( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, ULONG, ULONG ); static NTSTATUS (WINAPI *pNtClose) ( HANDLE ); static NTSTATUS (WINAPI *pNtCreateNamedPipeFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, @@ -55,11 +68,28 @@ static NTSTATUS (WINAPI *pNtOpenKeyedEvent)( HANDLE *, ACCESS_MASK, const OBJECT static NTSTATUS (WINAPI *pNtWaitForKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * ); static NTSTATUS (WINAPI *pNtReleaseKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * ); static NTSTATUS (WINAPI *pNtCreateIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG); +static NTSTATUS (WINAPI *pNtOpenIoCompletion)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES ); +static NTSTATUS (WINAPI *pNtQuerySystemInformation)(SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG); #define KEYEDEVENT_WAIT 0x0001 #define KEYEDEVENT_WAKE 0x0002 #define KEYEDEVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x0003) +#define ROUND_UP(value, alignment) (((value) + ((alignment) - 1)) & ~((alignment)-1)) + +static LPCSTR wine_dbgstr_us( const UNICODE_STRING *us ) +{ + if (!us) return "(null)"; + return wine_dbgstr_wn(us->Buffer, us->Length / sizeof(WCHAR)); +} + +static inline int strncmpW( const WCHAR *str1, const WCHAR *str2, int n ) +{ + if (n <= 0) return 0; + while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; } + return *str1 - *str2; +} + static void test_case_sensitive (void) { static const WCHAR buffer1[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s','\\','t','e','s','t',0}; @@ -165,33 +195,34 @@ static void test_namespace_pipe(void) status == STATUS_OBJECT_NAME_INVALID, /* vista */ "NtOpenFile should have failed with STATUS_OBJECT_NAME_NOT_FOUND got(%08x)\n", status); + str.Length -= 4 * sizeof(WCHAR); + status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0); + ok(status == STATUS_SUCCESS, "NtOpenFile should have succeeded got %08x\n", status); + pNtClose( h ); + + str.Length -= sizeof(WCHAR); + status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0); + ok(status == STATUS_SUCCESS, "NtOpenFile should have succeeded got %08x\n", status); + pNtClose( h ); + pNtClose(pipe); } #define DIRECTORY_QUERY (0x0001) #define SYMBOLIC_LINK_QUERY 0x0001 -#define DIR_TEST_CREATE_FAILURE(h,e) \ - status = pNtCreateDirectoryObject(h, DIRECTORY_QUERY, &attr);\ - ok(status == e,"NtCreateDirectoryObject should have failed with %s got(%08x)\n", #e, status); -#define DIR_TEST_OPEN_FAILURE(h,e) \ - status = pNtOpenDirectoryObject(h, DIRECTORY_QUERY, &attr);\ - ok(status == e,"NtOpenDirectoryObject should have failed with %s got(%08x)\n", #e, status); -#define DIR_TEST_CREATE_OPEN_FAILURE(h,n,e) \ - pRtlCreateUnicodeStringFromAsciiz(&str, n);\ - DIR_TEST_CREATE_FAILURE(h,e) DIR_TEST_OPEN_FAILURE(h,e)\ - pRtlFreeUnicodeString(&str); - -#define DIR_TEST_CREATE_SUCCESS(h) \ - status = pNtCreateDirectoryObject(h, DIRECTORY_QUERY, &attr); \ - ok(status == STATUS_SUCCESS, "Failed to create Directory(%08x)\n", status); -#define DIR_TEST_OPEN_SUCCESS(h) \ - status = pNtOpenDirectoryObject(h, DIRECTORY_QUERY, &attr); \ - ok(status == STATUS_SUCCESS, "Failed to open Directory(%08x)\n", status); -#define DIR_TEST_CREATE_OPEN_SUCCESS(h,n) \ - pRtlCreateUnicodeStringFromAsciiz(&str, n);\ - DIR_TEST_CREATE_SUCCESS(&h) pNtClose(h); DIR_TEST_OPEN_SUCCESS(&h) pNtClose(h); \ - pRtlFreeUnicodeString(&str); +#define DIR_TEST_CREATE_OPEN(n,e) \ + do { \ + HANDLE h; \ + pRtlCreateUnicodeStringFromAsciiz(&str, n); \ + status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); \ + ok( status == e, "NtCreateDirectoryObject(%s) got %08x\n", n, status ); \ + if (!status) pNtClose( h ); \ + status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr ); \ + ok( status == e, "NtOpenDirectoryObject(%s) got %08x\n", n, status ); \ + if (!status) pNtClose( h ); \ + pRtlFreeUnicodeString(&str); \ + } while(0) static BOOL is_correct_dir( HANDLE dir, const char *name ) { @@ -216,13 +247,14 @@ static HANDLE get_base_dir(void) UNICODE_STRING str; OBJECT_ATTRIBUTES attr; HANDLE dir, h; - unsigned int i; + char name[40]; h = CreateMutexA(NULL, FALSE, objname); ok(h != 0, "CreateMutexA failed got ret=%p (%d)\n", h, GetLastError()); InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, 0, NULL); - pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Local"); + sprintf( name, "\\BaseNamedObjects\\Session\\%u", NtCurrentTeb()->Peb->SessionId ); + pRtlCreateUnicodeStringFromAsciiz(&str, name ); status = pNtOpenDirectoryObject(&dir, DIRECTORY_QUERY, &attr); pRtlFreeUnicodeString(&str); if (!status && is_correct_dir( dir, objname )) goto done; @@ -234,16 +266,6 @@ static HANDLE get_base_dir(void) if (!status && is_correct_dir( dir, objname )) goto done; if (!status) pNtClose( dir ); - for (i = 0; i < 20; i++) - { - char name[40]; - sprintf( name, "\\BaseNamedObjects\\Session\\%u", i ); - pRtlCreateUnicodeStringFromAsciiz(&str, name ); - status = pNtOpenDirectoryObject(&dir, DIRECTORY_QUERY, &attr); - pRtlFreeUnicodeString(&str); - if (!status && is_correct_dir( dir, objname )) goto done; - if (!status) pNtClose( dir ); - } dir = 0; done: @@ -262,10 +284,12 @@ static void test_name_collisions(void) InitializeObjectAttributes(&attr, &str, 0, 0, NULL); pRtlCreateUnicodeStringFromAsciiz(&str, "\\"); - DIR_TEST_CREATE_FAILURE(&h, STATUS_OBJECT_NAME_COLLISION) + status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_OBJECT_NAME_COLLISION, "NtCreateDirectoryObject got %08x\n", status ); InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, 0, NULL); - DIR_TEST_CREATE_FAILURE(&h, STATUS_OBJECT_NAME_EXISTS) + status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_OBJECT_NAME_EXISTS, "NtCreateDirectoryObject got %08x\n", status ); pNtClose(h); status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE); ok(status == STATUS_OBJECT_TYPE_MISMATCH, @@ -356,12 +380,529 @@ static void test_name_collisions(void) pNtClose(dir); } +static void test_all_kernel_objects( UINT line, OBJECT_ATTRIBUTES *attr, + NTSTATUS create_expect, NTSTATUS open_expect ) +{ + UNICODE_STRING target; + LARGE_INTEGER size; + NTSTATUS status, status2; + HANDLE ret, ret2; + + pRtlCreateUnicodeStringFromAsciiz( &target, "\\DosDevices" ); + size.QuadPart = 4096; + + status = pNtCreateMutant( &ret, GENERIC_ALL, attr, FALSE ); + ok( status == create_expect, "%u: NtCreateMutant failed %x\n", line, status ); + status2 = pNtOpenMutant( &ret2, GENERIC_ALL, attr ); + ok( status2 == open_expect, "%u: NtOpenMutant failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + status = pNtCreateSemaphore( &ret, GENERIC_ALL, attr, 1, 2 ); + ok( status == create_expect, "%u: NtCreateSemaphore failed %x\n", line, status ); + status2 = pNtOpenSemaphore( &ret2, GENERIC_ALL, attr ); + ok( status2 == open_expect, "%u: NtOpenSemaphore failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + status = pNtCreateEvent( &ret, GENERIC_ALL, attr, 1, 0 ); + ok( status == create_expect, "%u: NtCreateEvent failed %x\n", line, status ); + status2 = pNtOpenEvent( &ret2, GENERIC_ALL, attr ); + ok( status2 == open_expect, "%u: NtOpenEvent failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + status = pNtCreateKeyedEvent( &ret, GENERIC_ALL, attr, 0 ); + ok( status == create_expect, "%u: NtCreateKeyedEvent failed %x\n", line, status ); + status2 = pNtOpenKeyedEvent( &ret2, GENERIC_ALL, attr ); + ok( status2 == open_expect, "%u: NtOpenKeyedEvent failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + status = pNtCreateTimer( &ret, GENERIC_ALL, attr, NotificationTimer ); + ok( status == create_expect, "%u: NtCreateTimer failed %x\n", line, status ); + status2 = pNtOpenTimer( &ret2, GENERIC_ALL, attr ); + ok( status2 == open_expect, "%u: NtOpenTimer failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + status = pNtCreateIoCompletion( &ret, GENERIC_ALL, attr, 0 ); + ok( status == create_expect, "%u: NtCreateCompletion failed %x\n", line, status ); + status2 = pNtOpenIoCompletion( &ret2, GENERIC_ALL, attr ); + ok( status2 == open_expect, "%u: NtOpenCompletion failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + status = pNtCreateJobObject( &ret, GENERIC_ALL, attr ); + ok( status == create_expect, "%u: NtCreateJobObject failed %x\n", line, status ); + status2 = pNtOpenJobObject( &ret2, GENERIC_ALL, attr ); + ok( status2 == open_expect, "%u: NtOpenJobObject failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + status = pNtCreateDirectoryObject( &ret, GENERIC_ALL, attr ); + ok( status == create_expect, "%u: NtCreateDirectoryObject failed %x\n", line, status ); + status2 = pNtOpenDirectoryObject( &ret2, GENERIC_ALL, attr ); + ok( status2 == open_expect, "%u: NtOpenDirectoryObject failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + status = pNtCreateSymbolicLinkObject( &ret, GENERIC_ALL, attr, &target ); + ok( status == create_expect, "%u: NtCreateSymbolicLinkObject failed %x\n", line, status ); + status2 = pNtOpenSymbolicLinkObject( &ret2, GENERIC_ALL, attr ); + ok( status2 == open_expect, "%u: NtOpenSymbolicLinkObject failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + status = pNtCreateSection( &ret, SECTION_MAP_WRITE, attr, &size, PAGE_READWRITE, SEC_COMMIT, 0 ); + ok( status == create_expect, "%u: NtCreateSection failed %x\n", line, status ); + status2 = pNtOpenSection( &ret2, SECTION_MAP_WRITE, attr ); + ok( status2 == open_expect, "%u: NtOpenSection failed %x\n", line, status2 ); + if (!status) pNtClose( ret ); + if (!status2) pNtClose( ret2 ); + pRtlFreeUnicodeString( &target ); +} + +static void test_name_limits(void) +{ + static const WCHAR localW[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s','\\','L','o','c','a','l',0}; + static const WCHAR pipeW[] = {'\\','D','e','v','i','c','e','\\','N','a','m','e','d','P','i','p','e','\\'}; + static const WCHAR mailslotW[] = {'\\','D','e','v','i','c','e','\\','M','a','i','l','S','l','o','t','\\'}; + static const WCHAR registryW[] = {'\\','R','E','G','I','S','T','R','Y','\\','M','a','c','h','i','n','e','\\','S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\'}; + OBJECT_ATTRIBUTES attr, attr2, attr3; + IO_STATUS_BLOCK iosb; + LARGE_INTEGER size, timeout; + UNICODE_STRING str, str2, target; + NTSTATUS status; + HANDLE ret, ret2; + DWORD i; + + InitializeObjectAttributes( &attr, &str, 0, 0, NULL ); + InitializeObjectAttributes( &attr2, &str, 0, (HANDLE)0xdeadbeef, NULL ); + InitializeObjectAttributes( &attr3, &str, 0, 0, NULL ); + str.Buffer = HeapAlloc( GetProcessHeap(), 0, 65536 + sizeof(registryW)); + str.MaximumLength = 65534; + for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i] = 'a'; + size.QuadPart = 4096; + pRtlCreateUnicodeStringFromAsciiz( &target, "\\DosDevices" ); + + if (!(attr.RootDirectory = get_base_dir())) + { + win_skip( "couldn't find the BaseNamedObjects dir\n" ); + return; + } + + str.Length = 0; + status = pNtCreateMutant( &ret, GENERIC_ALL, &attr2, FALSE ); + ok( status == STATUS_SUCCESS, "%u: NtCreateMutant failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenMutant( &ret2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenMutant failed %x\n", str.Length, status ); + status = pNtOpenMutant( &ret2, GENERIC_ALL, &attr3 ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, + "%u: NtOpenMutant failed %x\n", str.Length, status ); + pNtClose( ret ); + status = pNtCreateSemaphore( &ret, GENERIC_ALL, &attr2, 1, 2 ); + ok( status == STATUS_SUCCESS, "%u: NtCreateSemaphore failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenSemaphore( &ret2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenSemaphore failed %x\n", str.Length, status ); + status = pNtOpenSemaphore( &ret2, GENERIC_ALL, &attr3 ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, + "%u: NtOpenSemaphore failed %x\n", str.Length, status ); + pNtClose( ret ); + status = pNtCreateEvent( &ret, GENERIC_ALL, &attr2, 1, 0 ); + ok( status == STATUS_SUCCESS, "%u: NtCreateEvent failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenEvent( &ret2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenEvent failed %x\n", str.Length, status ); + status = pNtOpenEvent( &ret2, GENERIC_ALL, &attr3 ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, + "%u: NtOpenEvent failed %x\n", str.Length, status ); + pNtClose( ret ); + status = pNtCreateKeyedEvent( &ret, GENERIC_ALL, &attr2, 0 ); + ok( status == STATUS_SUCCESS, "%u: NtCreateKeyedEvent failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenKeyedEvent( &ret2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenKeyedEvent failed %x\n", str.Length, status ); + status = pNtOpenKeyedEvent( &ret2, GENERIC_ALL, &attr3 ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, + "%u: NtOpenKeyedEvent failed %x\n", str.Length, status ); + pNtClose( ret ); + status = pNtCreateTimer( &ret, GENERIC_ALL, &attr2, NotificationTimer ); + ok( status == STATUS_SUCCESS, "%u: NtCreateTimer failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenTimer( &ret2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenTimer failed %x\n", str.Length, status ); + status = pNtOpenTimer( &ret2, GENERIC_ALL, &attr3 ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, + "%u: NtOpenTimer failed %x\n", str.Length, status ); + pNtClose( ret ); + status = pNtCreateIoCompletion( &ret, GENERIC_ALL, &attr2, 0 ); + ok( status == STATUS_SUCCESS, "%u: NtCreateCompletion failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenIoCompletion( &ret2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenCompletion failed %x\n", str.Length, status ); + status = pNtOpenIoCompletion( &ret2, GENERIC_ALL, &attr3 ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, + "%u: NtOpenCompletion failed %x\n", str.Length, status ); + pNtClose( ret ); + status = pNtCreateJobObject( &ret, GENERIC_ALL, &attr2 ); + ok( status == STATUS_SUCCESS, "%u: NtCreateJobObject failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenJobObject( &ret2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenJobObject failed %x\n", str.Length, status ); + status = pNtOpenJobObject( &ret2, GENERIC_ALL, &attr3 ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, + "%u: NtOpenJobObject failed %x\n", str.Length, status ); + pNtClose( ret ); + status = pNtCreateDirectoryObject( &ret, GENERIC_ALL, &attr2 ); + ok( status == STATUS_SUCCESS, "%u: NtCreateDirectoryObject failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenDirectoryObject( &ret2, GENERIC_ALL, &attr ); + ok( status == STATUS_SUCCESS || broken(status == STATUS_ACCESS_DENIED), /* winxp */ + "%u: NtOpenDirectoryObject failed %x\n", str.Length, status ); + if (!status) pNtClose( ret2 ); + status = pNtOpenDirectoryObject( &ret2, GENERIC_ALL, &attr3 ); + ok( status == STATUS_SUCCESS, "%u: NtOpenDirectoryObject failed %x\n", str.Length, status ); + pNtClose( ret2 ); + pNtClose( ret ); + status = pNtCreateSymbolicLinkObject( &ret, GENERIC_ALL, &attr2, &target ); + ok( status == STATUS_SUCCESS, "%u: NtCreateSymbolicLinkObject failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenSymbolicLinkObject( &ret2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenSymbolicLinkObject failed %x\n", str.Length, status ); + status = pNtOpenSymbolicLinkObject( &ret2, GENERIC_ALL, &attr3 ); + ok( status == STATUS_SUCCESS, "%u: NtOpenSymbolicLinkObject failed %x\n", str.Length, status ); + pNtClose( ret2 ); + pNtClose( ret ); + status = pNtCreateSection( &ret, SECTION_MAP_WRITE, &attr2, &size, PAGE_READWRITE, SEC_COMMIT, 0 ); + ok( status == STATUS_SUCCESS, "%u: NtCreateSection failed %x\n", str.Length, status ); + attr3.RootDirectory = ret; + status = pNtOpenSection( &ret2, SECTION_MAP_WRITE, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenSection failed %x\n", str.Length, status ); + status = pNtOpenSection( &ret2, SECTION_MAP_WRITE, &attr3 ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE, + "%u: NtOpenSection failed %x\n", str.Length, status ); + pNtClose( ret ); + + str.Length = 67; + test_all_kernel_objects( __LINE__, &attr2, STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_NAME_INVALID ); + + str.Length = 65532; + test_all_kernel_objects( __LINE__, &attr, STATUS_SUCCESS, STATUS_SUCCESS ); + + str.Length = 65534; + test_all_kernel_objects( __LINE__, &attr, STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_NAME_INVALID ); + + str.Length = 128; + for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++) + { + if (attr.Length == sizeof(attr)) + test_all_kernel_objects( __LINE__, &attr, STATUS_SUCCESS, STATUS_SUCCESS ); + else + test_all_kernel_objects( __LINE__, &attr, STATUS_INVALID_PARAMETER, STATUS_INVALID_PARAMETER ); + } + attr.Length = sizeof(attr); + + /* null attributes or ObjectName, with or without RootDirectory */ + attr3.RootDirectory = 0; + attr2.ObjectName = attr3.ObjectName = NULL; + test_all_kernel_objects( __LINE__, &attr2, STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_NAME_INVALID ); + test_all_kernel_objects( __LINE__, &attr3, STATUS_SUCCESS, STATUS_OBJECT_PATH_SYNTAX_BAD ); + + attr3.ObjectName = &str2; + pRtlInitUnicodeString( &str2, localW ); + status = pNtOpenSymbolicLinkObject( &ret, SYMBOLIC_LINK_QUERY, &attr3 ); + ok( status == STATUS_SUCCESS, "can't open BaseNamedObjects\\Local %x\n", status ); + attr3.ObjectName = &str; + attr3.RootDirectory = ret; + test_all_kernel_objects( __LINE__, &attr3, STATUS_OBJECT_TYPE_MISMATCH, STATUS_OBJECT_TYPE_MISMATCH ); + pNtClose( attr3.RootDirectory ); + + status = pNtCreateMutant( &ret, GENERIC_ALL, NULL, FALSE ); + ok( status == STATUS_SUCCESS, "NULL: NtCreateMutant failed %x\n", status ); + pNtClose( ret ); + status = pNtOpenMutant( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenMutant failed %x\n", status ); + status = pNtCreateSemaphore( &ret, GENERIC_ALL, NULL, 1, 2 ); + ok( status == STATUS_SUCCESS, "NULL: NtCreateSemaphore failed %x\n", status ); + pNtClose( ret ); + status = pNtOpenSemaphore( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenSemaphore failed %x\n", status ); + status = pNtCreateEvent( &ret, GENERIC_ALL, NULL, 1, 0 ); + ok( status == STATUS_SUCCESS, "NULL: NtCreateEvent failed %x\n", status ); + pNtClose( ret ); + status = pNtOpenEvent( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenEvent failed %x\n", status ); + status = pNtCreateKeyedEvent( &ret, GENERIC_ALL, NULL, 0 ); + ok( status == STATUS_SUCCESS, "NULL: NtCreateKeyedEvent failed %x\n", status ); + pNtClose( ret ); + status = pNtOpenKeyedEvent( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenKeyedEvent failed %x\n", status ); + status = pNtCreateTimer( &ret, GENERIC_ALL, NULL, NotificationTimer ); + ok( status == STATUS_SUCCESS, "NULL: NtCreateTimer failed %x\n", status ); + pNtClose( ret ); + status = pNtOpenTimer( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenTimer failed %x\n", status ); + status = pNtCreateIoCompletion( &ret, GENERIC_ALL, NULL, 0 ); + ok( status == STATUS_SUCCESS, "NULL: NtCreateCompletion failed %x\n", status ); + pNtClose( ret ); + status = pNtOpenIoCompletion( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenCompletion failed %x\n", status ); + status = pNtCreateJobObject( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_SUCCESS, "NULL: NtCreateJobObject failed %x\n", status ); + pNtClose( ret ); + status = pNtOpenJobObject( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenJobObject failed %x\n", status ); + status = pNtCreateDirectoryObject( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_SUCCESS, "NULL: NtCreateDirectoryObject failed %x\n", status ); + pNtClose( ret ); + status = pNtOpenDirectoryObject( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenDirectoryObject failed %x\n", status ); + status = pNtCreateSymbolicLinkObject( &ret, GENERIC_ALL, NULL, &target ); + ok( status == STATUS_ACCESS_VIOLATION || broken( status == STATUS_SUCCESS), /* winxp */ + "NULL: NtCreateSymbolicLinkObject failed %x\n", status ); + if (!status) pNtClose( ret ); + status = pNtOpenSymbolicLinkObject( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenSymbolicLinkObject failed %x\n", status ); + status = pNtCreateSection( &ret, SECTION_MAP_WRITE, NULL, &size, PAGE_READWRITE, SEC_COMMIT, 0 ); + ok( status == STATUS_SUCCESS, "NULL: NtCreateSection failed %x\n", status ); + pNtClose( ret ); + status = pNtOpenSection( &ret, SECTION_MAP_WRITE, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenSection failed %x\n", status ); + attr2.ObjectName = attr3.ObjectName = &str; + + /* named pipes */ + memcpy( str.Buffer, pipeW, sizeof(pipeW) ); + for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i + sizeof(pipeW)/sizeof(WCHAR)] = 'a'; + str.Length = 0; + attr.RootDirectory = 0; + attr.Attributes = OBJ_CASE_INSENSITIVE; + timeout.QuadPart = -10000; + status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout ); + ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status ); + status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr2, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout ); + ok( status == STATUS_INVALID_HANDLE, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status ); + str.Length = 67; + status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr2, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout ); + ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status ); + str.Length = 128; + for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++) + { + status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout ); + if (attr.Length == sizeof(attr)) + { + ok( status == STATUS_SUCCESS, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status ); + pNtClose( ret ); + } + else ok( status == STATUS_INVALID_PARAMETER, + "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status ); + } + attr.Length = sizeof(attr); + str.Length = 65532; + status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout ); + ok( status == STATUS_SUCCESS, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status ); + pNtClose( ret ); + str.Length = 65534; + status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout ); + ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status ); + attr3.RootDirectory = 0; + attr2.ObjectName = attr3.ObjectName = NULL; + status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr2, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout ); + ok( status == STATUS_OBJECT_NAME_INVALID, "NULL: NtCreateNamedPipeFile failed %x\n", status ); + status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr3, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout ); + ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NULL: NtCreateNamedPipeFile failed %x\n", status ); + status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, NULL, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtCreateNamedPipeFile failed %x\n", status ); + attr2.ObjectName = attr3.ObjectName = &str; + + /* mailslots */ + memcpy( str.Buffer, mailslotW, sizeof(mailslotW) ); + for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i + sizeof(mailslotW)/sizeof(WCHAR)] = 'a'; + str.Length = 0; + status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL ); + ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "%u: NtCreateMailslotFile failed %x\n", str.Length, status ); + status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr2, &iosb, 0, 0, 0, NULL ); + ok( status == STATUS_INVALID_HANDLE, "%u: NtCreateMailslotFile failed %x\n", str.Length, status ); + str.Length = 67; + status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr2, &iosb, 0, 0, 0, NULL ); + ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateMailslotFile failed %x\n", str.Length, status ); + str.Length = 128; + for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++) + { + status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL ); + if (attr.Length == sizeof(attr)) + { + ok( status == STATUS_SUCCESS, "%u: NtCreateMailslotFile failed %x\n", str.Length, status ); + pNtClose( ret ); + } + else ok( status == STATUS_INVALID_PARAMETER, + "%u: NtCreateMailslotFile failed %x\n", str.Length, status ); + } + attr.Length = sizeof(attr); + str.Length = 65532; + status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL ); + ok( status == STATUS_SUCCESS, "%u: NtCreateMailslotFile failed %x\n", str.Length, status ); + pNtClose( ret ); + str.Length = 65534; + status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL ); + ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateMailslotFile failed %x\n", str.Length, status ); + attr3.RootDirectory = 0; + attr2.ObjectName = attr3.ObjectName = NULL; + status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr2, &iosb, 0, 0, 0, NULL ); + ok( status == STATUS_OBJECT_NAME_INVALID, "NULL: NtCreateMailslotFile failed %x\n", status ); + status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr3, &iosb, 0, 0, 0, NULL ); + ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NULL: NtCreateMailslotFile failed %x\n", status ); + status = pNtCreateMailslotFile( &ret, GENERIC_ALL, NULL, &iosb, 0, 0, 0, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "NULL: NtCreateMailslotFile failed %x\n", status ); + attr2.ObjectName = attr3.ObjectName = &str; + + /* registry keys */ + memcpy( str.Buffer, registryW, sizeof(registryW) ); + for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i + sizeof(registryW)/sizeof(WCHAR)] = 'a'; + str.Length = 0; + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + todo_wine + ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "%u: NtCreateKey failed %x\n", str.Length, status ); + status = pNtCreateKey( &ret, GENERIC_ALL, &attr2, 0, NULL, 0, NULL ); + ok( status == STATUS_INVALID_HANDLE, "%u: NtCreateKey failed %x\n", str.Length, status ); + status = pNtOpenKey( &ret, GENERIC_ALL, &attr2 ); + ok( status == STATUS_INVALID_HANDLE, "%u: NtOpenKey failed %x\n", str.Length, status ); + str.Length = sizeof(registryW) + 250 * sizeof(WCHAR) + 1; + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + ok( status == STATUS_OBJECT_NAME_INVALID || + status == STATUS_INVALID_PARAMETER || + broken( status == STATUS_SUCCESS ), /* wow64 */ + "%u: NtCreateKey failed %x\n", str.Length, status ); + if (!status) + { + pNtDeleteKey( ret ); + pNtClose( ret ); + } + str.Length = sizeof(registryW) + 256 * sizeof(WCHAR); + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED, + "%u: NtCreateKey failed %x\n", str.Length, status ); + if (!status) + { + status = pNtOpenKey( &ret2, KEY_READ, &attr ); + ok( status == STATUS_SUCCESS, "%u: NtOpenKey failed %x\n", str.Length, status ); + pNtClose( ret2 ); + attr3.RootDirectory = ret; + str.Length = 0; + status = pNtOpenKey( &ret2, KEY_READ, &attr3 ); + ok( status == STATUS_SUCCESS, "%u: NtOpenKey failed %x\n", str.Length, status ); + pNtClose( ret2 ); + pNtDeleteKey( ret ); + pNtClose( ret ); + + str.Length = sizeof(registryW) + 256 * sizeof(WCHAR); + for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++) + { + if (attr.Length == sizeof(attr)) + { + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + ok( status == STATUS_SUCCESS, "%u: NtCreateKey failed %x\n", str.Length, status ); + status = pNtOpenKey( &ret2, KEY_READ, &attr ); + ok( status == STATUS_SUCCESS, "%u: NtOpenKey failed %x\n", str.Length, status ); + pNtClose( ret2 ); + pNtDeleteKey( ret ); + pNtClose( ret ); + } + else + { + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "%u: NtCreateKey failed %x\n", str.Length, status ); + status = pNtOpenKey( &ret2, KEY_READ, &attr ); + ok( status == STATUS_INVALID_PARAMETER, "%u: NtOpenKey failed %x\n", str.Length, status ); + } + } + attr.Length = sizeof(attr); + } + str.Length = sizeof(registryW) + 256 * sizeof(WCHAR) + 1; + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + ok( status == STATUS_OBJECT_NAME_INVALID || + status == STATUS_INVALID_PARAMETER || + broken( status == STATUS_SUCCESS ), /* win7 */ + "%u: NtCreateKey failed %x\n", str.Length, status ); + if (!status) + { + pNtDeleteKey( ret ); + pNtClose( ret ); + } + status = pNtOpenKey( &ret, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_NAME_INVALID || + status == STATUS_INVALID_PARAMETER || + broken( status == STATUS_OBJECT_NAME_NOT_FOUND ), /* wow64 */ + "%u: NtOpenKey failed %x\n", str.Length, status ); + str.Length++; + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "%u: NtCreateKey failed %x\n", str.Length, status ); + status = pNtOpenKey( &ret, GENERIC_ALL, &attr ); + todo_wine + ok( status == STATUS_INVALID_PARAMETER, "%u: NtOpenKey failed %x\n", str.Length, status ); + str.Length = 2000; + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + ok( status == STATUS_INVALID_PARAMETER, "%u: NtCreateKey failed %x\n", str.Length, status ); + status = pNtOpenKey( &ret, GENERIC_ALL, &attr ); + todo_wine + ok( status == STATUS_INVALID_PARAMETER, "%u: NtOpenKey failed %x\n", str.Length, status ); + /* some Windows versions change the error past 2050 chars, others past 4066 chars, some don't */ + str.Length = 5000; + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + ok( status == STATUS_BUFFER_OVERFLOW || + status == STATUS_BUFFER_TOO_SMALL || + status == STATUS_INVALID_PARAMETER, + "%u: NtCreateKey failed %x\n", str.Length, status ); + status = pNtOpenKey( &ret, GENERIC_ALL, &attr ); + todo_wine + ok( status == STATUS_BUFFER_OVERFLOW || + status == STATUS_BUFFER_TOO_SMALL || + status == STATUS_INVALID_PARAMETER, + "%u: NtOpenKey failed %x\n", str.Length, status ); + str.Length = 65534; + status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL ); + ok( status == STATUS_OBJECT_NAME_INVALID || + status == STATUS_BUFFER_OVERFLOW || + status == STATUS_BUFFER_TOO_SMALL, + "%u: NtCreateKey failed %x\n", str.Length, status ); + status = pNtOpenKey( &ret, GENERIC_ALL, &attr ); + todo_wine + ok( status == STATUS_OBJECT_NAME_INVALID || + status == STATUS_BUFFER_OVERFLOW || + status == STATUS_BUFFER_TOO_SMALL, + "%u: NtOpenKey failed %x\n", str.Length, status ); + attr3.RootDirectory = 0; + attr2.ObjectName = attr3.ObjectName = NULL; + status = pNtCreateKey( &ret, GENERIC_ALL, &attr2, 0, NULL, 0, NULL ); + todo_wine + ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE, + "NULL: NtCreateKey failed %x\n", status ); + status = pNtCreateKey( &ret, GENERIC_ALL, &attr3, 0, NULL, 0, NULL ); + todo_wine + ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtCreateKey failed %x\n", status ); + status = pNtCreateKey( &ret, GENERIC_ALL, NULL, 0, NULL, 0, NULL ); + ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtCreateKey failed %x\n", status ); + status = pNtOpenKey( &ret, GENERIC_ALL, &attr2 ); + ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE, + "NULL: NtOpenKey failed %x\n", status ); + status = pNtOpenKey( &ret, GENERIC_ALL, &attr3 ); + ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtOpenKey failed %x\n", status ); + status = pNtOpenKey( &ret, GENERIC_ALL, NULL ); + ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtOpenKey failed %x\n", status ); + attr2.ObjectName = attr3.ObjectName = &str; + + pRtlFreeUnicodeString( &str ); + pRtlFreeUnicodeString( &target ); +} + static void test_directory(void) { NTSTATUS status; UNICODE_STRING str; OBJECT_ATTRIBUTES attr; - HANDLE dir, dir1, h; + HANDLE dir, dir1, h, h2; BOOL is_nt4; /* No name and/or no attributes */ @@ -380,28 +921,34 @@ static void test_directory(void) "NtOpenDirectoryObject should have failed with STATUS_INVALID_PARAMETER got(%08x)\n", status); InitializeObjectAttributes(&attr, NULL, 0, 0, NULL); - DIR_TEST_CREATE_SUCCESS(&dir) - DIR_TEST_OPEN_FAILURE(&h, STATUS_OBJECT_PATH_SYNTAX_BAD) + status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); + status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenDirectoryObject got %08x\n", status ); /* Bad name */ InitializeObjectAttributes(&attr, &str, 0, 0, NULL); pRtlCreateUnicodeStringFromAsciiz(&str, ""); - DIR_TEST_CREATE_SUCCESS(&h) + status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); pNtClose(h); - DIR_TEST_OPEN_FAILURE(&h, STATUS_OBJECT_PATH_SYNTAX_BAD) + status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenDirectoryObject got %08x\n", status ); pRtlFreeUnicodeString(&str); pNtClose(dir); - DIR_TEST_CREATE_OPEN_FAILURE(&h, "BaseNamedObjects", STATUS_OBJECT_PATH_SYNTAX_BAD) - DIR_TEST_CREATE_OPEN_FAILURE(&h, "\\BaseNamedObjects\\", STATUS_OBJECT_NAME_INVALID) - DIR_TEST_CREATE_OPEN_FAILURE(&h, "\\\\BaseNamedObjects", STATUS_OBJECT_NAME_INVALID) - DIR_TEST_CREATE_OPEN_FAILURE(&h, "\\BaseNamedObjects\\\\om.c-test", STATUS_OBJECT_NAME_INVALID) - DIR_TEST_CREATE_OPEN_FAILURE(&h, "\\BaseNamedObjects\\om.c-test\\", STATUS_OBJECT_PATH_NOT_FOUND) + DIR_TEST_CREATE_OPEN( "BaseNamedObjects", STATUS_OBJECT_PATH_SYNTAX_BAD ); + DIR_TEST_CREATE_OPEN( "\\BaseNamedObjects\\", STATUS_OBJECT_NAME_INVALID ); + DIR_TEST_CREATE_OPEN( "\\\\BaseNamedObjects", STATUS_OBJECT_NAME_INVALID ); + DIR_TEST_CREATE_OPEN( "\\BaseNamedObjects\\\\om.c-test", STATUS_OBJECT_NAME_INVALID ); + DIR_TEST_CREATE_OPEN( "\\BaseNamedObjects\\om.c-test\\", STATUS_OBJECT_PATH_NOT_FOUND ); pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\om.c-test"); - DIR_TEST_CREATE_SUCCESS(&h) - DIR_TEST_OPEN_SUCCESS(&dir1) + status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); + status = pNtOpenDirectoryObject( &dir1, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status ); pRtlFreeUnicodeString(&str); pNtClose(h); pNtClose(dir1); @@ -423,9 +970,43 @@ static void test_directory(void) pRtlFreeUnicodeString(&str); InitializeObjectAttributes(&attr, &str, 0, dir, NULL); pRtlCreateUnicodeStringFromAsciiz(&str, "one more level"); - DIR_TEST_CREATE_FAILURE(&h, STATUS_OBJECT_TYPE_MISMATCH) + status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtCreateDirectoryObject got %08x\n", status ); pRtlFreeUnicodeString(&str); + pRtlCreateUnicodeStringFromAsciiz( &str, "\\BaseNamedObjects\\Local\\om.c-test" ); + InitializeObjectAttributes( &attr, &str, 0, 0, NULL ); + status = pNtCreateDirectoryObject( &dir1, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); + pRtlFreeUnicodeString( &str ); + pRtlCreateUnicodeStringFromAsciiz( &str, "om.c-test" ); + InitializeObjectAttributes( &attr, &str, 0, dir, NULL ); + status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "Failed to open directory %08x\n", status ); + if (!status) pNtClose(h); + pRtlFreeUnicodeString( &str ); + + pRtlCreateUnicodeStringFromAsciiz( &str, "om.c-event" ); + InitializeObjectAttributes( &attr, &str, 0, dir1, NULL ); + status = pNtCreateEvent( &h, GENERIC_ALL, &attr, 1, 0 ); + ok( status == STATUS_SUCCESS, "NtCreateEvent failed %x\n", status ); + status = pNtOpenEvent( &h2, GENERIC_ALL, &attr ); + ok( status == STATUS_SUCCESS, "NtOpenEvent failed %x\n", status ); + pNtClose( h2 ); + pRtlFreeUnicodeString( &str ); + pRtlCreateUnicodeStringFromAsciiz( &str, "om.c-test\\om.c-event" ); + InitializeObjectAttributes( &attr, &str, 0, dir, NULL ); + status = pNtOpenEvent( &h2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtOpenEvent failed %x\n", status ); + pRtlFreeUnicodeString( &str ); + pRtlCreateUnicodeStringFromAsciiz( &str, "\\BasedNamedObjects\\Local\\om.c-test\\om.c-event" ); + InitializeObjectAttributes( &attr, &str, 0, 0, NULL ); + status = pNtOpenEvent( &h2, GENERIC_ALL, &attr ); + ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "NtOpenEvent failed %x\n", status ); + pRtlFreeUnicodeString( &str ); + pNtClose( h ); + pNtClose( dir1 ); + str.Buffer = buffer; str.MaximumLength = sizeof(buffer); len = 0xdeadbeef; @@ -463,22 +1044,26 @@ error: pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects"); InitializeObjectAttributes(&attr, &str, 0, 0, NULL); - DIR_TEST_OPEN_SUCCESS(&dir) + status = pNtOpenDirectoryObject( &dir, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status ); pRtlFreeUnicodeString(&str); InitializeObjectAttributes(&attr, NULL, 0, dir, NULL); - DIR_TEST_OPEN_FAILURE(&h, STATUS_OBJECT_NAME_INVALID) + status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_OBJECT_NAME_INVALID, "NtOpenDirectoryObject got %08x\n", status ); InitializeObjectAttributes(&attr, &str, 0, dir, NULL); - DIR_TEST_CREATE_OPEN_SUCCESS(h, "") - DIR_TEST_CREATE_OPEN_FAILURE(&h, "\\", STATUS_OBJECT_PATH_SYNTAX_BAD) - DIR_TEST_CREATE_OPEN_FAILURE(&h, "\\om.c-test", STATUS_OBJECT_PATH_SYNTAX_BAD) - DIR_TEST_CREATE_OPEN_FAILURE(&h, "\\om.c-test\\", STATUS_OBJECT_PATH_SYNTAX_BAD) - DIR_TEST_CREATE_OPEN_FAILURE(&h, "om.c-test\\", STATUS_OBJECT_PATH_NOT_FOUND) + DIR_TEST_CREATE_OPEN( "", STATUS_SUCCESS ); + DIR_TEST_CREATE_OPEN( "\\", STATUS_OBJECT_PATH_SYNTAX_BAD ); + DIR_TEST_CREATE_OPEN( "\\om.c-test", STATUS_OBJECT_PATH_SYNTAX_BAD ); + DIR_TEST_CREATE_OPEN( "\\om.c-test\\", STATUS_OBJECT_PATH_SYNTAX_BAD ); + DIR_TEST_CREATE_OPEN( "om.c-test\\", STATUS_OBJECT_PATH_NOT_FOUND ); pRtlCreateUnicodeStringFromAsciiz(&str, "om.c-test"); - DIR_TEST_CREATE_SUCCESS(&dir1) - DIR_TEST_OPEN_SUCCESS(&h) + status = pNtCreateDirectoryObject( &dir1, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); + status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status ); pRtlFreeUnicodeString(&str); pNtClose(h); @@ -488,23 +1073,28 @@ error: /* Nested directories */ pRtlCreateUnicodeStringFromAsciiz(&str, "\\"); InitializeObjectAttributes(&attr, &str, 0, 0, NULL); - DIR_TEST_OPEN_SUCCESS(&dir) + status = pNtOpenDirectoryObject( &dir, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status ); InitializeObjectAttributes(&attr, &str, 0, dir, NULL); - DIR_TEST_OPEN_FAILURE(&h, STATUS_OBJECT_PATH_SYNTAX_BAD) + status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenDirectoryObject got %08x\n", status ); pRtlFreeUnicodeString(&str); pNtClose(dir); InitializeObjectAttributes(&attr, &str, 0, 0, NULL); pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\om.c-test"); - DIR_TEST_CREATE_SUCCESS(&dir) + status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); pRtlFreeUnicodeString(&str); pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\om.c-test\\one more level"); - DIR_TEST_CREATE_SUCCESS(&h) + status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); pRtlFreeUnicodeString(&str); pNtClose(h); InitializeObjectAttributes(&attr, &str, 0, dir, NULL); pRtlCreateUnicodeStringFromAsciiz(&str, "one more level"); - DIR_TEST_CREATE_SUCCESS(&h) + status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); pRtlFreeUnicodeString(&str); pNtClose(h); @@ -514,15 +1104,18 @@ error: { InitializeObjectAttributes(&attr, &str, 0, 0, NULL); pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Global\\om.c-test"); - DIR_TEST_CREATE_SUCCESS(&dir) + status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); pRtlFreeUnicodeString(&str); pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Local\\om.c-test\\one more level"); - DIR_TEST_CREATE_SUCCESS(&h) + status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); + ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status ); pRtlFreeUnicodeString(&str); pNtClose(h); InitializeObjectAttributes(&attr, &str, 0, dir, NULL); pRtlCreateUnicodeStringFromAsciiz(&str, "one more level"); - DIR_TEST_CREATE_SUCCESS(&dir) ... 4309 lines suppressed ...

6 years, 11 months

[reactos] 01/02: [INCLUDE/WINE] Update winternl.h. CORE-13762

by Amine Khaldi

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ab3045c504d7d36371f1d… commit ab3045c504d7d36371f1ddd3563645b83bddabce Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Sat Oct 21 14:28:54 2017 +0100 [INCLUDE/WINE] Update winternl.h. CORE-13762 --- sdk/include/reactos/wine/winternl.h | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/sdk/include/reactos/wine/winternl.h b/sdk/include/reactos/wine/winternl.h index bcdb5b651b..803256fac4 100644 --- a/sdk/include/reactos/wine/winternl.h +++ b/sdk/include/reactos/wine/winternl.h @@ -2207,6 +2207,32 @@ typedef struct _LDR_MODULE HANDLE SectionHandle; } LDR_MODULE, *PLDR_MODULE; +typedef struct _LDR_DLL_LOADED_NOTIFICATION_DATA +{ + ULONG Flags; + PCUNICODE_STRING FullDllName; + PCUNICODE_STRING BaseDllName; + PVOID DllBase; + ULONG SizeOfImage; +} LDR_DLL_LOADED_NOTIFICATION_DATA, *PLDR_DLL_LOADED_NOTIFICATION_DATA; + +typedef struct _LDR_DLL_UNLOADED_NOTIFICATION_DATA +{ + ULONG Flags; + PCUNICODE_STRING FullDllName; + PCUNICODE_STRING BaseDllName; + PVOID DllBase; + ULONG SizeOfImage; +} LDR_DLL_UNLOADED_NOTIFICATION_DATA, *PLDR_DLL_UNLOADED_NOTIFICATION_DATA; + +typedef union _LDR_DLL_NOTIFICATION_DATA +{ + LDR_DLL_LOADED_NOTIFICATION_DATA Loaded; + LDR_DLL_UNLOADED_NOTIFICATION_DATA Unloaded; +} LDR_DLL_NOTIFICATION_DATA, *PLDR_DLL_NOTIFICATION_DATA; + +typedef void (CALLBACK *PLDR_DLL_NOTIFICATION_FUNCTION)(ULONG, LDR_DLL_NOTIFICATION_DATA*, void*); + /* those defines are (some of the) regular LDR_MODULE.Flags values */ #define LDR_IMAGE_IS_DLL 0x00000004 #define LDR_LOAD_IN_PROGRESS 0x00001000 @@ -2225,6 +2251,9 @@ typedef struct _LDR_MODULE /* FIXME: to be checked */ #define MAXIMUM_FILENAME_LENGTH 256 +#define LDR_DLL_NOTIFICATION_REASON_LOADED 1 +#define LDR_DLL_NOTIFICATION_REASON_UNLOADED 2 + typedef struct _SYSTEM_MODULE { PVOID Reserved1; /* 00/00 */

6 years, 11 months

[reactos] 01/01: [REGEDIT_WINETEST] Sync with Wine Staging 2.16. CORE-13762

by Amine Khaldi

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6595983e830936ef90900… commit 6595983e830936ef9090096ae886a11abef5b2ec Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Sat Oct 21 13:57:10 2017 +0100 [REGEDIT_WINETEST] Sync with Wine Staging 2.16. CORE-13762 --- modules/rostests/winetests/regedit/regedit.c | 2548 ++++++++++++++++++++++++-- 1 file changed, 2367 insertions(+), 181 deletions(-) diff --git a/modules/rostests/winetests/regedit/regedit.c b/modules/rostests/winetests/regedit/regedit.c index d145f0b058..60f93c92c2 100644 --- a/modules/rostests/winetests/regedit/regedit.c +++ b/modules/rostests/winetests/regedit/regedit.c @@ -20,19 +20,40 @@ #include "wine/test.h" -static BOOL supports_wchar; - #define lok ok_(__FILE__,line) -#define exec_import_str(c) r_exec_import_str(__LINE__, c) -static BOOL r_exec_import_str(unsigned line, const char *file_contents) +#define run_regedit_exe(c) run_regedit_exe_(__LINE__,c) +static BOOL run_regedit_exe_(unsigned line, const char *cmd) { STARTUPINFOA si = {sizeof(STARTUPINFOA)}; PROCESS_INFORMATION pi; + DWORD ret; + char cmdline[256]; + + si.dwFlags = STARTF_USESTDHANDLES; + si.hStdInput = INVALID_HANDLE_VALUE; + si.hStdOutput = INVALID_HANDLE_VALUE; + si.hStdError = INVALID_HANDLE_VALUE; + + strcpy(cmdline, cmd); + if (!CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) + return FALSE; + + ret = WaitForSingleObject(pi.hProcess, 10000); + if (ret == WAIT_TIMEOUT) + TerminateProcess(pi.hProcess, 1); + + CloseHandle(pi.hThread); + CloseHandle(pi.hProcess); + return (ret != WAIT_TIMEOUT); +} + +#define exec_import_str(c) r_exec_import_str(__LINE__, c) +static BOOL r_exec_import_str(unsigned line, const char *file_contents) +{ HANDLE regfile; - DWORD written, dr; + DWORD written; BOOL br; - char cmd[] = "regedit /s test.reg"; regfile = CreateFileA("test.reg", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); @@ -40,62 +61,56 @@ static BOOL r_exec_import_str(unsigned line, const char *file_contents) if(regfile == INVALID_HANDLE_VALUE) return FALSE; - br = WriteFile(regfile, file_contents, strlen(file_contents), &written, - NULL); - lok(br == TRUE, "WriteFile failed: %d\n", GetLastError()); - + br = WriteFile(regfile, file_contents, strlen(file_contents), &written, NULL); + lok(br, "WriteFile failed: %u\n", GetLastError()); CloseHandle(regfile); - if(!CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) - return FALSE; - - dr = WaitForSingleObject(pi.hProcess, 10000); - if(dr == WAIT_TIMEOUT) - TerminateProcess(pi.hProcess, 1); - CloseHandle(pi.hThread); - CloseHandle(pi.hProcess); + run_regedit_exe("regedit.exe /s test.reg"); br = DeleteFileA("test.reg"); - lok(br == TRUE, "DeleteFileA failed: %d\n", GetLastError()); + lok(br, "DeleteFile failed: %u\n", GetLastError()); - return (dr != WAIT_TIMEOUT); + return br; } #define exec_import_wstr(c) r_exec_import_wstr(__LINE__, c) -static BOOL r_exec_import_wstr(unsigned line, const WCHAR *file_contents) +static BOOL r_exec_import_wstr(unsigned line, const char *file_contents) { - STARTUPINFOA si = {sizeof(STARTUPINFOA)}; - PROCESS_INFORMATION pi; + int lenA, len, memsize; + WCHAR *wstr; HANDLE regfile; - DWORD written, dr; + DWORD written; BOOL br; - char cmd[] = "regedit /s test.reg"; + + lenA = strlen(file_contents); + + len = MultiByteToWideChar(CP_UTF8, 0, file_contents, lenA, NULL, 0); + memsize = len * sizeof(WCHAR); + wstr = HeapAlloc(GetProcessHeap(), 0, memsize); + if (!wstr) return FALSE; + MultiByteToWideChar(CP_UTF8, 0, file_contents, lenA, wstr, len); regfile = CreateFileA("test.reg", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); lok(regfile != INVALID_HANDLE_VALUE, "Failed to create test.reg file\n"); - if(regfile == INVALID_HANDLE_VALUE) + if (regfile == INVALID_HANDLE_VALUE) + { + HeapFree(GetProcessHeap(), 0, wstr); return FALSE; + } - br = WriteFile(regfile, file_contents, - lstrlenW(file_contents) * sizeof(WCHAR), &written, NULL); - lok(br == TRUE, "WriteFile failed: %d\n", GetLastError()); - + br = WriteFile(regfile, wstr, memsize, &written, NULL); + lok(br, "WriteFile failed: %u\n", GetLastError()); CloseHandle(regfile); - if(!CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) - return FALSE; + HeapFree(GetProcessHeap(), 0, wstr); - dr = WaitForSingleObject(pi.hProcess, 10000); - if(dr == WAIT_TIMEOUT) - TerminateProcess(pi.hProcess, 1); - CloseHandle(pi.hThread); - CloseHandle(pi.hProcess); + run_regedit_exe("regedit.exe /s test.reg"); br = DeleteFileA("test.reg"); - lok(br == TRUE, "DeleteFileA failed: %d\n", GetLastError()); + lok(br, "DeleteFile failed: %u\n", GetLastError()); - return (dr != WAIT_TIMEOUT); + return br; } #define TODO_REG_TYPE (0x0001u) @@ -126,41 +141,41 @@ static void verify_reg_(unsigned line, HKEY hkey, const char *value, lok(memcmp(data, exp_data, size) == 0, "got wrong data\n"); } -#define verify_reg_wsz(k,n,e) r_verify_reg_wsz(__LINE__,k,n,e) -static void r_verify_reg_wsz(unsigned line, HKEY key, const char *value_name, const WCHAR *exp_value) +#define verify_reg_nonexist(k,n) r_verify_reg_nonexist(__LINE__,k,n) +static void r_verify_reg_nonexist(unsigned line, HKEY key, const char *value_name) { LONG lr; - DWORD fnd_type, fnd_len; - WCHAR fnd_value[1024], value_nameW[1024]; - MultiByteToWideChar(CP_ACP, 0, value_name, -1, value_nameW, - sizeof(value_nameW)/sizeof(value_nameW[0])); + lr = RegQueryValueExA(key, value_name, NULL, NULL, NULL, NULL); + lok(lr == ERROR_FILE_NOT_FOUND, "registry value '%s' shouldn't exist; got %d, expected 2\n", + (value_name && *value_name) ? value_name : "(Default)", lr); +} - fnd_len = sizeof(fnd_value); - lr = RegQueryValueExW(key, value_nameW, NULL, &fnd_type, (BYTE*)fnd_value, &fnd_len); - lok(lr == ERROR_SUCCESS, "RegQueryValueExW failed: %d\n", lr); - if(lr != ERROR_SUCCESS) - return; +#define verify_key(k,s) verify_key_(__LINE__,k,s) +static void verify_key_(unsigned line, HKEY key_base, const char *subkey) +{ + HKEY hkey; + LONG lr; - lok(fnd_type == REG_SZ, "Got wrong type: %d\n", fnd_type); - if(fnd_type != REG_SZ) - return; - lok(!lstrcmpW(exp_value, fnd_value), - "Strings differ: expected %s, got %s\n", - wine_dbgstr_w(exp_value), wine_dbgstr_w(fnd_value)); + lr = RegOpenKeyExA(key_base, subkey, 0, KEY_READ, &hkey); + lok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %d\n", lr); + + if (hkey) + RegCloseKey(hkey); } -#define verify_reg_nonexist(k,n) r_verify_reg_nonexist(__LINE__,k,n) -static void r_verify_reg_nonexist(unsigned line, HKEY key, const char *value_name) +#define verify_key_nonexist(k,s) verify_key_nonexist_(__LINE__,k,s) +static void verify_key_nonexist_(unsigned line, HKEY key_base, const char *subkey) { + HKEY hkey; LONG lr; - DWORD fnd_type, fnd_len; - char fnd_value[32]; - fnd_len = sizeof(fnd_value); - lr = RegQueryValueExA(key, value_name, NULL, &fnd_type, (BYTE*)fnd_value, &fnd_len); - lok(lr == ERROR_FILE_NOT_FOUND, "Reg value shouldn't exist: %s\n", - value_name); + lr = RegOpenKeyExA(key_base, subkey, 0, KEY_READ, &hkey); + lok(lr == ERROR_FILE_NOT_FOUND, "registry key '%s' shouldn't exist; got %d, expected 2\n", + subkey, lr); + + if (hkey) + RegCloseKey(hkey); } #define KEY_BASE "Software\\Wine\\regedit_test" @@ -170,25 +185,8 @@ static void test_basic_import(void) HKEY hkey, subkey; DWORD dword = 0x17, type, size; char exp_binary[] = {0xAA,0xBB,0xCC,0x11}; - WCHAR wide_test[] = {0xFEFF,'W','i','n','d','o','w','s',' ','R','e','g', - 'i','s','t','r','y',' ','E','d','i','t','o','r',' ','V','e','r','s', - 'i','o','n',' ','5','.','0','0','\n','\n', - '[','H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E', - 'R','\\','S','o','f','t','w','a','r','e','\\','W','i','n','e','\\', - 'r','e','g','e','d','i','t','_','t','e','s','t',']','\n', - '"','T','e','s','t','V','a','l','u','e','3','"','=','"',0x3041,'V','a', - 'l','u','e','"','\n',0}; - WCHAR wide_test_r[] = {0xFEFF,'W','i','n','d','o','w','s',' ','R','e','g', - 'i','s','t','r','y',' ','E','d','i','t','o','r',' ','V','e','r','s', - 'i','o','n',' ','5','.','0','0','\r','\r', - '[','H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E', - 'R','\\','S','o','f','t','w','a','r','e','\\','W','i','n','e','\\', - 'r','e','g','e','d','i','t','_','t','e','s','t',']','\r', - '"','T','e','s','t','V','a','l','u','e','5','"','=','"',0x3041,'V','a', - 'l','u','e','"','\r',0}; - WCHAR wide_exp[] = {0x3041,'V','a','l','u','e',0}; LONG lr; - char buffer[8]; + char buffer[256]; BYTE hex[8]; lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); @@ -207,22 +205,21 @@ static void test_basic_import(void) "\"TestValue2\"=\"BValue\"\r\n"); verify_reg(hkey, "TestValue2", REG_SZ, "BValue", 7, 0); - if (supports_wchar) - { - exec_import_wstr(wide_test); - verify_reg_wsz(hkey, "TestValue3", wide_exp); - - exec_import_wstr(wide_test_r); - verify_reg_wsz(hkey, "TestValue5", wide_exp); - } - else - win_skip("Some WCHAR tests skipped\n"); + exec_import_str("Windows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"TestValue3\"=\"Value\"\n"); + verify_reg(hkey, "TestValue3", REG_SZ, "Value", 6, 0); exec_import_str("REGEDIT4\r\r" "[HKEY_CURRENT_USER\\" KEY_BASE "]\r" "\"TestValue4\"=\"DValue\"\r"); verify_reg(hkey, "TestValue4", REG_SZ, "DValue", 7, 0); + exec_import_str("Windows Registry Editor Version 5.00\r\r" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\r" + "\"TestValue5\"=\"Value\"\r"); + verify_reg(hkey, "TestValue5", REG_SZ, "Value", 6, 0); + exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" "\"TestDword\"=dword:00000017\n"); @@ -240,8 +237,10 @@ static void test_basic_import(void) exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" - "\"Empty string\"=\"\"\n\n"); + "\"Empty string\"=\"\"\n" + "\"\"=\"Default registry value\"\n\n"); verify_reg(hkey, "Empty string", REG_SZ, "", 1, 0); + verify_reg(hkey, NULL, REG_SZ, "Default registry value", 23, 0); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -306,7 +305,7 @@ static void test_basic_import(void) verify_reg(hkey, "Wine9a", REG_EXPAND_SZ, "Line", 5, 0); verify_reg(hkey, "Wine9b", REG_SZ, "Value 1", 8, 0); verify_reg_nonexist(hkey, "Wine9c"); - todo_wine verify_reg(hkey, "Wine9d", REG_SZ, "Value 2", 8, 0); + verify_reg(hkey, "Wine9d", REG_SZ, "Value 2", 8, 0); verify_reg_nonexist(hkey, "Wine9e"); verify_reg_nonexist(hkey, "Wine9f"); verify_reg(hkey, "Wine9g", REG_SZ, "Value 4", 8, 0); @@ -336,9 +335,9 @@ static void test_basic_import(void) " 65,00,00,00\n"); verify_reg(hkey, "Wine10a", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); verify_reg(hkey, "Wine10b", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); - todo_wine verify_reg(hkey, "Wine10c", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); - todo_wine verify_reg(hkey, "Wine10d", REG_NONE, "V\0a\0l\0u", 8, 0); - todo_wine verify_reg(hkey, "Wine10e", REG_NONE, "V\0a\0l\0u", 8, 0); + verify_reg(hkey, "Wine10c", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); + verify_reg(hkey, "Wine10d", REG_NONE, "V\0a\0l\0u", 8, 0); + verify_reg(hkey, "Wine10e", REG_NONE, "V\0a\0l\0u", 8, 0); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -356,22 +355,22 @@ static void test_basic_import(void) " 25,00\n"); verify_reg(hkey, "Wine11a", REG_EXPAND_SZ, "%PATH%", 7, 0); verify_reg(hkey, "Wine11b", REG_EXPAND_SZ, "%PATH%", 7, 0); - todo_wine verify_reg(hkey, "Wine11c", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine11c", REG_EXPAND_SZ, "%PATH%", 7, 0); /* Wine11d */ size = sizeof(buffer); lr = RegQueryValueExA(hkey, "Wine11d", NULL, &type, (BYTE *)&buffer, &size); - todo_wine ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); - todo_wine ok(type == REG_EXPAND_SZ, "got wrong type %u, expected %u\n", type, REG_EXPAND_SZ); - todo_wine ok(size == 6 || broken(size == 5) /* WinXP */, "got wrong size %u, expected 6\n", size); - todo_wine ok(memcmp(buffer, "%PATH", size) == 0, "got wrong data\n"); + ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); + ok(type == REG_EXPAND_SZ, "got wrong type %u, expected %u\n", type, REG_EXPAND_SZ); + ok(size == 6 || broken(size == 5) /* Win2k */, "got wrong size %u, expected 6\n", size); + ok(memcmp(buffer, "%PATH", size) == 0, "got wrong data\n"); /* Wine11e */ size = sizeof(buffer); memset(buffer, '-', size); lr = RegQueryValueExA(hkey, "Wine11e", NULL, &type, (BYTE *)&buffer, &size); - todo_wine ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); - todo_wine ok(type == REG_EXPAND_SZ, "got wrong type %u, expected %u\n", type, REG_EXPAND_SZ); - todo_wine ok(size == 6 || broken(size == 5) /* WinXP */, "got wrong size %u, expected 6\n", size); - todo_wine ok(memcmp(buffer, "%PATH", size) == 0, "got wrong data\n"); + ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); + ok(type == REG_EXPAND_SZ, "got wrong type %u, expected %u\n", type, REG_EXPAND_SZ); + ok(size == 6 || broken(size == 5) /* Win2k */, "got wrong size %u, expected 6\n", size); + ok(memcmp(buffer, "%PATH", size) == 0, "got wrong data\n"); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -391,9 +390,9 @@ static void test_basic_import(void) hex[4] = 0x55; hex[5] = 0x66; hex[6] = 0x77; hex[7] = 0x88; verify_reg(hkey, "Wine12a", REG_BINARY, hex, sizeof(hex), 0); verify_reg(hkey, "Wine12b", REG_BINARY, hex, sizeof(hex), 0); - todo_wine verify_reg(hkey, "Wine12c", REG_BINARY, hex, sizeof(hex), 0); - todo_wine verify_reg(hkey, "Wine12d", REG_BINARY, hex, 6, 0); - todo_wine verify_reg(hkey, "Wine12e", REG_BINARY, hex, 6, 0); + verify_reg(hkey, "Wine12c", REG_BINARY, hex, sizeof(hex), 0); + verify_reg(hkey, "Wine12d", REG_BINARY, hex, 6, 0); + verify_reg(hkey, "Wine12e", REG_BINARY, hex, 6, 0); /* Test import with subkeys */ exec_import_str("REGEDIT4\n\n" @@ -418,6 +417,560 @@ static void test_basic_import(void) lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE "\\Subkey/2"); ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + /* Test the accepted range of the hex-based data types */ + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine13a\"=hex(0):56,61,6c,75,65,00\n" + "\"Wine13b\"=hex(10):56,61,6c,75,65,00\n" + "\"Wine13c\"=hex(100):56,61,6c,75,65,00\n" + "\"Wine13d\"=hex(1000):56,61,6c,75,65,00\n" + "\"Wine13e\"=hex(7fff):56,61,6c,75,65,00\n" + "\"Wine13f\"=hex(ffff):56,61,6c,75,65,00\n" + "\"Wine13g\"=hex(7fffffff):56,61,6c,75,65,00\n" + "\"Wine13h\"=hex(ffffffff):56,61,6c,75,65,00\n" + "\"Wine13i\"=hex(100000000):56,61,6c,75,65,00\n" + "\"Wine13j\"=hex(0x2):56,61,6c,75,65,00\n" + "\"Wine13k\"=hex(0X2):56,61,6c,75,65,00\n" + "\"Wine13l\"=hex(x2):56,61,6c,75,65,00\n\n"); + verify_reg(hkey, "Wine13a", REG_NONE, "Value", 6, 0); + verify_reg(hkey, "Wine13b", 0x10, "Value", 6, 0); + verify_reg(hkey, "Wine13c", 0x100, "Value", 6, 0); + verify_reg(hkey, "Wine13d", 0x1000, "Value", 6, 0); + verify_reg(hkey, "Wine13e", 0x7fff, "Value", 6, 0); + verify_reg(hkey, "Wine13f", 0xffff, "Value", 6, 0); + verify_reg(hkey, "Wine13g", 0x7fffffff, "Value", 6, 0); + verify_reg(hkey, "Wine13h", 0xffffffff, "Value", 6, 0); + verify_reg_nonexist(hkey, "Wine13i"); + verify_reg_nonexist(hkey, "Wine13j"); + verify_reg_nonexist(hkey, "Wine13k"); + verify_reg_nonexist(hkey, "Wine13l"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine14a\"=hex(7):4c,69,6e,65,20, \\\n" + " 63,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n" + "\"Wine14b\"=hex(7):4c,69,6e,65,20,\t\\\n" + " 63,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n\n"); + verify_reg(hkey, "Wine14a", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Wine14b", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine15\"=hex(2):25,50,41,54,48,25,00,\n\n"); + verify_reg(hkey, "Wine15", REG_EXPAND_SZ, "%PATH%", 7, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine16\"=hex(2):\\\n" + " 25,48,4f,4d,45,25,00\n\n"); + verify_reg(hkey, "Wine16", REG_EXPAND_SZ, "%HOME%", 7, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17a\"=hex(0):56,61,6c,75,65,\\"); + verify_reg(hkey, "Wine17a", REG_NONE, "Value", 5, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17b\"=hex(2):25,50,41,54,48,25,\\"); + verify_reg(hkey, "Wine17b", REG_EXPAND_SZ, "%PATH%", 7, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17c\"=hex:11,22,33,44,55,\\"); + verify_reg(hkey, "Wine17c", REG_BINARY, hex, 5, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17d\"=hex(7):4c,69,6e,65,\\"); + verify_reg(hkey, "Wine17d", REG_MULTI_SZ, "Line", 5, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17e\"=hex(100):56,61,6c,75,65,\\"); + verify_reg(hkey, "Wine17e", 0x100, "Value", 5, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine18a\"=hex(7):4c,69,6e,65,00,00\n" + "\"Wine18b\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n" + "\"Wine18c\"=hex(7):4c,69,6e,65,20,\\;comment\n" + " 63,6f,6e,63,61,74,\\\n" + " 65,6e,61,74,69,6f,6e,00,00\n" + "\"Wine18d\"=hex(7):4c,69,6e,65,20,\\;comment\n" + " 63,6f,6e,63,61,74,\n" + " 65,6e,61,74,69,6f,6e,00,00\n" + "\"Wine18e\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,6f,6e,63,61,74,;comment\n" + " 65,6e,61,74,69,6f,6e,00,00\n\n"); + verify_reg(hkey, "Wine18a", REG_MULTI_SZ, "Line\0", 6, 0); + verify_reg(hkey, "Wine18b", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Wine18c", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + /* Wine18d */ + size = sizeof(buffer); + memset(buffer, '-', size); + lr = RegQueryValueExA(hkey, "Wine18d", NULL, &type, (BYTE *)&buffer, &size); + ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); + ok(type == REG_MULTI_SZ, "got wrong type %u, expected %u\n", type, REG_MULTI_SZ); + ok(size == 12 || broken(size == 11) /* Win2k */, "got wrong size %u, expected 12\n", size); + ok(memcmp(buffer, "Line concat", size) == 0, "got wrong data\n"); + /* Wine18e */ + size = sizeof(buffer); + memset(buffer, '-', size); + lr = RegQueryValueExA(hkey, "Wine18e", NULL, &type, (BYTE *)&buffer, &size); + ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); + ok(type == REG_MULTI_SZ, "got wrong type %u, expected %u\n", type, REG_MULTI_SZ); + ok(size == 12 || broken(size == 11) /* Win2k */, "got wrong size %u, expected 12\n", size); + ok(memcmp(buffer, "Line concat", size) == 0, "got wrong data\n"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine19a\"=hex(100):25,50,41,54,48,25,00\n" + "\"Wine19b\"=hex(100):25,50,41,\\\n" + " 54,48,25,00\n" + "\"Wine19c\"=hex(100):25,50,41,\\;comment\n" + " 54,48,\\\n" + " 25,00\n" + "\"Wine19d\"=hex(100):25,50,41,\\;comment\n" + " 54,48,\n" + " 25,00\n" + "\"Wine19e\"=hex(100):25,50,41,\\;comment\n" + " 54,48,;comment\n" + " 25,00\n"); + verify_reg(hkey, "Wine19a", 0x100, "%PATH%", 7, 0); + verify_reg(hkey, "Wine19b", 0x100, "%PATH%", 7, 0); + verify_reg(hkey, "Wine19c", 0x100, "%PATH%", 7, 0); + verify_reg(hkey, "Wine19d", 0x100, "%PATH", 5, 0); + verify_reg(hkey, "Wine19e", 0x100, "%PATH", 5, 0); + + /* Test null-termination of REG_EXPAND_SZ and REG_MULTI_SZ data*/ + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine20a\"=hex(7):4c,69,6e,65\n" + "\"Wine20b\"=hex(7):4c,69,6e,65,\n" + "\"Wine20c\"=hex(7):4c,69,6e,65,00\n" + "\"Wine20d\"=hex(7):4c,69,6e,65,00,\n" + "\"Wine20e\"=hex(7):4c,69,6e,65,00,00\n" + "\"Wine20f\"=hex(7):4c,69,6e,65,00,00,\n\n"); + verify_reg(hkey, "Wine20a", REG_MULTI_SZ, "Line", 5, 0); + verify_reg(hkey, "Wine20b", REG_MULTI_SZ, "Line", 5, 0); + verify_reg(hkey, "Wine20c", REG_MULTI_SZ, "Line", 5, 0); + verify_reg(hkey, "Wine20d", REG_MULTI_SZ, "Line", 5, 0); + verify_reg(hkey, "Wine20e", REG_MULTI_SZ, "Line\0", 6, 0); + verify_reg(hkey, "Wine20f", REG_MULTI_SZ, "Line\0", 6, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine21a\"=hex(2):25,50,41,54,48,25\n" + "\"Wine21b\"=hex(2):25,50,41,54,48,25,\n" + "\"Wine21c\"=hex(2):25,50,41,54,48,25,00\n" + "\"Wine21d\"=hex(2):25,50,41,54,48,25,00,\n\n"); + verify_reg(hkey, "Wine21a", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine21b", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine21c", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine21d", REG_EXPAND_SZ, "%PATH%", 7, 0); + + RegCloseKey(hkey); + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: %d\n", lr); +} + +static void test_basic_import_unicode(void) +{ + HKEY hkey, subkey; + DWORD dword = 0x17, type, size; + char exp_binary[] = {0xAA,0xBB,0xCC,0x11}; + LONG lr; + char buffer[256]; + BYTE hex[8]; + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"TestValue\"=\"AValue\"\n"); + lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: %d\n", lr); + verify_reg(hkey, "TestValue", REG_SZ, "AValue", 7, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\r\n\r\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\r\n" + "\"TestValue2\"=\"BValue\"\r\n"); + verify_reg(hkey, "TestValue2", REG_SZ, "BValue", 7, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"TestValue3\"=\"Value\"\n"); + verify_reg(hkey, "TestValue3", REG_SZ, "Value", 6, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\r\r" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\r" + "\"TestValue4\"=\"DValue\"\r"); + verify_reg(hkey, "TestValue4", REG_SZ, "DValue", 7, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\r\r" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\r" + "\"TestValue5\"=\"Value\"\r"); + verify_reg(hkey, "TestValue5", REG_SZ, "Value", 6, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"TestDword\"=dword:00000017\n"); + verify_reg(hkey, "TestDword", REG_DWORD, &dword, sizeof(dword), 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"TestBinary\"=hex:aa,bb,cc,11\n"); + verify_reg(hkey, "TestBinary", REG_BINARY, exp_binary, sizeof(exp_binary), 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"With=Equals\"=\"asdf\"\n"); + verify_reg(hkey, "With=Equals", REG_SZ, "asdf", 5, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Empty string\"=\"\"\n" + "\"\"=\"Default registry value\"\n\n"); + verify_reg(hkey, "Empty string", REG_SZ, "", 1, 0); + verify_reg(hkey, NULL, REG_SZ, "Default registry value", 23, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Line1\"=\"Value1\"\n\n" + "\"Line2\"=\"Value2\"\n\n\n" + "\"Line3\"=\"Value3\"\n\n\n\n" + "\"Line4\"=\"Value4\"\n\n"); + verify_reg(hkey, "Line1", REG_SZ, "Value1", 7, 0); + verify_reg(hkey, "Line2", REG_SZ, "Value2", 7, 0); + verify_reg(hkey, "Line3", REG_SZ, "Value3", 7, 0); + verify_reg(hkey, "Line4", REG_SZ, "Value4", 7, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine1\"=dword:00000782\n\n" + "\"Wine2\"=\"Test Value\"\n" + "\"Wine3\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n" + "#comment\n" + "@=\"Test\"\n" + ";comment\n\n" + "\"Wine4\"=dword:12345678\n\n"); + dword = 0x782; + verify_reg(hkey, "Wine1", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg(hkey, "Wine2", REG_SZ, "Test Value", 11, 0); + verify_reg(hkey, "Wine3", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "", REG_SZ, "Test", 5, 0); + dword = 0x12345678; + verify_reg(hkey, "Wine4", REG_DWORD, &dword, sizeof(dword), 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine5\"=\"No newline\""); + verify_reg(hkey, "Wine5", REG_SZ, "No newline", 11, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine6\"=dword:00000050\n\n" + "\"Wine7\"=\"No newline\""); + dword = 0x50; + verify_reg(hkey, "Wine6", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg(hkey, "Wine7", REG_SZ, "No newline", 11, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine8a\"=dword:1\n" + "\"Wine8b\"=dword:4444\n\n"); + dword = 0x1; + verify_reg(hkey, "Wine8a", REG_DWORD, &dword, sizeof(dword), 0); + dword = 0x4444; + verify_reg(hkey, "Wine8b", REG_DWORD, &dword, sizeof(dword), 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine9a\"=hex(2):4c,00,69,00,6e,00,65,00,00,00\n" + "\"Wine9b\"=\"Value 1\"\n" + "\"Wine9c\"=hex(2):4c,00,69,00,6e,00,65,00\\\n" + "\"Wine9d\"=\"Value 2\"\n" + "\"Wine9e\"=hex(2):4c,00,69,00,6e,00,65,00,\\\n" + "\"Wine9f\"=\"Value 3\"\n" + "\"Wine9g\"=\"Value 4\"\n\n"); + verify_reg(hkey, "Wine9a", REG_EXPAND_SZ, "Line", 5, 0); + verify_reg(hkey, "Wine9b", REG_SZ, "Value 1", 8, 0); + verify_reg_nonexist(hkey, "Wine9c"); + verify_reg(hkey, "Wine9d", REG_SZ, "Value 2", 8, 0); + verify_reg_nonexist(hkey, "Wine9e"); + verify_reg_nonexist(hkey, "Wine9f"); + verify_reg(hkey, "Wine9g", REG_SZ, "Value 4", 8, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"double\\\"quote\"=\"valid \\\"or\\\" not\"\n" + "\"single'quote\"=dword:00000008\n\n"); + verify_reg(hkey, "double\"quote", REG_SZ, "valid \"or\" not", 15, 0); + dword = 0x00000008; + verify_reg(hkey, "single'quote", REG_DWORD, &dword, sizeof(dword), 0); + + /* Test hex data concatenation for REG_NONE, REG_EXPAND_SZ and REG_BINARY */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine10a\"=hex(0):56,00,61,00,6c,00,75,00,65,00,00,00\n" + "\"Wine10b\"=hex(0):56,00,61,00,6c,00,\\\n" + " 75,00,65,00,00,00\n" + "\"Wine10c\"=hex(0):56,00,61,00,\\;comment\n" + " 6c,00,75,00,\\\n" + " 65,00,00,00\n" + "\"Wine10d\"=hex(0):56,00,61,00,\\;comment\n" + " 6c,00,75,00,\n" + " 65,00,00,00\n" + "\"Wine10e\"=hex(0):56,00,61,00,\\;comment\n" + " 6c,00,75,00,;comment\n" + " 65,00,00,00\n"); + verify_reg(hkey, "Wine10a", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); + verify_reg(hkey, "Wine10b", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); + verify_reg(hkey, "Wine10c", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); + verify_reg(hkey, "Wine10d", REG_NONE, "V\0a\0l\0u", 8, 0); + verify_reg(hkey, "Wine10e", REG_NONE, "V\0a\0l\0u", 8, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine11a\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine11b\"=hex(2):25,00,50,00,41,00,\\\n" + " 54,00,48,00,25,00,00,00\n" + "\"Wine11c\"=hex(2):25,00,50,00,41,00,\\;comment\n" + " 54,00,48,00,\\\n" + " 25,00,00,00\n" + "\"Wine11d\"=hex(2):25,00,50,00,41,00,\\;comment\n" + " 54,00,48,00,\n" + " 25,00,00,00\n" + "\"Wine11e\"=hex(2):25,00,50,00,41,00,\\;comment\n" + " 54,00,48,00,;comment\n" + " 25,00,00,00\n"); + verify_reg(hkey, "Wine11a", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine11b", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine11c", REG_EXPAND_SZ, "%PATH%", 7, 0); + /* Wine11d */ + size = sizeof(buffer); + lr = RegQueryValueExA(hkey, "Wine11d", NULL, &type, (BYTE *)&buffer, &size); + ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); + ok(type == REG_EXPAND_SZ, "got wrong type %u, expected %u\n", type, REG_EXPAND_SZ); + ok(size == 6 || broken(size == 5) /* Win2k */, "got wrong size %u, expected 6\n", size); + ok(memcmp(buffer, "%PATH", size) == 0, "got wrong data\n"); + /* Wine11e */ + size = sizeof(buffer); + memset(buffer, '-', size); + lr = RegQueryValueExA(hkey, "Wine11e", NULL, &type, (BYTE *)&buffer, &size); + ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); + ok(type == REG_EXPAND_SZ, "got wrong type %u, expected %u\n", type, REG_EXPAND_SZ); + ok(size == 6 || broken(size == 5) /* Win2k */, "got wrong size %u, expected 6\n", size); + ok(memcmp(buffer, "%PATH", size) == 0, "got wrong data\n"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine12a\"=hex:11,22,33,44,55,66,77,88\n" + "\"Wine12b\"=hex:11,22,33,44,\\\n" + " 55,66,77,88\n" + "\"Wine12c\"=hex:11,22,33,44,\\;comment\n" + " 55,66,\\\n" + " 77,88\n" + "\"Wine12d\"=hex:11,22,33,44,\\;comment\n" + " 55,66,\n" + " 77,88\n" + "\"Wine12e\"=hex:11,22,33,44,\\;comment\n" + " 55,66,;comment\n" + " 77,88\n"); + hex[0] = 0x11; hex[1] = 0x22; hex[2] = 0x33; hex[3] = 0x44; + hex[4] = 0x55; hex[5] = 0x66; hex[6] = 0x77; hex[7] = 0x88; + verify_reg(hkey, "Wine12a", REG_BINARY, hex, sizeof(hex), 0); + verify_reg(hkey, "Wine12b", REG_BINARY, hex, sizeof(hex), 0); + verify_reg(hkey, "Wine12c", REG_BINARY, hex, sizeof(hex), 0); + verify_reg(hkey, "Wine12d", REG_BINARY, hex, 6, 0); + verify_reg(hkey, "Wine12e", REG_BINARY, hex, 6, 0); + + /* Test import with subkeys */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey\"1]\n" + "\"Wine\\\\31\"=\"Test value\"\n\n"); + lr = RegOpenKeyExA(hkey, "Subkey\"1", 0, KEY_READ, &subkey); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + verify_reg(subkey, "Wine\\31", REG_SZ, "Test value", 11, 0); + lr = RegCloseKey(subkey); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE "\\Subkey\"1"); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey/2]\n" + "\"123/\\\"4;'5\"=\"Random value name\"\n\n"); + lr = RegOpenKeyExA(hkey, "Subkey/2", 0, KEY_READ, &subkey); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + verify_reg(subkey, "123/\"4;'5", REG_SZ, "Random value name", 18, 0); + lr = RegCloseKey(subkey); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE "\\Subkey/2"); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + + /* Test the accepted range of the hex-based data types */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine13a\"=hex(0):56,61,6c,75,65,00\n" + "\"Wine13b\"=hex(10):56,61,6c,75,65,00\n" + "\"Wine13c\"=hex(100):56,61,6c,75,65,00\n" + "\"Wine13d\"=hex(1000):56,61,6c,75,65,00\n" + "\"Wine13e\"=hex(7fff):56,61,6c,75,65,00\n" + "\"Wine13f\"=hex(ffff):56,61,6c,75,65,00\n" + "\"Wine13g\"=hex(7fffffff):56,61,6c,75,65,00\n" + "\"Wine13h\"=hex(ffffffff):56,61,6c,75,65,00\n" + "\"Wine13i\"=hex(100000000):56,61,6c,75,65,00\n" + "\"Wine13j\"=hex(0x2):56,61,6c,75,65,00\n" + "\"Wine13k\"=hex(0X2):56,61,6c,75,65,00\n" + "\"Wine13l\"=hex(x2):56,61,6c,75,65,00\n\n"); + verify_reg(hkey, "Wine13a", REG_NONE, "Value", 6, 0); + verify_reg(hkey, "Wine13b", 0x10, "Value", 6, 0); + verify_reg(hkey, "Wine13c", 0x100, "Value", 6, 0); + verify_reg(hkey, "Wine13d", 0x1000, "Value", 6, 0); + verify_reg(hkey, "Wine13e", 0x7fff, "Value", 6, 0); + verify_reg(hkey, "Wine13f", 0xffff, "Value", 6, 0); + verify_reg(hkey, "Wine13g", 0x7fffffff, "Value", 6, 0); + verify_reg(hkey, "Wine13h", 0xffffffff, "Value", 6, 0); + verify_reg_nonexist(hkey, "Wine13i"); + verify_reg_nonexist(hkey, "Wine13j"); + verify_reg_nonexist(hkey, "Wine13k"); + verify_reg_nonexist(hkey, "Wine13l"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine14a\"=hex(7):4c,00,69,00,6e,00,65,00,20,00, \\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n" + "\"Wine14b\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\t\\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Wine14a", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Wine14b", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine15\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00,\n\n"); + verify_reg(hkey, "Wine15", REG_EXPAND_SZ, "%PATH%", 7, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine16\"=hex(2):\\\n" + " 25,00,48,00,4f,00,4d,00,45,00,25,00,00,00\n\n"); + verify_reg(hkey, "Wine16", REG_EXPAND_SZ, "%HOME%", 7, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17a\"=hex(0):56,61,6c,75,65,\\"); + verify_reg(hkey, "Wine17a", REG_NONE, "Value", 5, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17b\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,\\"); + verify_reg(hkey, "Wine17b", REG_EXPAND_SZ, "%PATH%", 7, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17c\"=hex:11,22,33,44,55,\\"); + verify_reg(hkey, "Wine17c", REG_BINARY, hex, 5, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17d\"=hex(7):4c,00,69,00,6e,00,65,00,\\"); + verify_reg(hkey, "Wine17d", REG_MULTI_SZ, "Line", 5, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine17e\"=hex(100):56,61,6c,75,65,\\"); + verify_reg(hkey, "Wine17e", 0x100, "Value", 5, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine18a\"=hex(7):4c,00,69,00,6e,00,65,00,00,00,00,00\n" + "\"Wine18b\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n" + "\"Wine18c\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\;comment\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n" + "\"Wine18d\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\;comment\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n" + "\"Wine18e\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,;comment\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Wine18a", REG_MULTI_SZ, "Line\0", 6, 0); + verify_reg(hkey, "Wine18b", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Wine18c", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + /* Wine18d */ + size = sizeof(buffer); + memset(buffer, '-', size); + lr = RegQueryValueExA(hkey, "Wine18d", NULL, &type, (BYTE *)&buffer, &size); + ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); + ok(type == REG_MULTI_SZ, "got wrong type %u, expected %u\n", type, REG_MULTI_SZ); + ok(size == 12 || broken(size == 11) /* Win2k */, "got wrong size %u, expected 12\n", size); + ok(memcmp(buffer, "Line concat", size) == 0, "got wrong data\n"); + /* Wine18e */ + size = sizeof(buffer); + memset(buffer, '-', size); + lr = RegQueryValueExA(hkey, "Wine18e", NULL, &type, (BYTE *)&buffer, &size); + ok(lr == ERROR_SUCCESS, "RegQueryValueExA failed: %d\n", lr); + ok(type == REG_MULTI_SZ, "got wrong type %u, expected %u\n", type, REG_MULTI_SZ); + ok(size == 12 || broken(size == 11) /* Win2k */, "got wrong size %u, expected 12\n", size); + ok(memcmp(buffer, "Line concat", size) == 0, "got wrong data\n"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine19a\"=hex(100):25,50,41,54,48,25,00\n" + "\"Wine19b\"=hex(100):25,50,41,\\\n" + " 54,48,25,00\n" + "\"Wine19c\"=hex(100):25,50,41,\\;comment\n" + " 54,48,\\\n" + " 25,00\n" + "\"Wine19d\"=hex(100):25,50,41,\\;comment\n" + " 54,48,\n" + " 25,00\n" + "\"Wine19e\"=hex(100):25,50,41,\\;comment\n" + " 54,48,;comment\n" + " 25,00\n"); + verify_reg(hkey, "Wine19a", 0x100, "%PATH%", 7, 0); + verify_reg(hkey, "Wine19b", 0x100, "%PATH%", 7, 0); + verify_reg(hkey, "Wine19c", 0x100, "%PATH%", 7, 0); + verify_reg(hkey, "Wine19d", 0x100, "%PATH", 5, 0); + verify_reg(hkey, "Wine19e", 0x100, "%PATH", 5, 0); + + /* Test null-termination of REG_EXPAND_SZ and REG_MULTI_SZ data*/ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine20a\"=hex(7):4c,00,69,00,6e,00,65,00\n" + "\"Wine20b\"=hex(7):4c,00,69,00,6e,00,65,00,\n" + "\"Wine20c\"=hex(7):4c,00,69,00,6e,00,65,00,00,00\n" + "\"Wine20d\"=hex(7):4c,00,69,00,6e,00,65,00,00,00,\n" + "\"Wine20e\"=hex(7):4c,00,69,00,6e,00,65,00,00,00,00,00\n" + "\"Wine20f\"=hex(7):4c,00,69,00,6e,00,65,00,00,00,00,00,\n\n"); + verify_reg(hkey, "Wine20a", REG_MULTI_SZ, "Line", 5, 0); + verify_reg(hkey, "Wine20b", REG_MULTI_SZ, "Line", 5, 0); + verify_reg(hkey, "Wine20c", REG_MULTI_SZ, "Line", 5, 0); + verify_reg(hkey, "Wine20d", REG_MULTI_SZ, "Line", 5, 0); + verify_reg(hkey, "Wine20e", REG_MULTI_SZ, "Line\0", 6, 0); + verify_reg(hkey, "Wine20f", REG_MULTI_SZ, "Line\0", 6, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine21a\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00\n" + "\"Wine21b\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,\n" + "\"Wine21c\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine21d\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00,\n\n"); + verify_reg(hkey, "Wine21a", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine21b", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine21c", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine21d", REG_EXPAND_SZ, "%PATH%", 7, 0); + RegCloseKey(hkey); lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); @@ -433,11 +986,19 @@ static void test_basic_import_31(void) ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + /* Check if regedit.exe is running with elevated privileges */ + lr = RegCreateKeyExA(HKEY_CLASSES_ROOT, KEY_BASE, 0, NULL, REG_OPTION_NON_VOLATILE, + KEY_READ, NULL, &hkey, NULL); + if (lr == ERROR_ACCESS_DENIED) + { + win_skip("regedit.exe is not running with elevated privileges; " + "skipping Windows 3.1 import tests\n"); + return; + } + /* Test simple value */ exec_import_str("REGEDIT\r\n" "HKEY_CLASSES_ROOT\\" KEY_BASE " = Value0\r\n"); - lr = RegOpenKeyExA(HKEY_CLASSES_ROOT, KEY_BASE, 0, KEY_READ, &hkey); - ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: %d\n", lr); verify_reg(hkey, "", REG_SZ, "Value0", 7, 0); /* Test proper handling of spaces and equals signs */ @@ -482,7 +1043,8 @@ static void test_basic_import_31(void) static void test_invalid_import(void) { LONG lr; - HKEY hkey, subkey; + HKEY hkey; + DWORD dword = 0x8; lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); @@ -490,7 +1052,7 @@ static void test_invalid_import(void) exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" "\"TestNoEndQuote\"=\"Asdffdsa\n"); - lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey); + lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ|KEY_SET_VALUE, &hkey); ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: %d\n", lr); verify_reg_nonexist(hkey, "TestNoEndQuote"); @@ -586,25 +1148,25 @@ static void test_invalid_import(void) "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" "\"Multi-Line1\"=hex(7):4c,69,6e,65,20\\\n" ",63,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n\n"); - todo_wine verify_reg_nonexist(hkey, "Multi-Line1"); + verify_reg_nonexist(hkey, "Multi-Line1"); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" "\"Multi-Line2\"=hex(7):4c,69,6e,65,20\\\n" " ,63,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n\n"); - todo_wine verify_reg_nonexist(hkey, "Multi-Line2"); + verify_reg_nonexist(hkey, "Multi-Line2"); exec_import_str("Windows Registry Editor Version 5.00\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" "\"Multi-Line3\"=hex(7):4c,69,6e,65,20\\\n" ",63,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n\n"); - todo_wine verify_reg_nonexist(hkey, "Multi-Line3"); + verify_reg_nonexist(hkey, "Multi-Line3"); exec_import_str("Windows Registry Editor Version 5.00\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" "\"Multi-Line4\"=hex(7):4c,69,6e,65,20\\\n" " ,63,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n\n"); - todo_wine verify_reg_nonexist(hkey, "Multi-Line4"); + verify_reg_nonexist(hkey, "Multi-Line4"); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -657,14 +1219,12 @@ static void test_invalid_import(void) exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "\\\n" "Subkey1]\n"); - lr = RegOpenKeyExA(hkey, "Subkey1", 0, KEY_READ, &subkey); - ok(lr == ERROR_FILE_NOT_FOUND, "got %d, expected 2\n", lr); + verify_key_nonexist(hkey, "Subkey1"); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "\n" "\\Subkey2]\n"); - lr = RegOpenKeyExA(hkey, "Subkey2", 0, KEY_READ, &subkey); - ok(lr == ERROR_FILE_NOT_FOUND, "got %d, expected 2\n", lr); + verify_key_nonexist(hkey, "Subkey2"); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -673,7 +1233,7 @@ static void test_invalid_import(void) "\"Test17b\"=\"Value 2\"\n" "\"Test\n" "\\17c\"=\"Value 3\"\n\n"); - todo_wine verify_reg_nonexist(hkey, "Test17a"); + verify_reg_nonexist(hkey, "Test17a"); verify_reg(hkey, "Test17b", REG_SZ, "Value 2", 8, 0); verify_reg_nonexist(hkey, "Test17c"); @@ -683,8 +1243,8 @@ static void test_invalid_import(void) "5678\n" "\"Test18b\"=\"Test \\\n" "Value\"\n\n"); - todo_wine verify_reg_nonexist(hkey, "Test18a"); - todo_wine verify_reg_nonexist(hkey, "Test18b"); + verify_reg_nonexist(hkey, "Test18a"); + verify_reg_nonexist(hkey, "Test18b"); /* Test hex data concatenation for REG_NONE, REG_EXPAND_SZ and REG_BINARY */ exec_import_str("REGEDIT4\n\n" @@ -702,11 +1262,11 @@ static void test_invalid_import(void) "\"Test19f\"=hex(0):56,00,61,00,\\;comment\n" " 6c,00,75,00,\\#comment\n" " 65,00,00,00\n\n"); - todo_wine verify_reg_nonexist(hkey, "Test19a"); - todo_wine verify_reg_nonexist(hkey, "Test19b"); - todo_wine verify_reg_nonexist(hkey, "Test19c"); - todo_wine verify_reg_nonexist(hkey, "Test19d"); - todo_wine verify_reg_nonexist(hkey, "Test19e"); + verify_reg_nonexist(hkey, "Test19a"); + verify_reg_nonexist(hkey, "Test19b"); + verify_reg_nonexist(hkey, "Test19c"); + verify_reg_nonexist(hkey, "Test19d"); + verify_reg_nonexist(hkey, "Test19e"); verify_reg_nonexist(hkey, "Test19f"); exec_import_str("REGEDIT4\n\n" @@ -724,11 +1284,11 @@ static void test_invalid_import(void) "\"Test20f\"=hex(2):25,50,41,\\;comment\n" " 54,48,\\#comment\n" " 25,00\n\n"); - todo_wine verify_reg_nonexist(hkey, "Test20a"); - todo_wine verify_reg_nonexist(hkey, "Test20b"); + verify_reg_nonexist(hkey, "Test20a"); + verify_reg_nonexist(hkey, "Test20b"); verify_reg_nonexist(hkey, "Test20c"); - todo_wine verify_reg_nonexist(hkey, "Test20d"); - todo_wine verify_reg_nonexist(hkey, "Test20e"); + verify_reg_nonexist(hkey, "Test20d"); + verify_reg_nonexist(hkey, "Test20e"); verify_reg_nonexist(hkey, "Test20f"); exec_import_str("REGEDIT4\n\n" @@ -746,61 +1306,791 @@ static void test_invalid_import(void) "\"Test21f\"=hex:11,22,33,\\;comment\n" " 44,55,66,\\#comment\n" " 77,88\n\n"); - todo_wine verify_reg_nonexist(hkey, "Test21a"); - todo_wine verify_reg_nonexist(hkey, "Test21b"); + verify_reg_nonexist(hkey, "Test21a"); + verify_reg_nonexist(hkey, "Test21b"); verify_reg_nonexist(hkey, "Test21c"); - todo_wine verify_reg_nonexist(hkey, "Test21d"); - todo_wine verify_reg_nonexist(hkey, "Test21e"); + verify_reg_nonexist(hkey, "Test21d"); + verify_reg_nonexist(hkey, "Test21e"); verify_reg_nonexist(hkey, "Test21f"); - RegCloseKey(hkey); + /* Test support for characters greater than 0xff */ + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine22a\"=hex(0):25,50,100,54,48,25,00\n" + "\"Wine22b\"=hex(0):25,1a4,100,164,124,25,00\n\n"); + verify_reg_nonexist(hkey, "Wine22a"); + verify_reg_nonexist(hkey, "Wine22b"); - lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); - ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: %d\n", lr); -} + /* Test the effect of backslashes in hex data */ + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine23a\"=hex(2):25,48\\,4f,4d,45,25,00\n" + "\"Wine23b\"=hex(2):25,48,\\4f,4d,45,25,00\n" + "\"Wine23c\"=hex(2):25,48\\ ,4f,4d,45,25,00\n" + "\"Wine23d\"=hex(2):25,48,\\ 4f,4d,45,25,00\n" + "\"Wine23e\"=hex(2):\\25,48,4f,4d,45,25,00\n" + "\"Wine23f\"=hex(2):\\ 25,48,4f,4d,45,25,00\n" + "\"Wine23g\"=hex(2):25,48,4\\f,4d,45,25,00\n" + "\"Wine23h\"=hex(2):25,48,4\\\n" + " f,4d,45,25,00\n" + "\"Wine23i\"=hex(2):25,50,\\,41,54,48,25,00\n" + "\"Wine23j\"=hex(2):25,48,4f,4d,45,25,5c,\\\\\n" + " 25,50,41,54,48,25,00\n" + "\"Wine23k\"=hex(2):,\\\n" + " 25,48,4f,4d,45,25,00\n\n"); + verify_reg_nonexist(hkey, "Wine23a"); + verify_reg_nonexist(hkey, "Wine23b"); + verify_reg_nonexist(hkey, "Wine23c"); + verify_reg_nonexist(hkey, "Wine23d"); + verify_reg_nonexist(hkey, "Wine23e"); + verify_reg_nonexist(hkey, "Wine23f"); + verify_reg_nonexist(hkey, "Wine23g"); + verify_reg_nonexist(hkey, "Wine23h"); + verify_reg_nonexist(hkey, "Wine23i"); + verify_reg_nonexist(hkey, "Wine23j"); + verify_reg_nonexist(hkey, "Wine23k"); -static void test_invalid_import_31(void) -{ - HKEY hkey; - LONG lr; + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine24a\"=hex(2):4c,69,6e,65,20,\\\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1]\n"); + verify_reg_nonexist(hkey, "Wine24a"); + verify_key_nonexist(hkey, "Subkey1"); - lr = RegCreateKeyExA(HKEY_CLASSES_ROOT, KEY_BASE, 0, NULL, REG_OPTION_NON_VOLATILE, - KEY_READ, NULL, &hkey, NULL); - ok(lr == ERROR_SUCCESS, "RegCreateKeyExA failed: %d\n", lr); + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine24b\"=hex(2):4c,69,6e,65,20\\\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2]\n"); + verify_reg_nonexist(hkey, "Wine24b"); + verify_key(hkey, "Subkey2"); - /* Test character validity at the start of the line */ - exec_import_str("REGEDIT\r\n" - " HKEY_CLASSES_ROOT\\" KEY_BASE " = Value1a\r\n"); - todo_wine verify_reg_nonexist(hkey, ""); + lr = RegDeleteKeyA(hkey, "Subkey2"); + ok(lr == ERROR_SUCCESS, "RegDeleteKey failed: %u\n", lr); - exec_import_str("REGEDIT\r\n" - " HKEY_CLASSES_ROOT\\" KEY_BASE " = Value1b\r\n"); - todo_wine verify_reg_nonexist(hkey, ""); + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine25a\"=hex(2):4c,69,6e,65,20,\\\n" + "\"Wine25b\"=\"Test value\"\n" - exec_import_str("REGEDIT\r\n" - "\tHKEY_CLASSES_ROOT\\" KEY_BASE " = Value1c\r\n"); - todo_wine verify_reg_nonexist(hkey, ""); + "\"Wine25c\"=hex(2):4c,69,6e,65,20,\\\n" + ";comment\n" + "\"Wine25d\"=\"Test value\"\n" - exec_import_str("REGEDIT\r\n" - ";HKEY_CLASSES_ROOT\\" KEY_BASE " = Value2a\r\n"); - todo_wine verify_reg_nonexist(hkey, ""); + "\"Wine25e\"=hex(2):4c,69,6e,65,20,\\\n" + "#comment\n" + "\"Wine25f\"=\"Test value\"\n" - exec_import_str("REGEDIT\r\n" + "\"Wine25g\"=hex(2):4c,69,6e,65,20,\\\n\n" + "\"Wine25h\"=\"Test value\"\n" + + "\"Wine25i\"=hex(2):4c,69,6e,65,20\\\n" + "\"Wine25j\"=\"Test value\"\n\n"); + verify_reg_nonexist(hkey, "Wine25a"); + verify_reg_nonexist(hkey, "Wine25b"); + verify_reg_nonexist(hkey, "Wine25c"); + verify_reg_nonexist(hkey, "Wine25d"); + verify_reg_nonexist(hkey, "Wine25e"); + verify_reg(hkey, "Wine25f", REG_SZ, "Test value", 11, 0); + verify_reg_nonexist(hkey, "Wine25g"); + verify_reg_nonexist(hkey, "Wine25h"); + verify_reg_nonexist(hkey, "Wine25i"); + verify_reg(hkey, "Wine25j", REG_SZ, "Test value", 11, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine26a\"=hex(2):4c,69,6e,65,20,\\\n" + "\"Wine26b\"=dword:00000008\n" + + "\"Wine26c\"=hex(2):4c,69,6e,65,20,\\\n" + ";comment\n" + "\"Wine26d\"=dword:00000008\n" + + "\"Wine26e\"=hex(2):4c,69,6e,65,20,\\\n" + "#comment\n" + "\"Wine26f\"=dword:00000008\n" + + "\"Wine26g\"=hex(2):4c,69,6e,65,20,\\\n\n" + "\"Wine26h\"=dword:00000008\n" + + "\"Wine26i\"=hex(2):4c,69,6e,65,20\\\n" + "\"Wine26j\"=dword:00000008\n\n"); + verify_reg_nonexist(hkey, "Wine26a"); + verify_reg_nonexist(hkey, "Wine26b"); + verify_reg_nonexist(hkey, "Wine26c"); + verify_reg_nonexist(hkey, "Wine26d"); + verify_reg_nonexist(hkey, "Wine26e"); + verify_reg(hkey, "Wine26f", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg_nonexist(hkey, "Wine26g"); + verify_reg_nonexist(hkey, "Wine26h"); + verify_reg_nonexist(hkey, "Wine26i"); + verify_reg(hkey, "Wine26j", REG_DWORD, &dword, sizeof(dword), 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine27a\"=hex(2):25,48,4f,4d,45,25,5c,\\\n" + "\"Wine27b\"=hex(2):25,50,41,54,48,25,00\n" + + "\"Wine27c\"=hex(2):25,48,4f,4d,45,25,5c,\\\n" + ";comment\n" + "\"Wine27d\"=hex(2):25,50,41,54,48,25,00\n" + + "\"Wine27e\"=hex(2):25,48,4f,4d,45,25,5c,\\\n" + "#comment\n" + "\"Wine27f\"=hex(2):25,50,41,54,48,25,00\n" + + "\"Wine27g\"=hex(2):25,48,4f,4d,45,25,5c,\\\n\n" + "\"Wine27h\"=hex(2):25,50,41,54,48,25,00\n" + + "\"Wine27i\"=hex(2):25,48,4f,4d,45,25,5c\\\n" + "\"Wine27j\"=hex(2):25,50,41,54,48,25,00\n\n"); + verify_reg_nonexist(hkey, "Wine27a"); + verify_reg_nonexist(hkey, "Wine27b"); + verify_reg_nonexist(hkey, "Wine27c"); + verify_reg_nonexist(hkey, "Wine27d"); + verify_reg_nonexist(hkey, "Wine27e"); + verify_reg(hkey, "Wine27f", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg_nonexist(hkey, "Wine27g"); + verify_reg_nonexist(hkey, "Wine27h"); + verify_reg_nonexist(hkey, "Wine27i"); + verify_reg(hkey, "Wine27j", REG_EXPAND_SZ, "%PATH%", 7, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28a\"=hex(2):4c,69,6e,65,20,\\\n" + "@=\"Default value 1\"\n\n"); + verify_reg_nonexist(hkey, "Wine28a"); + verify_reg_nonexist(hkey, NULL); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28b\"=hex(2):4c,69,6e,65,20,\\\n" + ";comment\n" + "@=\"Default value 2\"\n\n"); + verify_reg_nonexist(hkey, "Wine28b"); + verify_reg_nonexist(hkey, NULL); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28c\"=hex(2):4c,69,6e,65,20,\\\n" + "#comment\n" + "@=\"Default value 3\"\n\n"); + verify_reg_nonexist(hkey, "Wine28c"); + verify_reg(hkey, NULL, REG_SZ, "Default value 3", 16, 0); + + lr = RegDeleteValueW(hkey, NULL); + ok(lr == ERROR_SUCCESS, "RegDeleteValue failed: %u\n", lr); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28d\"=hex(2):4c,69,6e,65,20,\\\n\n" + "@=\"Default value 4\"\n\n"); + verify_reg_nonexist(hkey, "Wine28d"); + verify_reg_nonexist(hkey, NULL); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28e\"=hex(2):4c,69,6e,65,20\\\n" + "@=\"Default value 5\"\n\n"); + verify_reg_nonexist(hkey, "Wine28e"); + verify_reg(hkey, NULL, REG_SZ, "Default value 5", 16, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29a\"=hex:11,22,33,\\\n" + "\\\n" + " 44,55,66\n" + "\"Wine29b\"=hex:11,22,33,\\\n" + " \\\n" + " 44,55,66\n\n"); + verify_reg_nonexist(hkey, "Wine29a"); + verify_reg_nonexist(hkey, "Wine29b"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine30a\"=hex(0):25,48,4f,4d,45,25,5c,/\n" + " 25,50,41,54,48,25,00\n" + "\"Wine30b\"=hex(0):25,48,4f,4d,45,25,5c/\n" + " 25,50,41,54,48,25,00\n\n"); + verify_reg_nonexist(hkey, "Wine30a"); + verify_reg_nonexist(hkey, "Wine30b"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine31\"=hex(7):4c,69,6e,65,20\\"); + verify_reg_nonexist(hkey, "Wine31"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine32a\"=hex(7):4c,69,6e,65,20,\\\n" + " ,63,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n" + "\"Wine32b\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n\n"); + verify_reg_nonexist(hkey, "Wine32a"); + verify_reg_nonexist(hkey, "Wine32b"); + + RegCloseKey(hkey); + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: %d\n", lr); +} + +static void test_invalid_import_unicode(void) +{ + LONG lr; + HKEY hkey; + DWORD dword = 0x8, os_version, major_version, minor_version; + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"TestNoEndQuote\"=\"Asdffdsa\n"); + lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ|KEY_SET_VALUE, &hkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: %d\n", lr); + verify_reg_nonexist(hkey, "TestNoEndQuote"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"TestNoBeginQuote\"=Asdffdsa\"\n"); + verify_reg_nonexist(hkey, "TestNoBeginQuote"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"TestNoQuotes\"=Asdffdsa\n"); + verify_reg_nonexist(hkey, "TestNoQuotes"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"NameNoEndQuote=\"Asdffdsa\"\n"); + verify_reg_nonexist(hkey, "NameNoEndQuote"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "NameNoBeginQuote\"=\"Asdffdsa\"\n"); + verify_reg_nonexist(hkey, "NameNoBeginQuote"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "NameNoQuotes=\"Asdffdsa\"\n"); + verify_reg_nonexist(hkey, "NameNoQuotes"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"MixedQuotes=Asdffdsa\"\n"); + verify_reg_nonexist(hkey, "MixedQuotes"); + verify_reg_nonexist(hkey, "MixedQuotes=Asdffdsa"); + + /* Test import with non-standard registry file headers */ + exec_import_wstr("\xef\xbb\xbfREGEDIT3\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test1\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test1"); + + exec_import_wstr("\xef\xbb\xbfregedit4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test2\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test2"); + + exec_import_wstr("\xef\xbb\xbfRegedit4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test3\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test3"); + + exec_import_wstr("\xef\xbb\xbfREGEDIT 4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test4\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test4"); + + exec_import_wstr("\xef\xbb\xbfREGEDIT4FOO\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test5\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test5"); + + exec_import_wstr("\xef\xbb\xbfREGEDIT4 FOO\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test6\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test6"); + + exec_import_wstr("\xef\xbb\xbfREGEDIT5\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test7\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test7"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 4.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test8\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test8"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test9\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test9"); + + exec_import_wstr("\xef\xbb\xbfWINDOWS REGISTRY EDITOR VERSION 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test10\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test10"); + + os_version = GetVersion(); + major_version = LOBYTE(LOWORD(os_version)); + minor_version = HIBYTE(LOWORD(os_version)); + + if (major_version > 5 || (major_version == 5 && minor_version > 0)) + { + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test11\"=\"Value\"\n"); + verify_reg_nonexist(hkey, "Test11"); + } + else /* Windows 2000 */ + win_skip("Skipping a non-standard header test\n"); + + /* Test multi-line import with incorrect comma placement */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line1\"=hex(7):4c,00,69,00,6e,00,65,00,20,00\\\n" + ",63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + "65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Multi-Line1"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line2\"=hex(7):4c,00,69,00,6e,00,65,00,20,00\\\n" + " ,63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Multi-Line2"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line3\"=hex(7):4c,00,69,00,6e,00,65,00,20,00\\\n" + ",63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Multi-Line3"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line4\"=hex(7):4c,00,69,00,6e,00,65,00,20,00\\\n" + ", 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Multi-Line4"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test12a\"=dword:\n" + "\"Test12b\"=dword:hello\n" + "\"Test12c\"=dword:123456789\n" + "\"Test12d\"=dword:012345678\n" + "\"Test12e\"=dword:000000001\n\n"); + verify_reg_nonexist(hkey, "Test12a"); + verify_reg_nonexist(hkey, "Test12b"); + verify_reg_nonexist(hkey, "Test12c"); + verify_reg_nonexist(hkey, "Test12d"); + verify_reg_nonexist(hkey, "Test12e"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test13a\"=dword:12345678abc\n" + "\"Test13b\"=dword:12345678 abc\n\n"); + verify_reg_nonexist(hkey, "Test13a"); + verify_reg_nonexist(hkey, "Test13b"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test14a\"=dword:0x123\n" + "\"Test14b\"=dword:123 456\n" + "\"Test14c\"=dword:1234 5678\n\n"); + verify_reg_nonexist(hkey, "Test14a"); + verify_reg_nonexist(hkey, "Test14b"); + verify_reg_nonexist(hkey, "Test14c"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test15a\"=\"foo\"bar\"\n" + "\"Test15b\"=\"foo\"\"bar\"\n\n"); + verify_reg_nonexist(hkey, "Test15a"); + verify_reg_nonexist(hkey, "Test15b"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test16a\"=\n" + "\"Test16b\"=\\\"\n" + "\"Test16c\"=\\\"Value\\\"\n" + "\"Test16d\"=\\\"Value\"\n\n"); + verify_reg_nonexist(hkey, "Test16a"); + verify_reg_nonexist(hkey, "Test16b"); + verify_reg_nonexist(hkey, "Test16c"); + verify_reg_nonexist(hkey, "Test16d"); + + /* Test key name and value name concatenation */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\\n" + "Subkey1]\n"); + verify_key_nonexist(hkey, "Subkey1"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\n" + "\\Subkey2]\n"); + verify_key_nonexist(hkey, "Subkey2"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test\\\n" + "17a\"=\"Value 1\"\n" + "\"Test17b\"=\"Value 2\"\n" + "\"Test\n" + "\\17c\"=\"Value 3\"\n\n"); + verify_reg_nonexist(hkey, "Test17a"); + verify_reg(hkey, "Test17b", REG_SZ, "Value 2", 8, 0); + verify_reg_nonexist(hkey, "Test17c"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test18a\"=dword:1234\\\n" + "5678\n" + "\"Test18b\"=\"Test \\\n" + "Value\"\n\n"); + verify_reg_nonexist(hkey, "Test18a"); + verify_reg_nonexist(hkey, "Test18b"); + + /* Test hex data concatenation for REG_NONE, REG_EXPAND_SZ and REG_BINARY */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test19a\"=hex(0):56,00,61,00,6c,00\\\n" + ",75,00,65,00,00,00\n" + "\"Test19b\"=hex(0):56,00,61,00,6c,00\\\n" + " ,75,00,65,00,00,00\n" + "\"Test19c\"=hex(0):56,00,61,00,6c,00\\\n" + " 75,00,65,00,00,00\n" + "\"Test19d\"=hex(0):56,00,61,00,6c,00,7\\\n" + "5,00,65,00,00,00\n" + "\"Test19e\"=hex(0):56,00,61,00,6c,00,7\\\n" + " 5,00,65,00,00,00\n" + "\"Test19f\"=hex(0):56,00,61,00,\\;comment\n" + " 6c,00,75,00,\\#comment\n" + " 65,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Test19a"); + verify_reg_nonexist(hkey, "Test19b"); + verify_reg_nonexist(hkey, "Test19c"); + verify_reg_nonexist(hkey, "Test19d"); + verify_reg_nonexist(hkey, "Test19e"); + verify_reg_nonexist(hkey, "Test19f"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test20a\"=hex(2):25,00,50,00,41,00\\\n" + ",54,00,48,00,25,00,00,00\n" + "\"Test20b\"=hex(2):25,00,50,00,41,00\\\n" + " ,54,00,48,00,25,00,00,00\n" + "\"Test20c\"=hex(2):25,00,50,00,41,00\\\n" + " 54,00,48,00,25,00,00,00\n" + "\"Test20d\"=hex(2):25,00,50,00,4\\\n" + "1,00,54,00,48,00,25,00,00,00\n" + "\"Test20e\"=hex(2):25,00,50,00,4\\\n" + " 1,00,54,00,48,00,25,00,00\n" + "\"Test20f\"=hex(2):25,00,50,00,41,00,\\;comment\n" + " 54,00,48,00,\\#comment\n" + " 25,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Test20a"); + verify_reg_nonexist(hkey, "Test20b"); + verify_reg_nonexist(hkey, "Test20c"); + verify_reg_nonexist(hkey, "Test20d"); + verify_reg_nonexist(hkey, "Test20e"); + verify_reg_nonexist(hkey, "Test20f"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Test21a\"=hex:11,22,33,44\\\n" + ",55,66,77,88\n" + "\"Test21b\"=hex:11,22,33,44\\\n" + " ,55,66,77,88\n" + "\"Test21c\"=hex:11,22,33,44\\\n" + " 55,66,77,88\n" + "\"Test21d\"=hex:11,22,33,4\\\n" + "4,55,66,77,88\n" + "\"Test21e\"=hex:11,22,33,4\\\n" + " 4,55,66,77,88\n" + "\"Test21f\"=hex:11,22,33,\\;comment\n" + " 44,55,66,\\#comment\n" + " 77,88\n\n"); + verify_reg_nonexist(hkey, "Test21a"); + verify_reg_nonexist(hkey, "Test21b"); + verify_reg_nonexist(hkey, "Test21c"); + verify_reg_nonexist(hkey, "Test21d"); + verify_reg_nonexist(hkey, "Test21e"); + verify_reg_nonexist(hkey, "Test21f"); + + /* Test support for characters greater than 0xff */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine22a\"=hex(0):25,50,100,54,48,25,00\n" + "\"Wine22b\"=hex(0):25,1a4,100,164,124,25,00\n\n"); + verify_reg_nonexist(hkey, "Wine22a"); + verify_reg_nonexist(hkey, "Wine22b"); + + /* Test the effect of backslashes in hex data */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine23a\"=hex(2):25,00,48\\,00,4f,00,4d,00,45,00,25,00,00,00\n" + "\"Wine23b\"=hex(2):25,00,48,00,\\4f,00,4d,00,45,00,25,00,00,00\n" + "\"Wine23c\"=hex(2):25,00,48\\ ,00,4f,00,4d,00,45,00,25,00,00,00\n" + "\"Wine23d\"=hex(2):25,00,48,00,\\ 4f,00,4d,00,45,00,25,00,00,00\n" + "\"Wine23e\"=hex(2):\\25,00,48,00,4f,00,4d,00,45,00,25,00,00,00\n" + "\"Wine23f\"=hex(2):\\ 25,00,48,00,4f,00,4d,00,45,00,25,00,00,00\n" + "\"Wine23g\"=hex(2):25,00,48,00,4\\f,00,4d,00,45,00,25,00,00,00\n" + "\"Wine23h\"=hex(2):25,00,48,00,4\\\n" + " f,00,4d,00,45,00,25,00,00,00\n" + "\"Wine23i\"=hex(2):25,00,50,00,\\,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine23j\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00,\\\\\n" + " 25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine23k\"=hex(2):,\\\n" + " 25,00,48,00,4f,00,4d,00,45,00,25,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Wine23a"); + verify_reg_nonexist(hkey, "Wine23b"); + verify_reg_nonexist(hkey, "Wine23c"); + verify_reg_nonexist(hkey, "Wine23d"); + verify_reg_nonexist(hkey, "Wine23e"); + verify_reg_nonexist(hkey, "Wine23f"); + verify_reg_nonexist(hkey, "Wine23g"); + verify_reg_nonexist(hkey, "Wine23h"); + verify_reg_nonexist(hkey, "Wine23i"); + verify_reg_nonexist(hkey, "Wine23j"); + verify_reg_nonexist(hkey, "Wine23k"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine24a\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1]\n"); + verify_reg_nonexist(hkey, "Wine24a"); + verify_key_nonexist(hkey, "Subkey1"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine24b\"=hex(2):4c,00,69,00,6e,00,65,00,20,00\\\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2]\n"); + verify_reg_nonexist(hkey, "Wine24b"); + verify_key(hkey, "Subkey2"); + + lr = RegDeleteKeyA(hkey, "Subkey2"); + ok(lr == ERROR_SUCCESS, "RegDeleteKey failed: %u\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine25a\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + "\"Wine25b\"=\"Test value\"\n" + + "\"Wine25c\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + ";comment\n" + "\"Wine25d\"=\"Test value\"\n" + + "\"Wine25e\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + "#comment\n" + "\"Wine25f\"=\"Test value\"\n" + + "\"Wine25g\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n\n" + "\"Wine25h\"=\"Test value\"\n" + + "\"Wine25i\"=hex(2):4c,00,69,00,6e,00,65,00,20,00\\\n" + "\"Wine25j\"=\"Test value\"\n\n"); + verify_reg_nonexist(hkey, "Wine25a"); + verify_reg_nonexist(hkey, "Wine25b"); + verify_reg_nonexist(hkey, "Wine25c"); + verify_reg_nonexist(hkey, "Wine25d"); + verify_reg_nonexist(hkey, "Wine25e"); + verify_reg(hkey, "Wine25f", REG_SZ, "Test value", 11, 0); + verify_reg_nonexist(hkey, "Wine25g"); + verify_reg_nonexist(hkey, "Wine25h"); + verify_reg_nonexist(hkey, "Wine25i"); + verify_reg(hkey, "Wine25j", REG_SZ, "Test value", 11, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine26a\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + "\"Wine26b\"=dword:00000008\n" + + "\"Wine26c\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + ";comment\n" + "\"Wine26d\"=dword:00000008\n" + + "\"Wine26e\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + "#comment\n" + "\"Wine26f\"=dword:00000008\n" + + "\"Wine26g\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n\n" + "\"Wine26h\"=dword:00000008\n" + + "\"Wine26i\"=hex(2):4c,00,69,00,6e,00,65,00,20,00\\\n" + "\"Wine26j\"=dword:00000008\n\n"); + verify_reg_nonexist(hkey, "Wine26a"); + verify_reg_nonexist(hkey, "Wine26b"); + verify_reg_nonexist(hkey, "Wine26c"); + verify_reg_nonexist(hkey, "Wine26d"); + verify_reg_nonexist(hkey, "Wine26e"); + verify_reg(hkey, "Wine26f", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg_nonexist(hkey, "Wine26g"); + verify_reg_nonexist(hkey, "Wine26h"); + verify_reg_nonexist(hkey, "Wine26i"); + verify_reg(hkey, "Wine26j", REG_DWORD, &dword, sizeof(dword), 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine27a\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00,\\\n" + "\"Wine27b\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + + "\"Wine27c\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00,\\\n" + ";comment\n" + "\"Wine27d\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + + "\"Wine27e\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00,\\\n" + "#comment\n" + "\"Wine27f\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + + "\"Wine27g\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00,\\\n\n" + "\"Wine27h\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + + "\"Wine27i\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00\\\n" + "\"Wine27j\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Wine27a"); + verify_reg_nonexist(hkey, "Wine27b"); + verify_reg_nonexist(hkey, "Wine27c"); + verify_reg_nonexist(hkey, "Wine27d"); + verify_reg_nonexist(hkey, "Wine27e"); + verify_reg(hkey, "Wine27f", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg_nonexist(hkey, "Wine27g"); + verify_reg_nonexist(hkey, "Wine27h"); + verify_reg_nonexist(hkey, "Wine27i"); + verify_reg(hkey, "Wine27j", REG_EXPAND_SZ, "%PATH%", 7, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28a\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + "@=\"Default value 1\"\n\n"); + verify_reg_nonexist(hkey, "Wine28a"); + verify_reg_nonexist(hkey, NULL); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28b\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + ";comment\n" + "@=\"Default value 2\"\n\n"); + verify_reg_nonexist(hkey, "Wine28b"); + verify_reg_nonexist(hkey, NULL); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28c\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n" + "#comment\n" + "@=\"Default value 3\"\n\n"); + verify_reg_nonexist(hkey, "Wine28c"); + verify_reg(hkey, NULL, REG_SZ, "Default value 3", 16, 0); + + lr = RegDeleteValueW(hkey, NULL); + ok(lr == ERROR_SUCCESS, "RegDeleteValue failed: %u\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28d\"=hex(2):4c,00,69,00,6e,00,65,00,20,00,\\\n\n" + "@=\"Default value 4\"\n\n"); + verify_reg_nonexist(hkey, "Wine28d"); + verify_reg_nonexist(hkey, NULL); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28e\"=hex(2):4c,00,69,00,6e,00,65,00,20,00\\\n" + "@=\"Default value 5\"\n\n"); + verify_reg_nonexist(hkey, "Wine28e"); + verify_reg(hkey, NULL, REG_SZ, "Default value 5", 16, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29a\"=hex:11,22,33,\\\n" + "\\\n" + " 44,55,66\n" + "\"Wine29b\"=hex:11,22,33,\\\n" + " \\\n" + " 44,55,66\n\n"); + verify_reg_nonexist(hkey, "Wine29a"); + verify_reg_nonexist(hkey, "Wine29b"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine30a\"=hex(0):25,48,4f,4d,45,25,5c,/\n" + " 25,50,41,54,48,25,00\n" + "\"Wine30b\"=hex(0):25,48,4f,4d,45,25,5c/\n" + " 25,50,41,54,48,25,00\n\n"); + verify_reg_nonexist(hkey, "Wine30a"); + verify_reg_nonexist(hkey, "Wine30b"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine31\"=hex(7):4c,00,69,00,6e,00,65,00,20,00\\"); + verify_reg_nonexist(hkey, "Wine31"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine32a\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " ,63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n" + "\"Wine32b\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Wine32a"); + verify_reg_nonexist(hkey, "Wine32b"); + + RegCloseKey(hkey); + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: %d\n", lr); +} + +static void test_invalid_import_31(void) +{ + HKEY hkey; + LONG lr; + + /* Check if regedit.exe is running with elevated privileges */ + lr = RegCreateKeyExA(HKEY_CLASSES_ROOT, KEY_BASE, 0, NULL, REG_OPTION_NON_VOLATILE, + KEY_READ, NULL, &hkey, NULL); + if (lr == ERROR_ACCESS_DENIED) + { + win_skip("regedit.exe is not running with elevated privileges; " + "skipping Windows 3.1 invalid import tests\n"); + return; + } + + /* Test character validity at the start of the line */ + exec_import_str("REGEDIT\r\n" + " HKEY_CLASSES_ROOT\\" KEY_BASE " = Value1a\r\n"); + verify_reg_nonexist(hkey, ""); + + exec_import_str("REGEDIT\r\n" + " HKEY_CLASSES_ROOT\\" KEY_BASE " = Value1b\r\n"); + verify_reg_nonexist(hkey, ""); + + exec_import_str("REGEDIT\r\n" + "\tHKEY_CLASSES_ROOT\\" KEY_BASE " = Value1c\r\n"); + verify_reg_nonexist(hkey, ""); + + exec_import_str("REGEDIT\r\n" + ";HKEY_CLASSES_ROOT\\" KEY_BASE " = Value2a\r\n"); + verify_reg_nonexist(hkey, ""); + + exec_import_str("REGEDIT\r\n" "#HKEY_CLASSES_ROOT\\" KEY_BASE " = Value2b\r\n"); - todo_wine verify_reg_nonexist(hkey, ""); + verify_reg_nonexist(hkey, ""); /* Test case sensitivity */ exec_import_str("REGEDIT\r\n" "hkey_classes_root\\" KEY_BASE " = Value3a\r\n"); - todo_wine verify_reg_nonexist(hkey, ""); + verify_reg_nonexist(hkey, ""); exec_import_str("REGEDIT\r\n" "hKEY_CLASSES_ROOT\\" KEY_BASE " = Value3b\r\n"); - todo_wine verify_reg_nonexist(hkey, ""); + verify_reg_nonexist(hkey, ""); exec_import_str("REGEDIT\r\n" "Hkey_Classes_Root\\" KEY_BASE " = Value3c\r\n"); - todo_wine verify_reg_nonexist(hkey, ""); + verify_reg_nonexist(hkey, ""); RegCloseKey(hkey); @@ -825,8 +2115,8 @@ static void test_comments(void) "\"Wine2\"=\"Line 2\"\n\n"); lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey); ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: %d\n", lr); - todo_wine verify_reg(hkey, "Wine1", REG_SZ, "Line 1", 7, 0); - todo_wine verify_reg(hkey, "Wine2", REG_SZ, "Line 2", 7, 0); + verify_reg(hkey, "Wine1", REG_SZ, "Line 1", 7, 0); + verify_reg(hkey, "Wine2", REG_SZ, "Line 2", 7, 0); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -852,7 +2142,7 @@ static void test_comments(void) "\"Wine10\"=\"Another valid line\"\n\n"); verify_reg_nonexist(hkey, "Wine7"); verify_reg(hkey, "Wine8", REG_SZ, "A valid line", 13, 0); - todo_wine verify_reg(hkey, "Wine9", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Wine9", REG_MULTI_SZ, "Line concatenation\0", 20, 0); verify_reg(hkey, "Wine10", REG_SZ, "Another valid line", 19, 0); exec_import_str("REGEDIT4\n\n" @@ -929,7 +2219,7 @@ static void test_comments(void) " 63,6f,6e,\\;comment\n" " 63,61,74,\\;comment\n" " 65,6e,61,74,69,6f,6e,00,00\n\n"); - todo_wine verify_reg(hkey, "Multi-Line1", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Multi-Line1", REG_MULTI_SZ, "Line concatenation\0", 20, 0); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -937,7 +2227,7 @@ static void test_comments(void) " 63,6f,6e,\\;comment\n" " 63,61,74,;comment\n" " 65,6e,61,74,69,6f,6e,00,00\n\n"); - todo_wine verify_reg(hkey, "Multi-Line2", REG_MULTI_SZ, "Line concat", 12, 0); + verify_reg(hkey, "Multi-Line2", REG_MULTI_SZ, "Line concat", 12, 0); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -946,7 +2236,7 @@ static void test_comments(void) " 63,6f,6e,\\;comment\n" " 63,61,74,\\;comment\n" " 65,6e,61,74,69,6f,6e,00,00\n\n"); - todo_wine verify_reg(hkey, "Multi-Line3", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Multi-Line3", REG_MULTI_SZ, "Line concatenation\0", 20, 0); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -955,7 +2245,7 @@ static void test_comments(void) " 63,6f,6e,\\;#comment\n" " 63,61,74,\\;#comment\n" " 65,6e,61,74,69,6f,6e,00,00\n\n"); - todo_wine verify_reg(hkey, "Multi-Line4", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Multi-Line4", REG_MULTI_SZ, "Line concatenation\0", 20, 0); exec_import_str("REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -973,7 +2263,318 @@ static void test_comments(void) " 63,61,74,\\\n\n" " 65,6e,\\;comment\n\n" " 61,74,69,6f,6e,00,00\n\n"); - todo_wine verify_reg(hkey, "Multi-Line6", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Multi-Line6", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine27a\"=hex(2):25,50,41,54,48,25,00 ;comment\n" + "\"Wine27b\"=hex(2):25,50,41,54,48,25,00\t;comment\n" + "\"Wine27c\"=hex(2):25,50,41,54,48,25,00 #comment\n" + "\"Wine27d\"=hex(2):25,50,41,54,48,25,00\t#comment\n\n"); + verify_reg(hkey, "Wine27a", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine27b", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg_nonexist(hkey, "Wine27c"); + verify_reg_nonexist(hkey, "Wine27d"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28a\"=hex(2):25,48,4f,4d,45,25,5c,\\\n" + " 25,50,41,54,48,25,00\n" + "\"Wine28b\"=hex(2):25,48,4f,4d,45,25,5c\\\n" + " 25,50,41,54,48,25,00\n" + "\"Wine28c\"=hex(2):25,48,4f,4d,45,25,5c, \\ ;comment\n" + " 25,50,41,54,48,25,00\n" + "\"Wine28d\"=hex(2):25,48,4f,4d,45,25,5c \\ ;comment\n" + " 25,50,41,54,48,25,00\n" + "\"Wine28e\"=hex(2):25,48,4f,4d,45,25,5c,\\\t ;comment\n" + " 25,50,41,54,48,25,00\n" + "\"Wine28f\"=hex(2):25,48,4f,4d,45,25,5c\\\t ;comment\n" + " 25,50,41,54,48,25,00\n\n"); + verify_reg(hkey, "Wine28a", REG_EXPAND_SZ, "%HOME%\\%PATH%", 14, 0); + verify_reg_nonexist(hkey, "Wine28b"); + verify_reg(hkey, "Wine28c", REG_EXPAND_SZ, "%HOME%\\%PATH%", 14, 0); + verify_reg_nonexist(hkey, "Wine28d"); + verify_reg(hkey, "Wine28e", REG_EXPAND_SZ, "%HOME%\\%PATH%", 14, 0); + verify_reg_nonexist(hkey, "Wine28f"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29a\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,6f,6e,63,61,74,\\\n" + ";comment\n" + " 65,6e,\\;comment\n" + " 61,74,69,6f,6e,00,00\n\n"); + verify_reg(hkey, "Wine29a", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29b\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,6f,6e,63,61,74,\\\n" + " ;comment\n" + " 65,6e,\\;comment\n" + " 61,74,69,6f,6e,00,00\n\n"); + verify_reg(hkey, "Wine29b", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29c\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,6f,6e,63,61,74,\\\n" + "#comment\n" + " 65,6e,\\;comment\n" + " 61,74,69,6f,6e,00,00\n\n"); + verify_reg_nonexist(hkey, "Wine29c"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29d\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,6f,6e,63,61,74,\\\n" + " #comment\n" + " 65,6e,\\;comment\n" + " 61,74,69,6f,6e,00,00\n\n"); + verify_reg_nonexist(hkey, "Wine29d"); + + RegCloseKey(hkey); + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: %d\n", lr); +} + +static void test_comments_unicode(void) +{ + LONG lr; + HKEY hkey; + DWORD dword; + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "#comment\\\n" + "\"Wine1\"=\"Line 1\"\n" + ";comment\\\n" + "\"Wine2\"=\"Line 2\"\n\n"); + lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: %d\n", lr); + verify_reg(hkey, "Wine1", REG_SZ, "Line 1", 7, 0); + verify_reg(hkey, "Wine2", REG_SZ, "Line 2", 7, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine3\"=\"Value 1\"#comment\n" + "\"Wine4\"=\"Value 2\";comment\n" + "\"Wine5\"=dword:01020304 #comment\n" + "\"Wine6\"=dword:02040608 ;comment\n\n"); + verify_reg_nonexist(hkey, "Wine3"); + verify_reg(hkey, "Wine4", REG_SZ, "Value 2", 8, 0); + verify_reg_nonexist(hkey, "Wine5"); + dword = 0x2040608; + verify_reg(hkey, "Wine6", REG_DWORD, &dword, sizeof(dword), 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine7\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " #comment\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n" + "\"Wine8\"=\"A valid line\"\n" + "\"Wine9\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " ;comment\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n" + "\"Wine10\"=\"Another valid line\"\n\n"); + verify_reg_nonexist(hkey, "Wine7"); + verify_reg(hkey, "Wine8", REG_SZ, "A valid line", 13, 0); + verify_reg(hkey, "Wine9", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Wine10", REG_SZ, "Another valid line", 19, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "#\"Comment1\"=\"Value 1\"\n" + ";\"Comment2\"=\"Value 2\"\n" + " #\"Comment3\"=\"Value 3\"\n" + " ;\"Comment4\"=\"Value 4\"\n" + "\"Wine11\"=\"Value 6\"#\"Comment5\"=\"Value 5\"\n" + "\"Wine12\"=\"Value 7\";\"Comment6\"=\"Value 6\"\n\n"); + verify_reg_nonexist(hkey, "Comment1"); + verify_reg_nonexist(hkey, "Comment2"); + verify_reg_nonexist(hkey, "Comment3"); + verify_reg_nonexist(hkey, "Comment4"); + verify_reg_nonexist(hkey, "Wine11"); + verify_reg_nonexist(hkey, "Comment5"); + verify_reg(hkey, "Wine12", REG_SZ, "Value 7", 8, 0); + verify_reg_nonexist(hkey, "Comment6"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine13\"=#\"Value 8\"\n" + "\"Wine14\"=;\"Value 9\"\n" + "\"Wine15\"=\"#comment1\"\n" + "\"Wine16\"=\";comment2\"\n" + "\"Wine17\"=\"Value#comment3\"\n" + "\"Wine18\"=\"Value;comment4\"\n" + "\"Wine19\"=\"Value #comment5\"\n" + "\"Wine20\"=\"Value ;comment6\"\n" + "\"Wine21\"=#dword:00000001\n" + "\"Wine22\"=;dword:00000002\n" + "\"Wine23\"=dword:00000003#comment\n" + "\"Wine24\"=dword:00000004;comment\n\n"); + verify_reg_nonexist(hkey, "Wine13"); + verify_reg_nonexist(hkey, "Wine14"); + verify_reg(hkey, "Wine15", REG_SZ, "#comment1", 10, 0); + verify_reg(hkey, "Wine16", REG_SZ, ";comment2", 10, 0); + verify_reg(hkey, "Wine17", REG_SZ, "Value#comment3", 15, 0); + verify_reg(hkey, "Wine18", REG_SZ, "Value;comment4", 15, 0); + verify_reg(hkey, "Wine19", REG_SZ, "Value #comment5", 16, 0); + verify_reg(hkey, "Wine20", REG_SZ, "Value ;comment6", 16, 0); + verify_reg_nonexist(hkey, "Wine21"); + verify_reg_nonexist(hkey, "Wine22"); + verify_reg_nonexist(hkey, "Wine23"); + dword = 0x00000004; + verify_reg(hkey, "Wine24", REG_DWORD, &dword, sizeof(dword), 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine25a\"=dword:1234;5678\n" + "\"Wine25b\"=dword:1234 ;5678\n" + "\"Wine25c\"=dword:1234#5678\n" + "\"Wine25d\"=dword:1234 #5678\n\n"); + dword = 0x1234; + verify_reg(hkey, "Wine25a", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg(hkey, "Wine25b", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg_nonexist(hkey, "Wine25c"); + verify_reg_nonexist(hkey, "Wine25d"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine26a\"=\"Value1\" ;comment\n" + "\"Wine26b\"=\"Value2\"\t\t;comment\n" + "\"Wine26c\"=\"Value3\" #comment\n" + "\"Wine26d\"=\"Value4\"\t\t#comment\n\n"); + verify_reg(hkey, "Wine26a", REG_SZ, "Value1", 7, 0); + verify_reg(hkey, "Wine26b", REG_SZ, "Value2", 7, 0); + verify_reg_nonexist(hkey, "Wine26c"); + verify_reg_nonexist(hkey, "Wine26d"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line1\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,\\;comment\n" + " 63,00,61,00,74,00,\\;comment\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Multi-Line1", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line2\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,\\;comment\n" + " 63,00,61,00,74,00,;comment\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Multi-Line2", REG_MULTI_SZ, "Line concat", 12, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line3\"=hex(7):4c,00,69,00,6e,00,\\;comment\n" + " 65,00,20,00,\\;comment\n" + " 63,00,6f,00,6e,00,\\;comment\n" + " 63,00,61,00,74,00,\\;comment\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Multi-Line3", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line4\"=hex(7):4c,00,69,00,6e,00,\\;#comment\n" + " 65,00,20,00,\\;#comment\n" + " 63,00,6f,00,6e,00,\\;#comment\n" + " 63,00,61,00,74,00,\\;#comment\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Multi-Line4", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line5\"=hex(7):4c,00,69,00,6e,00,\\;comment\n" + " 65,00,20,00,\\;comment\n" + " 63,00,6f,00,6e,00,\\;comment\n" + " 63,00,61,00,74,00,\\#comment\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Multi-Line5"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Multi-Line6\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,\\;comment\n" + " 63,00,61,00,74,00,\\\n\n" + " 65,00,6e,00,\\;comment\n\n" + " 61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Multi-Line6", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine27a\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00 ;comment\n" + "\"Wine27b\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\t;comment\n" + "\"Wine27c\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00 #comment\n" + "\"Wine27d\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\t#comment\n\n"); + verify_reg(hkey, "Wine27a", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine27b", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg_nonexist(hkey, "Wine27c"); + verify_reg_nonexist(hkey, "Wine27d"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine28a\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00,\\\n" + " 25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine28b\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00\\\n" + " 25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine28c\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00, \\ ;comment\n" + " 25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine28d\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00 \\ ;comment\n" + " 25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine28e\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00,\\\t ;comment\n" + " 25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine28f\"=hex(2):25,00,48,00,4f,00,4d,00,45,00,25,00,5c,00\\\t ;comment\n" + " 25,00,50,00,41,00,54,00,48,00,25,00,00,00\n\n"); + verify_reg(hkey, "Wine28a", REG_EXPAND_SZ, "%HOME%\\%PATH%", 14, 0); + verify_reg_nonexist(hkey, "Wine28b"); + verify_reg(hkey, "Wine28c", REG_EXPAND_SZ, "%HOME%\\%PATH%", 14, 0); + verify_reg_nonexist(hkey, "Wine28d"); + verify_reg(hkey, "Wine28e", REG_EXPAND_SZ, "%HOME%\\%PATH%", 14, 0); + verify_reg_nonexist(hkey, "Wine28f"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29a\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + ";comment\n" + " 65,00,6e,00,\\;comment\n" + " 61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Wine29a", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29b\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " ;comment\n" + " 65,00,6e,00,\\;comment\n" + " 61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Wine29b", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29c\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + "#comment\n" + " 65,00,6e,00,\\;comment\n" + " 61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Wine29c"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine29d\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " #comment\n" + " 65,00,6e,00,\\;comment\n" + " 61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg_nonexist(hkey, "Wine29d"); RegCloseKey(hkey); @@ -987,6 +2588,9 @@ static void test_import_with_whitespace(void) LONG lr; DWORD dword; + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + exec_import_str(" REGEDIT4\n\n" "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n"); @@ -1049,7 +2653,7 @@ static void test_import_with_whitespace(void) verify_reg(hkey, "Wine4a", REG_SZ, "Tab and four spaces", 20, 0); dword = 0x112233; verify_reg(hkey, "Wine4b", REG_DWORD, &dword, sizeof(dword), 0); - todo_wine verify_reg(hkey, "Wine4c", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Wine4c", REG_MULTI_SZ, "Line concatenation\0", 20, 0); exec_import_str(" REGEDIT4\n\n" "\t[HKEY_CURRENT_USER\\" KEY_BASE "]\n" @@ -1103,6 +2707,24 @@ static void test_import_with_whitespace(void) "\t@\t=\tdword:\t00000008\t\n\n"); verify_reg(hkey, "", REG_DWORD, &dword, sizeof(DWORD), 0); + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine10a\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,6f,6e,\\\n\n" + " 63,61,74,\\\n\n\n" + " 65,6e,\\\n\n\n\n" + " 61,74,69,6f,6e,00,00\n\n"); + verify_reg(hkey, "Wine10a", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine10b\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,6f,6e,\\\n \n" + " 63,61,74,\\\n\t\n\t\n" + " 65,6e,\\\n\t \t\n\t \t\n\t \t\n" + " 61,74,69,6f,6e,00,00\n\n"); + verify_reg(hkey, "Wine10b", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + lr = RegCloseKey(hkey); ok(lr == ERROR_SUCCESS, "RegCloseKey failed: got %d, expected 0\n", lr); @@ -1110,23 +2732,587 @@ static void test_import_with_whitespace(void) ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %d, expected 0\n", lr); } -START_TEST(regedit) +static void test_import_with_whitespace_unicode(void) +{ + HKEY hkey; + LONG lr; + DWORD dword; + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + + exec_import_wstr("\xef\xbb\xbf Windows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n"); + + lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %d, expected 0\n", lr); + + exec_import_wstr("\xef\xbb\xbf Windows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine1a\"=\"Value\"\n\n"); + verify_reg(hkey, "Wine1a", REG_SZ, "Value", 6, 0); + + exec_import_wstr("\xef\xbb\xbf\tWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine1b\"=\"Value\"\n\n"); + verify_reg(hkey, "Wine1b", REG_SZ, "Value", 6, 0); + + exec_import_wstr("\xef\xbb\xbf \t Windows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine1c\"=\"Value\"\n\n"); + verify_reg(hkey, "Wine1c", REG_SZ, "Value", 6, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + " [HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine2a\"=\"Value\"\n\n"); + verify_reg(hkey, "Wine2a", REG_SZ, "Value", 6, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "\t[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine2b\"=\"Value\"\n\n"); + verify_reg(hkey, "Wine2b", REG_SZ, "Value", 6, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + " \t [HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine2c\"=\"Value\"\n\n"); + verify_reg(hkey, "Wine2c", REG_SZ, "Value", 6, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + " \"Wine3a\"=\"Two leading spaces\"\n\n"); + verify_reg(hkey, "Wine3a", REG_SZ, "Two leading spaces", 19, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\t\"Wine3b\"=\"One leading tab\"\n\n"); + verify_reg(hkey, "Wine3b", REG_SZ, "One leading tab", 16, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + " \t \"Wine3c\"=\"Space, tab, space\"\n\n"); + verify_reg(hkey, "Wine3c", REG_SZ, "Space, tab, space", 18, 0); + + exec_import_wstr("\xef\xbb\xbf Windows Registry Editor Version 5.00\n\n" + "\t\t\t[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\t \"Wine4a\"=\"Tab and four spaces\"\n" + " \"Wine4b\"=dword:00112233\n" + "\t \t \t \t \t \t \"Wine4c\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,\\;comment\n" + "\t\t\t\t63,00,61,00,74,00,\\;comment\n" + " \t65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Wine4a", REG_SZ, "Tab and four spaces", 20, 0); + dword = 0x112233; + verify_reg(hkey, "Wine4b", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg(hkey, "Wine4c", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_wstr("\xef\xbb\xbf Windows Registry Editor Version 5.00\n\n" + "\t[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + " \"Wine5a\"=\"Leading spaces\"\n" + "\t\t\"Wine5b\"\t\t=\"Leading tabs\"\n" + "\t \"Wine5c\"=\t \"Tabs and spaces\"\n" + " \"Wine5d\" \t = \t \"More whitespace\"\n\n"); + verify_reg(hkey, "Wine5a", REG_SZ, "Leading spaces", 15, 0); + verify_reg(hkey, "Wine5b", REG_SZ, "Leading tabs", 13, 0); + verify_reg(hkey, "Wine5c", REG_SZ, "Tabs and spaces", 16, 0); + verify_reg(hkey, "Wine5d", REG_SZ, "More whitespace", 16, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\" Wine6a\"=\"Leading spaces\"\n" + "\"\t\tWine6b\"=\"Leading tabs\"\n" + " \" Wine6c \" = \" Spaces everywhere \" \n\n"); + verify_reg(hkey, " Wine6a", REG_SZ, "Leading spaces", 15, 0); + verify_reg(hkey, "\t\tWine6b", REG_SZ, "Leading tabs", 13, 0); + verify_reg(hkey, " Wine6c ", REG_SZ, " Spaces everywhere ", 22, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine7a\"=\" Four spaces in the data\"\n" + "\"Wine7b\"=\"\t\tTwo tabs in the data\"\n\n"); + verify_reg(hkey, "Wine7a", REG_SZ, " Four spaces in the data", 28, 0); + verify_reg(hkey, "Wine7b", REG_SZ, "\t\tTwo tabs in the data", 23, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine8a\"=\"Trailing spaces\" \n" + "\"Wine8b\"=\"Trailing tabs and spaces\"\t \t\n\n"); + verify_reg(hkey, "Wine8a", REG_SZ, "Trailing spaces", 16, 0); + verify_reg(hkey, "Wine8b", REG_SZ, "Trailing tabs and spaces", 25, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine9a\"=dword: 00000008\n" + "\"Wine9b\"=dword:\t\t00000008\n\n"); + dword = 0x00000008; + verify_reg(hkey, "Wine9a", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg(hkey, "Wine9b", REG_DWORD, &dword, sizeof(dword), 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "@ = \"Test Value\"\n\n"); + verify_reg(hkey, "", REG_SZ, "Test Value", 11, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\t@\t=\tdword:\t00000008\t\n\n"); + verify_reg(hkey, "", REG_DWORD, &dword, sizeof(DWORD), 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine10a\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,\\\n\n" + " 63,00,61,00,74,00,\\\n\n\n" + " 65,00,6e,00,\\\n\n\n\n" + " 61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Wine10a", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine10b\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,\\\n \n" + " 63,00,61,00,74,00,\\\n\t\n\t\n" + " 65,00,6e,00,\\\n\t \t\n\t \t\n\t \t\n" + " 61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n\n"); + verify_reg(hkey, "Wine10b", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + + lr = RegCloseKey(hkey); + ok(lr == ERROR_SUCCESS, "RegCloseKey failed: got %d, expected 0\n", lr); + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %d, expected 0\n", lr); +} + +static void test_key_creation_and_deletion(void) +{ + HKEY hkey, subkey; + LONG lr; + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n"); + + lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %d, expected 0\n", lr); + + /* Test key creation */ + exec_import_str("REGEDIT4\n\n" + "HKEY_CURRENT_USER\\" KEY_BASE "\\No_Opening_Bracket]\n"); + verify_key_nonexist(hkey, "No_Opening_Bracket"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\No_Closing_Bracket\n"); + verify_key_nonexist(hkey, "No_Closing_Bracket"); + + exec_import_str("REGEDIT4\n\n" + "[ HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1a]\n"); + verify_key_nonexist(hkey, "Subkey1a"); + + exec_import_str("REGEDIT4\n\n" + "[\tHKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1b]\n"); + verify_key_nonexist(hkey, "Subkey1b"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1c ]\n"); + verify_key(hkey, "Subkey1c "); + lr = RegDeleteKeyA(hkey, "Subkey1c "); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1d\t]\n"); + verify_key(hkey, "Subkey1d\t"); + lr = RegDeleteKeyA(hkey, "Subkey1d\t"); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1e\\]\n" + "\"Wine\"=\"Test value\"\n\n"); + verify_key(hkey, "Subkey1e\\"); + verify_key(hkey, "Subkey1e"); + lr = RegOpenKeyExA(hkey, "Subkey1e", 0, KEY_READ, &subkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %u, expected 0\n", lr); + verify_reg(subkey, "Wine", REG_SZ, "Test value", 11, 0); + RegCloseKey(subkey); + lr = RegDeleteKeyA(hkey, "Subkey1e"); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %u, expected 0\n", lr); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1f\\\\]\n" + "\"Wine\"=\"Test value\"\n\n"); + verify_key(hkey, "Subkey1f\\\\"); + verify_key(hkey, "Subkey1f\\"); + verify_key(hkey, "Subkey1f"); + lr = RegOpenKeyExA(hkey, "Subkey1f\\\\", 0, KEY_READ, &subkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %u, expected 0\n", lr); + verify_reg(subkey, "Wine", REG_SZ, "Test value", 11, 0); + RegCloseKey(subkey); + lr = RegDeleteKeyA(hkey, "Subkey1f\\\\"); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %u, expected 0\n", lr); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1g\\\\\\\\]\n" + "\"Wine\"=\"Test value\"\n\n"); + verify_key(hkey, "Subkey1g\\\\\\\\"); + verify_key(hkey, "Subkey1g\\\\"); + verify_key(hkey, "Subkey1g\\"); + verify_key(hkey, "Subkey1g"); + lr = RegOpenKeyExA(hkey, "Subkey1g\\\\", 0, KEY_READ, &subkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %u, expected 0\n", lr); + verify_reg(subkey, "Wine", REG_SZ, "Test value", 11, 0); + RegCloseKey(subkey); + lr = RegDeleteKeyA(hkey, "Subkey1g\\\\"); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %u, expected 0\n", lr); + + /* Test key deletion. We start by creating some registry keys. */ + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2a]\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2b]\n\n"); + verify_key(hkey, "Subkey2a"); + verify_key(hkey, "Subkey2b"); + + exec_import_str("REGEDIT4\n\n" + "[ -HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2a]\n"); + verify_key(hkey, "Subkey2a"); + + exec_import_str("REGEDIT4\n\n" + "[\t-HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2b]\n"); + verify_key(hkey, "Subkey2b"); + + exec_import_str("REGEDIT4\n\n" + "[- HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2a]\n"); + verify_key(hkey, "Subkey2a"); + + exec_import_str("REGEDIT4\n\n" + "[-\tHKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2b]\n"); + verify_key(hkey, "Subkey2b"); + + exec_import_str("REGEDIT4\n\n" + "[-HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2a]\n\n" + "[-HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2b]\n\n"); + verify_key_nonexist(hkey, "Subkey2a"); + verify_key_nonexist(hkey, "Subkey2b"); + + /* Test case sensitivity when creating and deleting registry keys. */ + exec_import_str("REGEDIT4\n\n" + "[hkey_CURRENT_user\\" KEY_BASE "\\Subkey3a]\n\n" + "[HkEy_CuRrEnT_uSeR\\" KEY_BASE "\\SuBkEy3b]\n\n"); + verify_key(hkey, "Subkey3a"); + verify_key(hkey, "Subkey3b"); + + exec_import_str("REGEDIT4\n\n" + "[-HKEY_current_USER\\" KEY_BASE "\\sUBKEY3A]\n\n" + "[-hKeY_cUrReNt_UsEr\\" KEY_BASE "\\sUbKeY3B]\n\n"); + verify_key_nonexist(hkey, "Subkey3a"); + verify_key_nonexist(hkey, "Subkey3b"); + + /* Test mixed key creation and deletion. We start by creating a subkey. */ + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey4a]\n\n"); + verify_key(hkey, "Subkey4a"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n" + "[-HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey4a]\n" + "\"Wine1a\"=dword:12345678\n\n"); + verify_key_nonexist(hkey, "Subkey4a"); + verify_reg_nonexist(hkey, "Wine1a"); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n" + "[HKEY_CURRENT_USERS\\" KEY_BASE "\\Subkey4b]\n" + "\"Wine1b\"=dword:12345678\n\n"); + verify_key_nonexist(hkey, "Subkey4b"); + verify_reg_nonexist(hkey, "Wine1b"); + + lr = RegCloseKey(hkey); + ok(lr == ERROR_SUCCESS, "RegCloseKey failed: got %d, expected 0\n", lr); + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %d, expected 0\n", lr); +} + +static void test_key_creation_and_deletion_unicode(void) { - WCHAR wchar_test[] = {0xFEFF,'W','i','n','d','o','w','s',' ','R','e','g', - 'i','s','t','r','y',' ','E','d','i','t','o','r',' ','V','e','r','s', - 'i','o','n',' ','5','.','0','0','\n','\n',0}; + HKEY hkey, subkey; + LONG lr; + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n"); + + lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %d, expected 0\n", lr); + /* Test key creation */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "HKEY_CURRENT_USER\\" KEY_BASE "\\No_Opening_Bracket]\n"); + verify_key_nonexist(hkey, "No_Opening_Bracket"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\No_Closing_Bracket\n"); + verify_key_nonexist(hkey, "No_Closing_Bracket"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[ HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1a]\n"); + verify_key_nonexist(hkey, "Subkey1a"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[\tHKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1b]\n"); + verify_key_nonexist(hkey, "Subkey1b"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1c ]\n"); + verify_key(hkey, "Subkey1c "); + lr = RegDeleteKeyA(hkey, "Subkey1c "); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1d\t]\n"); + verify_key(hkey, "Subkey1d\t"); + lr = RegDeleteKeyA(hkey, "Subkey1d\t"); + ok(lr == ERROR_SUCCESS, "got %d, expected 0\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1e\\]\n" + "\"Wine\"=\"Test value\"\n\n"); + verify_key(hkey, "Subkey1e\\"); + verify_key(hkey, "Subkey1e"); + lr = RegOpenKeyExA(hkey, "Subkey1e", 0, KEY_READ, &subkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %u, expected 0\n", lr); + verify_reg(subkey, "Wine", REG_SZ, "Test value", 11, 0); + RegCloseKey(subkey); + lr = RegDeleteKeyA(hkey, "Subkey1e"); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %u, expected 0\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1f\\\\]\n" + "\"Wine\"=\"Test value\"\n\n"); + verify_key(hkey, "Subkey1f\\\\"); + verify_key(hkey, "Subkey1f\\"); + verify_key(hkey, "Subkey1f"); + lr = RegOpenKeyExA(hkey, "Subkey1f\\\\", 0, KEY_READ, &subkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %u, expected 0\n", lr); + verify_reg(subkey, "Wine", REG_SZ, "Test value", 11, 0); + RegCloseKey(subkey); + lr = RegDeleteKeyA(hkey, "Subkey1f\\\\"); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %u, expected 0\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey1g\\\\\\\\]\n" + "\"Wine\"=\"Test value\"\n\n"); + verify_key(hkey, "Subkey1g\\\\\\\\"); + verify_key(hkey, "Subkey1g\\\\"); + verify_key(hkey, "Subkey1g\\"); + verify_key(hkey, "Subkey1g"); + lr = RegOpenKeyExA(hkey, "Subkey1g\\\\", 0, KEY_READ, &subkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %u, expected 0\n", lr); + verify_reg(subkey, "Wine", REG_SZ, "Test value", 11, 0); + RegCloseKey(subkey); + lr = RegDeleteKeyA(hkey, "Subkey1g\\\\"); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %u, expected 0\n", lr); + + /* Test key deletion. We start by creating some registry keys. */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2a]\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2b]\n\n"); + verify_key(hkey, "Subkey2a"); + verify_key(hkey, "Subkey2b"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[ -HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2a]\n"); + verify_key(hkey, "Subkey2a"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[\t-HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2b]\n"); + verify_key(hkey, "Subkey2b"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[- HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2a]\n"); + verify_key(hkey, "Subkey2a"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[-\tHKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2b]\n"); + verify_key(hkey, "Subkey2b"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[-HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2a]\n\n" + "[-HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey2b]\n\n"); + verify_key_nonexist(hkey, "Subkey2a"); + verify_key_nonexist(hkey, "Subkey2b"); + + /* Test case sensitivity when creating and deleting registry keys. */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[hkey_CURRENT_user\\" KEY_BASE "\\Subkey3a]\n\n" + "[HkEy_CuRrEnT_uSeR\\" KEY_BASE "\\SuBkEy3b]\n\n"); + verify_key(hkey, "Subkey3a"); + verify_key(hkey, "Subkey3b"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[-HKEY_current_USER\\" KEY_BASE "\\sUBKEY3A]\n\n" + "[-hKeY_cUrReNt_UsEr\\" KEY_BASE "\\sUbKeY3B]\n\n"); + verify_key_nonexist(hkey, "Subkey3a"); + verify_key_nonexist(hkey, "Subkey3b"); + + /* Test mixed key creation and deletion. We start by creating a subkey. */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey4a]\n\n"); + verify_key(hkey, "Subkey4a"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n" + "[-HKEY_CURRENT_USER\\" KEY_BASE "\\Subkey4a]\n" + "\"Wine1a\"=dword:12345678\n\n"); + verify_key_nonexist(hkey, "Subkey4a"); + verify_reg_nonexist(hkey, "Wine1a"); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n" + "[HKEY_CURRENT_USERS\\" KEY_BASE "\\Subkey4b]\n" + "\"Wine1b\"=dword:12345678\n\n"); + verify_key_nonexist(hkey, "Subkey4b"); + verify_reg_nonexist(hkey, "Wine1b"); + + lr = RegCloseKey(hkey); + ok(lr == ERROR_SUCCESS, "RegCloseKey failed: got %d, expected 0\n", lr); + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %d, expected 0\n", lr); +} + +static void test_value_deletion(void) +{ + HKEY hkey; + LONG lr; + DWORD dword = 0x8; + BYTE hex[4] = {0x11, 0x22, 0x33, 0x44}; + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n"); + + lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %d, expected 0\n", lr); + + /* Test value deletion. We start by creating some registry values. */ + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine46a\"=\"Test Value\"\n" + "\"Wine46b\"=dword:00000008\n" + "\"Wine46c\"=hex:11,22,33,44\n" + "\"Wine46d\"=hex(7):4c,69,6e,65,20,\\\n" + " 63,6f,6e,63,61,74,65,6e,61,74,69,6f,6e,00,00\n" + "\"Wine46e\"=hex(2):25,50,41,54,48,25,00\n" + "\"Wine46f\"=hex(0):56,00,61,00,6c,00,75,00,65,00,00,00\n\n"); + verify_reg(hkey, "Wine46a", REG_SZ, "Test Value", 11, 0); + verify_reg(hkey, "Wine46b", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg(hkey, "Wine46c", REG_BINARY, hex, 4, 0); + verify_reg(hkey, "Wine46d", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Wine46e", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine46f", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); + + exec_import_str("REGEDIT4\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine46a\"=-\n" + "\"Wine46b\"= -\n" + "\"Wine46c\"= \t-\t \n" + "\"Wine46d\"=-\"Test\"\n" + "\"Wine46e\"=- ;comment\n" + "\"Wine46f\"=- #comment\n\n"); + verify_reg_nonexist(hkey, "Wine46a"); + verify_reg_nonexist(hkey, "Wine46b"); + verify_reg_nonexist(hkey, "Wine46c"); + verify_reg(hkey, "Wine46d", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg_nonexist(hkey, "Wine46e"); + verify_reg(hkey, "Wine46f", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); + + lr = RegCloseKey(hkey); + ok(lr == ERROR_SUCCESS, "RegCloseKey failed: got %d, expected 0\n", lr); + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %d, expected 0\n", lr); +} + + +static void test_value_deletion_unicode(void) +{ + HKEY hkey; + LONG lr; + DWORD dword = 0x8; + BYTE hex[4] = {0x11, 0x22, 0x33, 0x44}; + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS || lr == ERROR_FILE_NOT_FOUND, "RegDeleteKeyA failed: %d\n", lr); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n\n"); + + lr = RegOpenKeyExA(HKEY_CURRENT_USER, KEY_BASE, 0, KEY_READ, &hkey); + ok(lr == ERROR_SUCCESS, "RegOpenKeyExA failed: got %d, expected 0\n", lr); + + /* Test value deletion. We start by creating some registry values. */ + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine46a\"=\"Test Value\"\n" + "\"Wine46b\"=dword:00000008\n" + "\"Wine46c\"=hex:11,22,33,44\n" + "\"Wine46d\"=hex(7):4c,00,69,00,6e,00,65,00,20,00,\\\n" + " 63,00,6f,00,6e,00,63,00,61,00,74,00,\\\n" + " 65,00,6e,00,61,00,74,00,69,00,6f,00,6e,00,00,00,00,00\n" + "\"Wine46e\"=hex(2):25,00,50,00,41,00,54,00,48,00,25,00,00,00\n" + "\"Wine46f\"=hex(0):56,00,61,00,6c,00,75,00,65,00,00,00\n\n"); + verify_reg(hkey, "Wine46a", REG_SZ, "Test Value", 11, 0); + verify_reg(hkey, "Wine46b", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg(hkey, "Wine46c", REG_BINARY, hex, 4, 0); + verify_reg(hkey, "Wine46d", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg(hkey, "Wine46e", REG_EXPAND_SZ, "%PATH%", 7, 0); + verify_reg(hkey, "Wine46f", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); + + exec_import_wstr("\xef\xbb\xbfWindows Registry Editor Version 5.00\n\n" + "[HKEY_CURRENT_USER\\" KEY_BASE "]\n" + "\"Wine46a\"=-\n" + "\"Wine46b\"= -\n" + "\"Wine46c\"= \t-\t \n" + "\"Wine46d\"=-\"Test\"\n" + "\"Wine46e\"=- ;comment\n" + "\"Wine46f\"=- #comment\n\n"); + verify_reg_nonexist(hkey, "Wine46a"); + verify_reg_nonexist(hkey, "Wine46b"); + verify_reg_nonexist(hkey, "Wine46c"); + verify_reg(hkey, "Wine46d", REG_MULTI_SZ, "Line concatenation\0", 20, 0); + verify_reg_nonexist(hkey, "Wine46e"); + verify_reg(hkey, "Wine46f", REG_NONE, "V\0a\0l\0u\0e\0\0", 12, 0); + + lr = RegCloseKey(hkey); + ok(lr == ERROR_SUCCESS, "RegCloseKey failed: got %d, expected 0\n", lr); + + lr = RegDeleteKeyA(HKEY_CURRENT_USER, KEY_BASE); + ok(lr == ERROR_SUCCESS, "RegDeleteKeyA failed: got %d, expected 0\n", lr); +} + +START_TEST(regedit) +{ if(!exec_import_str("REGEDIT4\r\n\r\n")){ win_skip("regedit not available, skipping regedit tests\n"); return; } - supports_wchar = exec_import_wstr(wchar_test); - test_basic_import(); + test_basic_import_unicode(); test_basic_import_31(); test_invalid_import(); + test_invalid_import_unicode(); test_invalid_import_31(); test_comments(); + test_comments_unicode(); test_import_with_whitespace(); + test_import_with_whitespace_unicode(); + test_key_creation_and_deletion(); + test_key_creation_and_deletion_unicode(); + test_value_deletion(); + test_value_deletion_unicode(); }

6 years, 11 months

[reactos] 01/01: [QEDIT_WINETEST] Sync with Wine Staging 2.16. CORE-13762

by Amine Khaldi

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=8901d24b00e912b07e039… commit 8901d24b00e912b07e0399f001fff818b8f194cd Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Sat Oct 21 13:29:32 2017 +0100 [QEDIT_WINETEST] Sync with Wine Staging 2.16. CORE-13762 --- modules/rostests/winetests/qedit/CMakeLists.txt | 2 +- modules/rostests/winetests/qedit/testlist.c | 2 + modules/rostests/winetests/qedit/timeline.c | 116 ++++++++++++++++++++++++ 3 files changed, 119 insertions(+), 1 deletion(-) diff --git a/modules/rostests/winetests/qedit/CMakeLists.txt b/modules/rostests/winetests/qedit/CMakeLists.txt index 8128d9a3f5..311d011faf 100644 --- a/modules/rostests/winetests/qedit/CMakeLists.txt +++ b/modules/rostests/winetests/qedit/CMakeLists.txt @@ -1,6 +1,6 @@ add_definitions(-DUSE_WINE_TODOS) -add_executable(qedit_winetest mediadet.c testlist.c qedit.rc) +add_executable(qedit_winetest mediadet.c timeline.c testlist.c qedit.rc) set_module_type(qedit_winetest win32cui) add_importlibs(qedit_winetest oleaut32 ole32 msvcrt kernel32) add_rostests_file(TARGET qedit_winetest) diff --git a/modules/rostests/winetests/qedit/testlist.c b/modules/rostests/winetests/qedit/testlist.c index 7d6350bea9..bc74a29175 100644 --- a/modules/rostests/winetests/qedit/testlist.c +++ b/modules/rostests/winetests/qedit/testlist.c @@ -4,9 +4,11 @@ #include <wine/test.h> extern void func_mediadet(void); +extern void func_timeline(void); const struct test winetest_testlist[] = { { "mediadet", func_mediadet }, + { "timeline", func_timeline }, { 0, 0 } }; diff --git a/modules/rostests/winetests/qedit/timeline.c b/modules/rostests/winetests/qedit/timeline.c new file mode 100644 index 0000000000..40cf774ecd --- /dev/null +++ b/modules/rostests/winetests/qedit/timeline.c @@ -0,0 +1,116 @@ +/* + * Unit tests for Timeline + * + * Copyright (C) 2016 Alex Henrie + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define COBJMACROS +#define CONST_VTABLE + +#include "wine/test.h" +#include "qedit.h" + +static void test_timeline(void) +{ + HRESULT hr; + IAMTimeline *timeline = NULL; + IAMTimeline *timeline2 = (IAMTimeline *)0xdeadbeef; + IAMTimelineObj *obj = (IAMTimelineObj *)0xdeadbeef; + IAMTimelineObj obj_iface; + TIMELINE_MAJOR_TYPE type; + + hr = CoCreateInstance(&CLSID_AMTimeline, NULL, CLSCTX_INPROC_SERVER, &IID_IAMTimeline, (void **)&timeline); + ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG), "CoCreateInstance failed: %08x\n", hr); + if (!timeline) return; + + hr = IAMTimeline_QueryInterface(timeline, &IID_IAMTimelineObj, NULL); + ok(hr == E_POINTER, "Expected E_POINTER got %08x\n", hr); + + hr = IAMTimeline_QueryInterface(timeline, &IID_IAMTimelineObj, (void **)&obj); + ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE got %08x\n", hr); + ok(!obj, "Expected NULL got %p\n", obj); + + hr = IAMTimeline_CreateEmptyNode(timeline, NULL, 0); + ok(hr == E_POINTER, "Expected E_POINTER got %08x\n", hr); + + hr = IAMTimeline_CreateEmptyNode(timeline, NULL, TIMELINE_MAJOR_TYPE_COMPOSITE); + ok(hr == E_POINTER, "Expected E_POINTER got %08x\n", hr); + + for (type = 0; type < 256; type++) + { + obj = &obj_iface; + hr = IAMTimeline_CreateEmptyNode(timeline, &obj, type); + switch (type) + { + case TIMELINE_MAJOR_TYPE_COMPOSITE: + case TIMELINE_MAJOR_TYPE_TRACK: + case TIMELINE_MAJOR_TYPE_SOURCE: + case TIMELINE_MAJOR_TYPE_TRANSITION: + case TIMELINE_MAJOR_TYPE_EFFECT: + case TIMELINE_MAJOR_TYPE_GROUP: + ok(hr == S_OK, "CreateEmptyNode failed: %08x\n", hr); + if (obj != &obj_iface) IAMTimelineObj_Release(obj); + break; + default: + ok(hr == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", hr); + ok(obj == &obj_iface, "Expected %p got %p\n", &obj_iface, obj); + } + } + + obj = NULL; + hr = IAMTimeline_CreateEmptyNode(timeline, &obj, TIMELINE_MAJOR_TYPE_COMPOSITE); + ok(hr == S_OK, "CreateEmptyNode failed: %08x\n", hr); + if (!obj) return; + + hr = IAMTimelineObj_QueryInterface(obj, &IID_IAMTimeline, NULL); + ok(hr == E_POINTER, "Expected E_POINTER got %08x\n", hr); + + hr = IAMTimelineObj_QueryInterface(obj, &IID_IAMTimeline, (void **)&timeline2); + ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE got %08x\n", hr); + ok(!timeline2, "Expected NULL got %p\n", timeline2); + + hr = IAMTimelineObj_GetTimelineType(obj, NULL); + ok(hr == E_POINTER, "Expected E_POINTER got %08x\n", hr); + + hr = IAMTimelineObj_GetTimelineType(obj, &type); + ok(hr == S_OK, "GetTimelineType failed: %08x\n", hr); + ok(type == TIMELINE_MAJOR_TYPE_COMPOSITE, "Expected TIMELINE_MAJOR_TYPE_COMPOSITE got %d\n", type); + + for (type = 0; type < 256; type++) + { + hr = IAMTimelineObj_SetTimelineType(obj, type); + if (type == TIMELINE_MAJOR_TYPE_COMPOSITE) + ok(hr == S_OK, "SetTimelineType failed: %08x\n", hr); + else + ok(hr == E_INVALIDARG, "Expected E_INVALIDARG got %08x\n", hr); + } + + hr = IAMTimelineObj_GetTimelineNoRef(obj, NULL); + ok(hr == E_POINTER, "Expected E_POINTER got %08x\n", hr); + + timeline2 = (IAMTimeline *)0xdeadbeef; + hr = IAMTimelineObj_GetTimelineNoRef(obj, &timeline2); + ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE got %08x\n", hr); + ok(!timeline2, "Expected NULL got %p\n", timeline2); +} + +START_TEST(timeline) +{ + CoInitialize(NULL); + test_timeline(); + CoUninitialize(); +}

6 years, 11 months

[reactos] 01/01: [PSAPI_WINETEST] Sync with Wine Staging 2.16. CORE-13762

by Amine Khaldi

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=bff534936af398e6a6c0a… commit bff534936af398e6a6c0ac73c8e93a6b11b7c268 Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Sat Oct 21 13:24:28 2017 +0100 [PSAPI_WINETEST] Sync with Wine Staging 2.16. CORE-13762 --- modules/rostests/winetests/psapi/psapi_main.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/modules/rostests/winetests/psapi/psapi_main.c b/modules/rostests/winetests/psapi/psapi_main.c index 5869866553..b02c7a0f06 100644 --- a/modules/rostests/winetests/psapi/psapi_main.c +++ b/modules/rostests/winetests/psapi/psapi_main.c @@ -149,6 +149,7 @@ static void test_EnumProcessModules(void) static void test_GetModuleInformation(void) { HMODULE hMod = GetModuleHandleA(NULL); + DWORD *tmp, counter = 0; MODULEINFO info; DWORD ret; @@ -168,10 +169,21 @@ static void test_GetModuleInformation(void) pGetModuleInformation(hpQV, hMod, &info, sizeof(info)-1); ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError()); - SetLastError(0xdeadbeef); ret = pGetModuleInformation(hpQV, hMod, &info, sizeof(info)); ok(ret == 1, "failed with %d\n", GetLastError()); ok(info.lpBaseOfDll == hMod, "lpBaseOfDll=%p hMod=%p\n", info.lpBaseOfDll, hMod); + + hMod = LoadLibraryA("shell32.dll"); + ok(hMod != NULL, "Failed to load shell32.dll, error: %u\n", GetLastError()); + + ret = pGetModuleInformation(hpQV, hMod, &info, sizeof(info)); + ok(ret == 1, "failed with %d\n", GetLastError()); + info.SizeOfImage /= sizeof(DWORD); + for (tmp = (DWORD *)hMod; info.SizeOfImage; info.SizeOfImage--) + counter ^= *tmp++; + trace("xor of shell32: %08x\n", counter); + + FreeLibrary(hMod); } static BOOL check_with_margin(SIZE_T perf, SIZE_T sysperf, int margin)

6 years, 11 months

[reactos] 01/01: [OPENGL32_WINETEST] Sync with Wine Staging 2.16. CORE-13762

by Amine Khaldi

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3ce9d8ab17cb861050e57… commit 3ce9d8ab17cb861050e57d7004058bc311fa5ed5 Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Sat Oct 21 13:19:43 2017 +0100 [OPENGL32_WINETEST] Sync with Wine Staging 2.16. CORE-13762 --- modules/rostests/winetests/opengl32/opengl.c | 142 ++++++++++++++++++++++++++- 1 file changed, 140 insertions(+), 2 deletions(-) diff --git a/modules/rostests/winetests/opengl32/opengl.c b/modules/rostests/winetests/opengl32/opengl.c index 3e6441c056..346b89d45a 100644 --- a/modules/rostests/winetests/opengl32/opengl.c +++ b/modules/rostests/winetests/opengl32/opengl.c @@ -242,6 +242,118 @@ static void test_pbuffers(HDC hdc) else skip("Pbuffer test for offscreen pixelformat skipped as no offscreen-only format with pbuffer capabilities has been found\n"); } +static int test_pfd(const PIXELFORMATDESCRIPTOR *pfd, PIXELFORMATDESCRIPTOR *fmt) +{ + int pf; + HDC hdc; + HWND hwnd; + + hwnd = CreateWindowA("static", "Title", WS_OVERLAPPEDWINDOW, 10, 10, 200, 200, NULL, NULL, + NULL, NULL); + if (!hwnd) + return 0; + + hdc = GetDC( hwnd ); + pf = ChoosePixelFormat( hdc, pfd ); + if (pf && fmt) + { + memset(fmt, 0, sizeof(*fmt)); + ok(DescribePixelFormat( hdc, pf, sizeof(*fmt), fmt ), + "DescribePixelFormat failed with error: %u\n", GetLastError()); + } + ReleaseDC( hwnd, hdc ); + DestroyWindow( hwnd ); + + return pf; +} + +static void test_choosepixelformat(void) +{ + PIXELFORMATDESCRIPTOR pfd = { + sizeof(PIXELFORMATDESCRIPTOR), + 1, /* version */ + PFD_DRAW_TO_WINDOW | + PFD_SUPPORT_OPENGL | + PFD_TYPE_RGBA, + 0, /* color depth */ + 0, 0, 0, 0, 0, 0, /* color bits */ + 0, /* alpha buffer */ + 0, /* shift bit */ + 0, /* accumulation buffer */ + 0, 0, 0, 0, /* accum bits */ + 0, /* z-buffer */ + 0, /* stencil buffer */ + 0, /* auxiliary buffer */ + PFD_MAIN_PLANE, /* main layer */ + 0, /* reserved */ + 0, 0, 0 /* layer masks */ + }; + PIXELFORMATDESCRIPTOR ret_fmt; + + ok( test_pfd(&pfd, NULL), "Simple pfd failed\n" ); + pfd.dwFlags |= PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE failed\n" ); + pfd.dwFlags |= PFD_STEREO_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE|PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_STEREO_DONTCARE; + pfd.iPixelType = 32; + ok( test_pfd(&pfd, &ret_fmt), "Invalid pixel format 32 failed\n" ); + ok( ret_fmt.iPixelType == PFD_TYPE_RGBA, "Expected pixel type PFD_TYPE_RGBA, got %d\n", ret_fmt.iPixelType ); + pfd.iPixelType = 33; + ok( test_pfd(&pfd, &ret_fmt), "Invalid pixel format 33 failed\n" ); + ok( ret_fmt.iPixelType == PFD_TYPE_RGBA, "Expected pixel type PFD_TYPE_RGBA, got %d\n", ret_fmt.iPixelType ); + pfd.iPixelType = 15; + ok( test_pfd(&pfd, &ret_fmt), "Invalid pixel format 15 failed\n" ); + ok( ret_fmt.iPixelType == PFD_TYPE_RGBA, "Expected pixel type PFD_TYPE_RGBA, got %d\n", ret_fmt.iPixelType ); + pfd.iPixelType = PFD_TYPE_RGBA; + + pfd.cColorBits = 32; + ok( test_pfd(&pfd, NULL), "Simple pfd failed\n" ); + pfd.dwFlags |= PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE failed\n" ); + pfd.dwFlags |= PFD_STEREO_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE|PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_STEREO_DONTCARE; + pfd.cColorBits = 0; + + pfd.cAlphaBits = 8; + ok( test_pfd(&pfd, NULL), "Simple pfd failed\n" ); + pfd.dwFlags |= PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE failed\n" ); + pfd.dwFlags |= PFD_STEREO_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE|PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_STEREO_DONTCARE; + pfd.cAlphaBits = 0; + + pfd.cStencilBits = 8; + ok( test_pfd(&pfd, NULL), "Simple pfd failed\n" ); + pfd.dwFlags |= PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE failed\n" ); + pfd.dwFlags |= PFD_STEREO_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE|PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_STEREO_DONTCARE; + pfd.cStencilBits = 0; + + pfd.cAuxBuffers = 1; + ok( test_pfd(&pfd, NULL), "Simple pfd failed\n" ); + pfd.dwFlags |= PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE failed\n" ); + pfd.dwFlags |= PFD_STEREO_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_DOUBLEBUFFER_DONTCARE|PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_DOUBLEBUFFER_DONTCARE; + ok( test_pfd(&pfd, NULL), "PFD_STEREO_DONTCARE failed\n" ); + pfd.dwFlags &= ~PFD_STEREO_DONTCARE; + pfd.cAuxBuffers = 0; +} + static void WINAPI gl_debug_message_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam) { @@ -345,6 +457,30 @@ static void test_setpixelformat(HDC winhdc) ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf ); ReleaseDC( hwnd, hdc ); DestroyWindow( hwnd ); + /* check various calls with invalid hdc */ + SetLastError( 0xdeadbeef ); + i = GetPixelFormat( hdc ); + ok( i == 0, "GetPixelFormat succeeded\n" ); + ok( GetLastError() == ERROR_INVALID_PIXEL_FORMAT, "wrong error %u\n", GetLastError() ); + SetLastError( 0xdeadbeef ); + res = SetPixelFormat( hdc, pf, &pfd ); + ok( i == 0, "SetPixelFormat succeeded\n" ); + ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() ); + SetLastError( 0xdeadbeef ); + res = DescribePixelFormat( hdc, 0, 0, NULL ); + ok( !res, "DescribePixelFormat succeeded\n" ); + ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() ); + SetLastError( 0xdeadbeef ); + pf = ChoosePixelFormat( hdc, &pfd ); + ok( !pf, "ChoosePixelFormat succeeded\n" ); + ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() ); + SetLastError( 0xdeadbeef ); + res = SwapBuffers( hdc ); + ok( !res, "SwapBuffers succeeded\n" ); + ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() ); + SetLastError( 0xdeadbeef ); + ok( !wglCreateContext( hdc ), "CreateContext succeeded\n" ); + ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() ); } hwnd = CreateWindowA("static", "Title", WS_OVERLAPPEDWINDOW, 10, 10, 200, 200, NULL, NULL, @@ -934,7 +1070,8 @@ static void test_opengl3(HDC hdc) gl3Ctx = pwglCreateContextAttribsARB((HDC)0xdeadbeef, 0, 0); ok(gl3Ctx == 0, "pwglCreateContextAttribsARB using an invalid HDC passed\n"); error = GetLastError(); - ok(error == ERROR_DC_NOT_FOUND || + ok(error == ERROR_DC_NOT_FOUND || error == ERROR_INVALID_HANDLE || + broken(error == ERROR_DS_GENERIC_ERROR) || broken(error == NVIDIA_HRESULT_FROM_WIN32(ERROR_INVALID_DATA)), /* Nvidia Vista + Win7 */ "Expected ERROR_DC_NOT_FOUND, got error=%x\n", error); wglDeleteContext(gl3Ctx); @@ -949,7 +1086,7 @@ static void test_opengl3(HDC hdc) ok(gl3Ctx == 0, "pwglCreateContextAttribsARB using an invalid shareList passed\n"); error = GetLastError(); /* The Nvidia implementation seems to return hresults instead of win32 error codes */ - ok(error == ERROR_INVALID_OPERATION || + ok(error == ERROR_INVALID_OPERATION || error == ERROR_INVALID_DATA || error == NVIDIA_HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION), "Expected ERROR_INVALID_OPERATION, got error=%x\n", error); wglDeleteContext(gl3Ctx); } @@ -1732,6 +1869,7 @@ START_TEST(opengl) return; } + test_choosepixelformat(); test_debug_message_callback(); test_setpixelformat(hdc); test_destroy(hdc);

6 years, 11 months

[reactos] 01/01: [CRT] Use MAX_PATH for buffer meant to contain an arbitrary path

by Samuel Serapion

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=136fabd357f973fa3f446… commit 136fabd357f973fa3f4465804728a14fc1aea025 Author: Samuel Serapion <samuel.serapion(a)gmail.com> AuthorDate: Fri Oct 20 11:03:07 2017 -0400 [CRT] Use MAX_PATH for buffer meant to contain an arbitrary path The cFileName member of WIN32_FIND_DATA is an array of MAX_PATH(260). Using strcpy/wcscpy with the target buffer being smaller is potentially bad. Corresponds to CID 1401198 and 1401195. --- sdk/lib/crt/misc/getargs.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sdk/lib/crt/misc/getargs.c b/sdk/lib/crt/misc/getargs.c index df20bb227c..1a8cf0fb9e 100644 --- a/sdk/lib/crt/misc/getargs.c +++ b/sdk/lib/crt/misc/getargs.c @@ -70,7 +70,7 @@ int wexpand(wchar_t* name, int expand_wildcards) WIN32_FIND_DATAW fd; HANDLE hFile; BOOLEAN first = TRUE; - wchar_t buffer[256]; + wchar_t buffer[MAX_PATH]; uintptr_t pos; if (expand_wildcards && (s = wcspbrk(name, L"*?"))) @@ -135,7 +135,7 @@ int aexpand(char* name, int expand_wildcards) WIN32_FIND_DATAA fd; HANDLE hFile; BOOLEAN first = TRUE; - char buffer[256]; + char buffer[MAX_PATH]; uintptr_t pos; if (expand_wildcards && (s = strpbrk(name, "*?")))

6 years, 11 months

[reactos] 01/01: [KERNEL32] Fix a FIXME in GetNamedPipeHandleStateW and stub a private function for a left unimplemented function

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=19cef7806c43e34a00e1e… commit 19cef7806c43e34a00e1eb13dbb9444e722249a8 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Mon Oct 23 14:36:18 2017 +0200 [KERNEL32] Fix a FIXME in GetNamedPipeHandleStateW and stub a private function for a left unimplemented function --- dll/win32/kernel32/client/file/npipe.c | 36 ++++++++++++++++++++++++++++------ 1 file changed, 30 insertions(+), 6 deletions(-) diff --git a/dll/win32/kernel32/client/file/npipe.c b/dll/win32/kernel32/client/file/npipe.c index ee341580c2..3ed0c555e3 100644 --- a/dll/win32/kernel32/client/file/npipe.c +++ b/dll/win32/kernel32/client/file/npipe.c @@ -20,6 +20,20 @@ LONG ProcessPipeId; /* FUNCTIONS ******************************************************************/ +static +BOOL +NpGetUserNamep(HANDLE hNamedPipe, + LPWSTR lpUserName, + DWORD nMaxUserNameSize) +{ + /* FIXME - open the thread token, call ImpersonateNamedPipeClient() and + retrieve the user name with GetUserName(), revert the impersonation + and finally restore the thread token */ + UNIMPLEMENTED; + return TRUE; +} + + /* * @implemented */ @@ -935,18 +949,28 @@ GetNamedPipeHandleStateW(HANDLE hNamedPipe, *lpMaxCollectionCount = RemoteInfo.MaximumCollectionCount; } - if(lpCollectDataTimeout != NULL) + if (lpCollectDataTimeout != NULL) { - /* FIXME */ - *lpCollectDataTimeout = 0; + LARGE_INTEGER CollectDataTime; + + /* Convert time and return it */ + RemoteInfo.CollectDataTime.QuadPart *= -1; + CollectDataTime = RtlExtendedLargeIntegerDivide(RemoteInfo.CollectDataTime, 10000, NULL); + /* In case of overflow, just return MAX - 1 */ + if (CollectDataTime.HighPart != 0) + { + *lpCollectDataTimeout = -2; + } + else + { + *lpCollectDataTimeout = CollectDataTime.LowPart; + } } } if (lpUserName != NULL) { - /* FIXME - open the thread token, call ImpersonateNamedPipeClient() and - retrieve the user name with GetUserName(), revert the impersonation - and finally restore the thread token */ + return NpGetUserNamep(hNamedPipe, lpUserName, nMaxUserNameSize); } return TRUE;

6 years, 11 months

[reactos] 01/01: [KERNEL32] Check Basep8BitStringToDynamicUnicodeString() return and only call -W in case of success CID 1419330

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3832f83a32040e17c1955… commit 3832f83a32040e17c195513f5671ecec2387e6b0 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Mon Oct 23 13:39:44 2017 +0200 [KERNEL32] Check Basep8BitStringToDynamicUnicodeString() return and only call -W in case of success CID 1419330 --- dll/win32/kernel32/client/file/npipe.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/dll/win32/kernel32/client/file/npipe.c b/dll/win32/kernel32/client/file/npipe.c index 535f648e59..ee341580c2 100644 --- a/dll/win32/kernel32/client/file/npipe.c +++ b/dll/win32/kernel32/client/file/npipe.c @@ -344,17 +344,18 @@ WINAPI WaitNamedPipeA(LPCSTR lpNamedPipeName, DWORD nTimeOut) { - BOOL r; + BOOL r = FALSE; UNICODE_STRING NameU; /* Convert the name to Unicode */ - Basep8BitStringToDynamicUnicodeString(&NameU, lpNamedPipeName); - - /* Call the Unicode API */ - r = WaitNamedPipeW(NameU.Buffer, nTimeOut); + if (Basep8BitStringToDynamicUnicodeString(&NameU, lpNamedPipeName)) + { + /* Call the Unicode API */ + r = WaitNamedPipeW(NameU.Buffer, nTimeOut); - /* Free the Unicode string */ - RtlFreeUnicodeString(&NameU); + /* Free the Unicode string */ + RtlFreeUnicodeString(&NameU); + } /* Return result */ return r;

6 years, 11 months

[reactos] 01/01: [KERNEL32] Check NtQueryInformationFile succeed before using its return. Also fix coding style CID 512966

by Pierre Schweitzer

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=19f1cd78c15f7bd300287… commit 19f1cd78c15f7bd3002871796d69a14711971e2d Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Mon Oct 23 12:36:43 2017 +0200 [KERNEL32] Check NtQueryInformationFile succeed before using its return. Also fix coding style CID 512966 --- dll/win32/kernel32/client/file/fileinfo.c | 134 +++++++++++++++++------------- 1 file changed, 77 insertions(+), 57 deletions(-) diff --git a/dll/win32/kernel32/client/file/fileinfo.c b/dll/win32/kernel32/client/file/fileinfo.c index 4b8df966c0..2721c82631 100644 --- a/dll/win32/kernel32/client/file/fileinfo.c +++ b/dll/win32/kernel32/client/file/fileinfo.c @@ -325,70 +325,90 @@ SetFilePointer(HANDLE hFile, BOOL WINAPI SetFilePointerEx(HANDLE hFile, - LARGE_INTEGER liDistanceToMove, - PLARGE_INTEGER lpNewFilePointer, - DWORD dwMoveMethod) + LARGE_INTEGER liDistanceToMove, + PLARGE_INTEGER lpNewFilePointer, + DWORD dwMoveMethod) { - FILE_POSITION_INFORMATION FilePosition; - FILE_STANDARD_INFORMATION FileStandard; - NTSTATUS errCode; - IO_STATUS_BLOCK IoStatusBlock; + NTSTATUS Status; + IO_STATUS_BLOCK IoStatusBlock; + FILE_POSITION_INFORMATION FilePosition; + FILE_STANDARD_INFORMATION FileStandard; - if(IsConsoleHandle(hFile)) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } + if (IsConsoleHandle(hFile)) + { + BaseSetLastNTError(STATUS_INVALID_HANDLE); + return FALSE; + } - switch(dwMoveMethod) - { - case FILE_CURRENT: - NtQueryInformationFile(hFile, - &IoStatusBlock, - &FilePosition, - sizeof(FILE_POSITION_INFORMATION), - FilePositionInformation); - FilePosition.CurrentByteOffset.QuadPart += liDistanceToMove.QuadPart; - break; - case FILE_END: - NtQueryInformationFile(hFile, - &IoStatusBlock, - &FileStandard, - sizeof(FILE_STANDARD_INFORMATION), - FileStandardInformation); - FilePosition.CurrentByteOffset.QuadPart = - FileStandard.EndOfFile.QuadPart + liDistanceToMove.QuadPart; - break; - case FILE_BEGIN: - FilePosition.CurrentByteOffset.QuadPart = liDistanceToMove.QuadPart; - break; - default: - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } + switch (dwMoveMethod) + { + case FILE_CURRENT: + { + Status = NtQueryInformationFile(hFile, &IoStatusBlock, + &FilePosition, + sizeof(FILE_POSITION_INFORMATION), + FilePositionInformation); + if (!NT_SUCCESS(Status)) + { + BaseSetLastNTError(Status); + return FALSE; + } + + FilePosition.CurrentByteOffset.QuadPart += liDistanceToMove.QuadPart; + break; + } - if(FilePosition.CurrentByteOffset.QuadPart < 0) - { - SetLastError(ERROR_NEGATIVE_SEEK); - return FALSE; - } + case FILE_END: + { + Status = NtQueryInformationFile(hFile, &IoStatusBlock, + &FileStandard, + sizeof(FILE_STANDARD_INFORMATION), + FileStandardInformation); + if (!NT_SUCCESS(Status)) + { + BaseSetLastNTError(Status); + return FALSE; + } + + FilePosition.CurrentByteOffset.QuadPart = FileStandard.EndOfFile.QuadPart + + liDistanceToMove.QuadPart; + break; + } - errCode = NtSetInformationFile(hFile, - &IoStatusBlock, - &FilePosition, - sizeof(FILE_POSITION_INFORMATION), - FilePositionInformation); - if (!NT_SUCCESS(errCode)) - { - BaseSetLastNTError(errCode); - return FALSE; - } + case FILE_BEGIN: + { + FilePosition.CurrentByteOffset.QuadPart = liDistanceToMove.QuadPart; + break; + } - if (lpNewFilePointer) - { + default: + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + } + + if (FilePosition.CurrentByteOffset.QuadPart < 0) + { + SetLastError(ERROR_NEGATIVE_SEEK); + return FALSE; + } + + Status = NtSetInformationFile(hFile, &IoStatusBlock, &FilePosition, + sizeof(FILE_POSITION_INFORMATION), + FilePositionInformation); + if (!NT_SUCCESS(Status)) + { + BaseSetLastNTError(Status); + return FALSE; + } + + if (lpNewFilePointer != NULL) + { *lpNewFilePointer = FilePosition.CurrentByteOffset; - } - return TRUE; + } + + return TRUE; }

6 years, 11 months

← Newer
1
...
4
5
6
7
8
9
10
...
28
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs October 2017