wine-devel May 2019

wine-devel@winehq.org

96 participants
789 discussions

[PATCH] mfplat: Add timestamp support for system time source.
by Nikolay Sivov 24 May '19

24 May '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mfplat/main.c | 81 +++++++++++++++----- dlls/mfplat/tests/mfplat.c | 152 +++++++++++++++++++++++++++++++++++++ 2 files changed, 216 insertions(+), 17 deletions(-) diff --git a/dlls/mfplat/main.c b/dlls/mfplat/main.c index 23f13afa3a..1009f4083b 100644 --- a/dlls/mfplat/main.c +++ b/dlls/mfplat/main.c @@ -18,6 +18,7 @@ #include <stdarg.h> #include <string.h> +#include <math.h> #define COBJMACROS #define NONAMELESSUNION @@ -57,9 +58,20 @@ struct system_time_source LONG refcount; MFCLOCK_STATE state; IMFClock *clock; + LONGLONG start_offset; + float rate; + int i_rate; CRITICAL_SECTION cs; }; +static void system_time_source_apply_rate(const struct system_time_source *source, LONGLONG *value) +{ + if (source->i_rate) + *value *= source->i_rate; + else + *value *= source->rate; +} + static struct system_time_source *impl_from_IMFPresentationTimeSource(IMFPresentationTimeSource *iface) { return CONTAINING_RECORD(iface, struct system_time_source, IMFPresentationTimeSource_iface); @@ -6736,11 +6748,26 @@ static HRESULT WINAPI system_time_source_GetClockCharacteristics(IMFPresentation static HRESULT WINAPI system_time_source_GetCorrelatedTime(IMFPresentationTimeSource *iface, DWORD reserved, LONGLONG *clock_time, MFTIME *system_time) { - FIXME("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time); + struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface); + HRESULT hr; - return E_NOTIMPL; -} + TRACE("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time); + EnterCriticalSection(&source->cs); + if (SUCCEEDED(hr = IMFClock_GetCorrelatedTime(source->clock, 0, clock_time, system_time))) + { + if (source->state == MFCLOCK_STATE_RUNNING) + { + system_time_source_apply_rate(source, clock_time); + *clock_time += source->start_offset; + } + else + *clock_time = source->start_offset; + } + LeaveCriticalSection(&source->cs); + + return hr; +} static HRESULT WINAPI system_time_source_GetContinuityKey(IMFPresentationTimeSource *iface, DWORD *key) { @@ -6870,11 +6897,13 @@ static HRESULT WINAPI system_time_source_sink_OnClockStart(IMFClockStateSink *if TRACE("%p, %s, %s.\n", iface, wine_dbgstr_longlong(system_time), wine_dbgstr_longlong(start_offset)); EnterCriticalSection(&source->cs); - hr = system_time_source_change_state(source, CLOCK_CMD_START); + if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_START))) + { + system_time_source_apply_rate(source, &system_time); + source->start_offset = -system_time + start_offset; + } LeaveCriticalSection(&source->cs); - /* FIXME: update timestamps */ - return hr; } @@ -6886,11 +6915,10 @@ static HRESULT WINAPI system_time_source_sink_OnClockStop(IMFClockStateSink *ifa TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(system_time)); EnterCriticalSection(&source->cs); - hr = system_time_source_change_state(source, CLOCK_CMD_STOP); + if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_STOP))) + source->start_offset = 0; LeaveCriticalSection(&source->cs); - /* FIXME: update timestamps */ - return hr; } @@ -6902,11 +6930,13 @@ static HRESULT WINAPI system_time_source_sink_OnClockPause(IMFClockStateSink *if TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(system_time)); EnterCriticalSection(&source->cs); - hr = system_time_source_change_state(source, CLOCK_CMD_PAUSE); + if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_PAUSE))) + { + system_time_source_apply_rate(source, &system_time); + source->start_offset += system_time; + } LeaveCriticalSection(&source->cs); - /* FIXME: update timestamps */ - return hr; } @@ -6918,19 +6948,34 @@ static HRESULT WINAPI system_time_source_sink_OnClockRestart(IMFClockStateSink * TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(system_time)); EnterCriticalSection(&source->cs); - hr = system_time_source_change_state(source, CLOCK_CMD_RESTART); + if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_RESTART))) + { + system_time_source_apply_rate(source, &system_time); + source->start_offset -= system_time; + } LeaveCriticalSection(&source->cs); - /* FIXME: update timestamps */ - return hr; } static HRESULT WINAPI system_time_source_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME system_time, float rate) { - FIXME("%p, %s, %f.\n", iface, wine_dbgstr_longlong(system_time), rate); + struct system_time_source *source = impl_from_IMFClockStateSink(iface); + double intpart; - return E_NOTIMPL; + TRACE("%p, %s, %f.\n", iface, wine_dbgstr_longlong(system_time), rate); + + if (rate == 0.0f) + return MF_E_UNSUPPORTED_RATE; + + modf(rate, &intpart); + + EnterCriticalSection(&source->cs); + source->rate = rate; + source->i_rate = rate == intpart ? rate : 0; + LeaveCriticalSection(&source->cs); + + return S_OK; } static const IMFClockStateSinkVtbl systemtimesourcesinkvtbl = @@ -6962,6 +7007,8 @@ HRESULT WINAPI MFCreateSystemTimeSource(IMFPresentationTimeSource **time_source) object->IMFPresentationTimeSource_iface.lpVtbl = &systemtimesourcevtbl; object->IMFClockStateSink_iface.lpVtbl = &systemtimesourcesinkvtbl; object->refcount = 1; + object->rate = 1.0f; + object->i_rate = 1; InitializeCriticalSection(&object->cs); if (FAILED(hr = create_system_clock(&object->clock))) diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c index e385987f33..295863716b 100644 --- a/dlls/mfplat/tests/mfplat.c +++ b/dlls/mfplat/tests/mfplat.c @@ -2675,6 +2675,158 @@ static void test_system_time_source(void) IMFClock_Release(clock); + /* Test returned time regarding specified rate and offset. */ + hr = IMFPresentationTimeSource_QueryInterface(time_source, &IID_IMFClockStateSink, (void **)&statesink); + ok(hr == S_OK, "Failed to get sink interface, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetState(time_source, 0, &state); + ok(hr == S_OK, "Failed to get state %#x.\n", hr); + ok(state == MFCLOCK_STATE_STOPPED, "Unexpected state %d.\n", state); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 0, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockStart(statesink, 0, 0); + ok(hr == S_OK, "Failed to start source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == systime, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockStart(statesink, 0, 1); + ok(hr == S_OK, "Failed to start source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == systime + 1, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockPause(statesink, 2); + ok(hr == S_OK, "Failed to pause source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 3, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockRestart(statesink, 5); + ok(hr == S_OK, "Failed to restart source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == systime - 2, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockPause(statesink, 0); + ok(hr == S_OK, "Failed to pause source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == -2, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockStop(statesink, 123); + ok(hr == S_OK, "Failed to stop source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 0, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), wine_dbgstr_longlong(systime)); + + /* Increased rate. */ + hr = IMFClockStateSink_OnClockSetRate(statesink, 0, 2.0f); + ok(hr == S_OK, "Failed to set rate, hr %#x.\n", hr); + + hr = IMFClockStateSink_OnClockStart(statesink, 0, 0); + ok(hr == S_OK, "Failed to start source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 2 * systime, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(2 * systime)); + + hr = IMFClockStateSink_OnClockStart(statesink, 0, 10); + ok(hr == S_OK, "Failed to start source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 2 * systime + 10, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(2 * systime)); + + hr = IMFClockStateSink_OnClockPause(statesink, 2); + ok(hr == S_OK, "Failed to pause source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 10 + 2 * 2, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockRestart(statesink, 5); + ok(hr == S_OK, "Failed to restart source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 2 * systime + 14 - 5 * 2, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockPause(statesink, 0); + ok(hr == S_OK, "Failed to pause source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 4, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockStop(statesink, 123); + ok(hr == S_OK, "Failed to stop source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 0, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), wine_dbgstr_longlong(systime)); + IMFClockStateSink_Release(statesink); + + hr = IMFClockStateSink_OnClockStart(statesink, 10, 0); + ok(hr == S_OK, "Failed to start source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 2 * systime - 2 * 10, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(2 * systime)); + + hr = IMFClockStateSink_OnClockStop(statesink, 123); + ok(hr == S_OK, "Failed to stop source, hr %#x.\n", hr); + + hr = IMFClockStateSink_OnClockStart(statesink, 10, 20); + ok(hr == S_OK, "Failed to start source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 2 * systime, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(2 * systime)); + + hr = IMFClockStateSink_OnClockPause(statesink, 2); + ok(hr == S_OK, "Failed to pause source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 2 * 2, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockRestart(statesink, 5); + ok(hr == S_OK, "Failed to restart source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == 2 * systime + 4 - 5 * 2, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(systime)); + + hr = IMFClockStateSink_OnClockPause(statesink, 0); + ok(hr == S_OK, "Failed to pause source, hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetCorrelatedTime(time_source, 0, &time, &systime); + ok(hr == S_OK, "Failed to get time %#x.\n", hr); + ok(time == -6, "Unexpected time stamp %s, %s.\n", wine_dbgstr_longlong(time), + wine_dbgstr_longlong(systime)); + IMFPresentationTimeSource_Release(time_source); } -- 2.20.1

1 0

[PATCH 1/2] kernel32/tests: Add NtAllocateVirtualMemory tests for ZeroBits behavior
by Rémi Bernon 24 May '19

24 May '19

The ZeroBits parameter doesn't behave as expected, and some 64bit code use it to allocate memory in the lower 32bit address space. The expected full behaviour is: * ZeroBits == 0: no constraint on address range * 0 < ZeroBits <= 15: returned address should have as many upper bits set to 0, starting at bit 31. In 64bit mode, upper 64bits should all be 0 as well. * 15 < ZeroBits <= 31: unsure, but probably same as ZeroBits == 15. * ZeroBits > 31: (64bit/WoW64 only) ZeroBits behaves as a bitmask, as if it was set to the number of leading 0 in the bitmask, works in the whole 64bit range. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/kernel32/tests/virtual.c | 72 +++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/dlls/kernel32/tests/virtual.c b/dlls/kernel32/tests/virtual.c index 474955630fd..c6a9f34954a 100644 --- a/dlls/kernel32/tests/virtual.c +++ b/dlls/kernel32/tests/virtual.c @@ -228,10 +228,12 @@ static void test_VirtualAllocEx(void) static void test_VirtualAlloc(void) { void *addr1, *addr2; + UINT_PTR mask; DWORD old_prot; MEMORY_BASIC_INFORMATION info; NTSTATUS status; SIZE_T size; + BOOL is_wow64; SetLastError(0xdeadbeef); addr1 = VirtualAlloc(0, 0, MEM_RESERVE, PAGE_NOACCESS); @@ -473,6 +475,76 @@ static void test_VirtualAlloc(void) ok(status == STATUS_INVALID_PARAMETER_3, "NtAllocateVirtualMemory returned %08x\n", status); if (status == STATUS_SUCCESS) ok(VirtualFree(addr2, 0, MEM_RELEASE), "VirtualFree failed\n"); + /* 1 zero bits should zero 63-31 upper bits */ + size = 0x1000; + addr2 = NULL; + mask = 0xffffffff8000ffffull; + status = pNtAllocateVirtualMemory(GetCurrentProcess(), &addr2, 1, &size, + MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); + ok((status == STATUS_SUCCESS || broken(status == STATUS_INVALID_PARAMETER_3) /* winxp */) + && ((uintptr_t)addr2 & mask) == 0, + "NtAllocateVirtualMemory returned %08x, addr2: %x, mask: %x\n", status, addr2, mask); + if (status == STATUS_SUCCESS) + { + size = 0; + status = pNtFreeVirtualMemory(GetCurrentProcess(), &addr2, &size, MEM_RELEASE); + ok(status == STATUS_SUCCESS, "pNtFreeVirtualMemory return %08x, addr2: %p\n", status, addr2); + } + + /* 2 zero bits should zero 63-31 upper bits */ + size = 0x1000; + addr2 = NULL; + mask = 0xffffffff8000ffffull; + status = pNtAllocateVirtualMemory(GetCurrentProcess(), &addr2, 2, &size, + MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); + ok(status == STATUS_SUCCESS && ((uintptr_t)addr2 & mask) == 0, + "NtAllocateVirtualMemory returned %08x, addr2: %x, mask: %x\n", status, addr2, mask); + if (status == STATUS_SUCCESS) + { + size = 0; + status = pNtFreeVirtualMemory(GetCurrentProcess(), &addr2, &size, MEM_RELEASE); + ok(status == STATUS_SUCCESS, "pNtFreeVirtualMemory return %08x, addr2: %p\n", status, addr2); + } + + /* 15 zero bits should zero 63-17 upper bits */ + size = 0x1000; + addr2 = NULL; + mask = 0xfffffffffff7ffffull; + status = pNtAllocateVirtualMemory(GetCurrentProcess(), &addr2, 15, &size, + MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); + ok((status == STATUS_SUCCESS || status == STATUS_NO_MEMORY) && ((uintptr_t)addr2 & mask) == 0, + "NtAllocateVirtualMemory returned %08x, addr2: %x, mask: %x\n", status, addr2, mask); + if (status == STATUS_SUCCESS) + { + size = 0; + status = pNtFreeVirtualMemory(GetCurrentProcess(), &addr2, &size, MEM_RELEASE); + ok(status == STATUS_SUCCESS, "pNtFreeVirtualMemory return %08x, addr2: %p\n", status, addr2); + } + + /* zero bits > 31 should be considered as bitmask on 64bit and WoW64 */ + size = 0x1000; + addr2 = NULL; + mask = 0xffffffff7000ffffull; + status = pNtAllocateVirtualMemory(GetCurrentProcess(), &addr2, 0x1fffffff, &size, + MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); + + if (sizeof(void *) == sizeof(int) && (!pIsWow64Process || + !pIsWow64Process( GetCurrentProcess(), &is_wow64 ) || !is_wow64)) + { + ok(status == STATUS_INVALID_PARAMETER_3, "NtAllocateVirtualMemory returned %08x\n", status); + } + else + { + ok(status == STATUS_SUCCESS && ((uintptr_t)addr2 & mask) == 0, + "NtAllocateVirtualMemory returned %08x, addr2: %x, mask: %x\n", status, addr2, mask); + if (status == STATUS_SUCCESS) + { + size = 0; + status = pNtFreeVirtualMemory(GetCurrentProcess(), &addr2, &size, MEM_RELEASE); + ok(status == STATUS_SUCCESS, "pNtFreeVirtualMemory return %08x, addr2: %p\n", status, addr2); + } + } + /* AT_ROUND_TO_PAGE flag is not supported for VirtualAlloc */ SetLastError(0xdeadbeef); addr2 = VirtualAlloc(addr1, 0x1000, MEM_RESERVE | MEM_COMMIT | AT_ROUND_TO_PAGE, PAGE_EXECUTE_READWRITE); -- 2.20.1

2 3

[PATCH 4/4] advapi32: Implement REG_MUI_STRING_TRUNCATE flag.
by Akihiro Sagawa 24 May '19

24 May '19

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/advapi32/registry.c | 21 ++++++++++++++++----- dlls/advapi32/tests/registry.c | 12 ++++++------ 2 files changed, 22 insertions(+), 11 deletions(-)

1 0

[PATCH 3/4] advapi32: Factor out load_mui_string().
by Akihiro Sagawa 24 May '19

24 May '19

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/advapi32/registry.c | 81 ++++++++++++++++++++++++++++++------------------ 1 file changed, 51 insertions(+), 30 deletions(-)

1 0

[PATCH 2/4] advapi32/tests: Add RegLoadMUIString tests with REG_MUI_STRING_TRUNCATE flag.
by Akihiro Sagawa 24 May '19

24 May '19

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/advapi32/tests/registry.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)

1 0

[PATCH 1/4] kernel32: Add traces to time zone functions.
by Akihiro Sagawa 24 May '19

24 May '19

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/kernel32/time.c | 7 +++++++ 1 file changed, 7 insertions(+)

1 0

[PATCH 1/3] kernelbase: Add remaining URL functions.
by Nikolay Sivov 24 May '19

24 May '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/kernelbase/kernelbase.spec | 12 +- dlls/kernelbase/path.c | 403 ++++++++++++++++++++++++++++++++ 2 files changed, 409 insertions(+), 6 deletions(-) diff --git a/dlls/kernelbase/kernelbase.spec b/dlls/kernelbase/kernelbase.spec index 193af89b43..7f48169745 100644 --- a/dlls/kernelbase/kernelbase.spec +++ b/dlls/kernelbase/kernelbase.spec @@ -771,7 +771,7 @@ @ stdcall GlobalMemoryStatusEx(ptr) kernel32.GlobalMemoryStatusEx # @ stub GuardCheckLongJumpTarget # @ stub HasPolicyForegroundProcessingCompletedInternal -@ stdcall HashData(ptr long ptr long) shlwapi.HashData +@ stdcall HashData(ptr long ptr long) @ stdcall HeapAlloc(long long long) kernel32.HeapAlloc @ stdcall HeapCompact(long long) kernel32.HeapCompact @ stdcall HeapCreate(long long long) kernel32.HeapCreate @@ -861,7 +861,7 @@ # @ stub IsDeveloperModePolicyApplied # @ stub IsEnclaveTypeSupported # @ stub IsGlobalizationUserSettingsKeyRedirected -@ stdcall IsInternetESCEnabled() shlwapi.IsInternetESCEnabled +@ stdcall IsInternetESCEnabled() @ stub IsNLSDefinedString @ stdcall IsNormalizedString(long wstr long) kernel32.IsNormalizedString # @ stub IsProcessCritical @@ -1632,8 +1632,8 @@ @ stdcall UrlApplySchemeW(wstr ptr ptr long) @ stdcall UrlCanonicalizeA(str ptr ptr long) @ stdcall UrlCanonicalizeW(wstr ptr ptr long) -@ stdcall UrlCombineA(str str ptr ptr long) shlwapi.UrlCombineA -@ stdcall UrlCombineW(wstr wstr ptr ptr long) shlwapi.UrlCombineW +@ stdcall UrlCombineA(str str ptr ptr long) +@ stdcall UrlCombineW(wstr wstr ptr ptr long) @ stdcall UrlCompareA(str str long) @ stdcall UrlCompareW(wstr wstr long) @ stdcall UrlCreateFromPathA(str ptr ptr long) @@ -1645,8 +1645,8 @@ @ stdcall UrlGetLocationW(wstr) @ stdcall UrlGetPartA(str ptr ptr long long) @ stdcall UrlGetPartW(wstr ptr ptr long long) -@ stdcall UrlHashA(str ptr long) shlwapi.UrlHashA -@ stdcall UrlHashW(wstr ptr long) shlwapi.UrlHashW +@ stdcall UrlHashA(str ptr long) +@ stdcall UrlHashW(wstr ptr long) @ stdcall UrlIsA(str long) @ stdcall UrlIsNoHistoryA(str) @ stdcall UrlIsNoHistoryW(wstr) diff --git a/dlls/kernelbase/path.c b/dlls/kernelbase/path.c index 76f8610956..767ae43d5a 100644 --- a/dlls/kernelbase/path.c +++ b/dlls/kernelbase/path.c @@ -36,6 +36,26 @@ WINE_DEFAULT_DEBUG_CHANNEL(path); static const char hexDigits[] = "0123456789ABCDEF"; +static const unsigned char hashdata_lookup[256] = +{ + 0x01, 0x0e, 0x6e, 0x19, 0x61, 0xae, 0x84, 0x77, 0x8a, 0xaa, 0x7d, 0x76, 0x1b, 0xe9, 0x8c, 0x33, + 0x57, 0xc5, 0xb1, 0x6b, 0xea, 0xa9, 0x38, 0x44, 0x1e, 0x07, 0xad, 0x49, 0xbc, 0x28, 0x24, 0x41, + 0x31, 0xd5, 0x68, 0xbe, 0x39, 0xd3, 0x94, 0xdf, 0x30, 0x73, 0x0f, 0x02, 0x43, 0xba, 0xd2, 0x1c, + 0x0c, 0xb5, 0x67, 0x46, 0x16, 0x3a, 0x4b, 0x4e, 0xb7, 0xa7, 0xee, 0x9d, 0x7c, 0x93, 0xac, 0x90, + 0xb0, 0xa1, 0x8d, 0x56, 0x3c, 0x42, 0x80, 0x53, 0x9c, 0xf1, 0x4f, 0x2e, 0xa8, 0xc6, 0x29, 0xfe, + 0xb2, 0x55, 0xfd, 0xed, 0xfa, 0x9a, 0x85, 0x58, 0x23, 0xce, 0x5f, 0x74, 0xfc, 0xc0, 0x36, 0xdd, + 0x66, 0xda, 0xff, 0xf0, 0x52, 0x6a, 0x9e, 0xc9, 0x3d, 0x03, 0x59, 0x09, 0x2a, 0x9b, 0x9f, 0x5d, + 0xa6, 0x50, 0x32, 0x22, 0xaf, 0xc3, 0x64, 0x63, 0x1a, 0x96, 0x10, 0x91, 0x04, 0x21, 0x08, 0xbd, + 0x79, 0x40, 0x4d, 0x48, 0xd0, 0xf5, 0x82, 0x7a, 0x8f, 0x37, 0x69, 0x86, 0x1d, 0xa4, 0xb9, 0xc2, + 0xc1, 0xef, 0x65, 0xf2, 0x05, 0xab, 0x7e, 0x0b, 0x4a, 0x3b, 0x89, 0xe4, 0x6c, 0xbf, 0xe8, 0x8b, + 0x06, 0x18, 0x51, 0x14, 0x7f, 0x11, 0x5b, 0x5c, 0xfb, 0x97, 0xe1, 0xcf, 0x15, 0x62, 0x71, 0x70, + 0x54, 0xe2, 0x12, 0xd6, 0xc7, 0xbb, 0x0d, 0x20, 0x5e, 0xdc, 0xe0, 0xd4, 0xf7, 0xcc, 0xc4, 0x2b, + 0xf9, 0xec, 0x2d, 0xf4, 0x6f, 0xb6, 0x99, 0x88, 0x81, 0x5a, 0xd9, 0xca, 0x13, 0xa5, 0xe7, 0x47, + 0xe6, 0x8e, 0x60, 0xe3, 0x3e, 0xb3, 0xf6, 0x72, 0xa2, 0x35, 0xa0, 0xd7, 0xcd, 0xb4, 0x2f, 0x6d, + 0x2c, 0x26, 0x1f, 0x95, 0x87, 0x00, 0xd8, 0x34, 0x3f, 0x17, 0x25, 0x45, 0x27, 0x75, 0x92, 0xb8, + 0xa3, 0xc8, 0xde, 0xeb, 0xf8, 0xf3, 0xdb, 0x0a, 0x98, 0x83, 0x7b, 0xe5, 0xcb, 0x4c, 0x78, 0xd1, +}; + struct parsed_url { const WCHAR *scheme; /* [out] start of scheme */ @@ -4699,3 +4719,386 @@ HRESULT WINAPI UrlCreateFromPathW(const WCHAR *path, WCHAR *url, DWORD *url_len, return hr; } + +HRESULT WINAPI UrlCombineA(const char *base, const char *relative, char *combined, DWORD *combined_len, DWORD flags) +{ + WCHAR *baseW, *relativeW, *combinedW; + DWORD len, len2; + HRESULT hr; + + TRACE("%s, %s, %d, %#x\n", debugstr_a(base), debugstr_a(relative), combined_len ? *combined_len : 0, flags); + + if (!base || !relative || !combined_len) + return E_INVALIDARG; + + baseW = heap_alloc(3 * INTERNET_MAX_URL_LENGTH * sizeof(WCHAR)); + relativeW = baseW + INTERNET_MAX_URL_LENGTH; + combinedW = relativeW + INTERNET_MAX_URL_LENGTH; + + MultiByteToWideChar(CP_ACP, 0, base, -1, baseW, INTERNET_MAX_URL_LENGTH); + MultiByteToWideChar(CP_ACP, 0, relative, -1, relativeW, INTERNET_MAX_URL_LENGTH); + len = *combined_len; + + hr = UrlCombineW(baseW, relativeW, combined ? combinedW : NULL, &len, flags); + if (hr != S_OK) + { + *combined_len = len; + heap_free(baseW); + return hr; + } + + len2 = WideCharToMultiByte(CP_ACP, 0, combinedW, len, NULL, 0, NULL, NULL); + if (len2 > *combined_len) + { + *combined_len = len2; + heap_free(baseW); + return E_POINTER; + } + WideCharToMultiByte(CP_ACP, 0, combinedW, len+1, combined, *combined_len + 1, NULL, NULL); + *combined_len = len2; + heap_free(baseW); + return S_OK; +} + +HRESULT WINAPI UrlCombineW(const WCHAR *baseW, const WCHAR *relativeW, WCHAR *combined, DWORD *combined_len, DWORD flags) +{ + static const WCHAR myfilestr[] = {'f','i','l','e',':','/','/','/','\0'}; + static const WCHAR fragquerystr[] = {'#','?',0}; + DWORD i, len, process_case = 0, myflags, sizeloc = 0; + LPWSTR work, preliminary, mbase, mrelative; + PARSEDURLW base, relative; + HRESULT hr; + + TRACE("%s, %s, %d, %#x\n", debugstr_w(baseW), debugstr_w(relativeW), combined_len ? *combined_len : 0, flags); + + if (!baseW || !relativeW || !combined_len) + return E_INVALIDARG; + + base.cbSize = sizeof(base); + relative.cbSize = sizeof(relative); + + /* Get space for duplicates of the input and the output */ + preliminary = heap_alloc(3 * INTERNET_MAX_URL_LENGTH * sizeof(WCHAR)); + mbase = preliminary + INTERNET_MAX_URL_LENGTH; + mrelative = mbase + INTERNET_MAX_URL_LENGTH; + *preliminary = '\0'; + + /* Canonicalize the base input prior to looking for the scheme */ + myflags = flags & (URL_DONT_SIMPLIFY | URL_UNESCAPE); + len = INTERNET_MAX_URL_LENGTH; + UrlCanonicalizeW(baseW, mbase, &len, myflags); + + /* Canonicalize the relative input prior to looking for the scheme */ + len = INTERNET_MAX_URL_LENGTH; + UrlCanonicalizeW(relativeW, mrelative, &len, myflags); + + /* See if the base has a scheme */ + if (ParseURLW(mbase, &base) != S_OK) + { + /* If base has no scheme return relative. */ + TRACE("no scheme detected in Base\n"); + process_case = 1; + } + else do + { + BOOL manual_search = FALSE; + + work = (LPWSTR)base.pszProtocol; + for (i = 0; i < base.cchProtocol; ++i) + work[i] = tolowerW(work[i]); + + /* mk is a special case */ + if (base.nScheme == URL_SCHEME_MK) + { + static const WCHAR wsz[] = {':',':',0}; + WCHAR *ptr = strstrW(base.pszSuffix, wsz); + if (ptr) + { + int delta; + + ptr += 2; + delta = ptr-base.pszSuffix; + base.cchProtocol += delta; + base.pszSuffix += delta; + base.cchSuffix -= delta; + } + } + else + { + /* get size of location field (if it exists) */ + work = (LPWSTR)base.pszSuffix; + sizeloc = 0; + if (*work++ == '/') + { + if (*work++ == '/') + { + /* At this point have start of location and + * it ends at next '/' or end of string. + */ + while (*work && (*work != '/')) work++; + sizeloc = (DWORD)(work - base.pszSuffix); + } + } + } + + /* If there is a '?', then the remaining part can only contain a + * query string or fragment, so start looking for the last leaf + * from the '?'. Otherwise, if there is a '#' and the characters + * immediately preceding it are ".htm[l]", then begin looking for + * the last leaf starting from the '#'. Otherwise the '#' is not + * meaningful and just start looking from the end. */ + if ((work = strpbrkW(base.pszSuffix + sizeloc, fragquerystr))) + { + static const WCHAR htmlW[] = {'.','h','t','m','l'}; + static const WCHAR htmW[] = {'.','h','t','m'}; + + if (*work == '?' || base.nScheme == URL_SCHEME_HTTP || base.nScheme == URL_SCHEME_HTTPS) + manual_search = TRUE; + else if (work - base.pszSuffix > ARRAY_SIZE(htmW)) + { + work -= ARRAY_SIZE(htmW); + if (!strncmpiW(work, htmW, ARRAY_SIZE(htmW))) + manual_search = TRUE; + work += ARRAY_SIZE(htmW); + } + + if (!manual_search && work - base.pszSuffix > ARRAY_SIZE(htmlW)) + { + work -= ARRAY_SIZE(htmlW); + if (!strncmpiW(work, htmlW, ARRAY_SIZE(htmlW))) + manual_search = TRUE; + work += ARRAY_SIZE(htmlW); + } + } + + if (manual_search) + { + /* search backwards starting from the current position */ + while (*work != '/' && work > base.pszSuffix + sizeloc) + --work; + base.cchSuffix = work - base.pszSuffix + 1; + } + else + { + /* search backwards starting from the end of the string */ + work = strrchrW((base.pszSuffix+sizeloc), '/'); + if (work) + { + len = (DWORD)(work - base.pszSuffix + 1); + base.cchSuffix = len; + } + else + base.cchSuffix = sizeloc; + } + + /* + * At this point: + * .pszSuffix points to location (starting with '//') + * .cchSuffix length of location (above) and rest less the last + * leaf (if any) + * sizeloc length of location (above) up to but not including + * the last '/' + */ + + if (ParseURLW(mrelative, &relative) != S_OK) + { + /* No scheme in relative */ + TRACE("no scheme detected in Relative\n"); + relative.pszSuffix = mrelative; /* case 3,4,5 depends on this */ + relative.cchSuffix = strlenW(mrelative); + if (*relativeW == ':') + { + /* Case that is either left alone or uses base. */ + if (flags & URL_PLUGGABLE_PROTOCOL) + { + process_case = 5; + break; + } + process_case = 1; + break; + } + if (isalnumW(*mrelative) && *(mrelative + 1) == ':') + { + /* case that becomes "file:///" */ + strcpyW(preliminary, myfilestr); + process_case = 1; + break; + } + if (*mrelative == '/' && *(mrelative+1) == '/') + { + /* Relative has location and the rest. */ + process_case = 3; + break; + } + if (*mrelative == '/') + { + /* Relative is root to location. */ + process_case = 4; + break; + } + if (*mrelative == '#') + { + if (!(work = strchrW(base.pszSuffix+base.cchSuffix, '#'))) + work = (LPWSTR)base.pszSuffix + strlenW(base.pszSuffix); + + memcpy(preliminary, base.pszProtocol, (work-base.pszProtocol)*sizeof(WCHAR)); + preliminary[work-base.pszProtocol] = '\0'; + process_case = 1; + break; + } + process_case = (*base.pszSuffix == '/' || base.nScheme == URL_SCHEME_MK) ? 5 : 3; + break; + } + else + { + work = (LPWSTR)relative.pszProtocol; + for (i = 0; i < relative.cchProtocol; ++i) + work[i] = tolowerW(work[i]); + } + + /* Handle cases where relative has scheme. */ + if ((base.cchProtocol == relative.cchProtocol) && !strncmpW(base.pszProtocol, relative.pszProtocol, base.cchProtocol)) + { + /* since the schemes are the same */ + if (*relative.pszSuffix == '/' && *(relative.pszSuffix+1) == '/') + { + /* Relative replaces location and what follows. */ + process_case = 3; + break; + } + if (*relative.pszSuffix == '/') + { + /* Relative is root to location */ + process_case = 4; + break; + } + /* replace either just location if base's location starts with a + * slash or otherwise everything */ + process_case = (*base.pszSuffix == '/') ? 5 : 1; + break; + } + + if (*relative.pszSuffix == '/' && *(relative.pszSuffix+1) == '/') + { + /* Relative replaces scheme, location, and following and handles PLUGGABLE */ + process_case = 2; + break; + } + process_case = 1; + break; + } while (FALSE); /* a little trick to allow easy exit from nested if's */ + + hr = S_OK; + switch (process_case) + { + case 1: + /* Return relative appended to whatever is in combined (which may the string "file:///" */ + strcatW(preliminary, mrelative); + break; + + case 2: + /* Relative replaces scheme and location */ + strcpyW(preliminary, mrelative); + break; + + case 3: + /* Return the base scheme with relative. Basically keeps the scheme and replaces the domain and following. */ + memcpy(preliminary, base.pszProtocol, (base.cchProtocol + 1)*sizeof(WCHAR)); + work = preliminary + base.cchProtocol + 1; + strcpyW(work, relative.pszSuffix); + break; + + case 4: + /* Return the base scheme and location but everything after the location is relative. (Replace document from root on.) */ + memcpy(preliminary, base.pszProtocol, (base.cchProtocol+1+sizeloc)*sizeof(WCHAR)); + work = preliminary + base.cchProtocol + 1 + sizeloc; + if (flags & URL_PLUGGABLE_PROTOCOL) + *(work++) = '/'; + strcpyW(work, relative.pszSuffix); + break; + + case 5: + /* Return the base without its document (if any) and append relative after its scheme. */ + memcpy(preliminary, base.pszProtocol, (base.cchProtocol + 1 + base.cchSuffix)*sizeof(WCHAR)); + work = preliminary + base.cchProtocol + 1 + base.cchSuffix - 1; + if (*work++ != '/') + *(work++) = '/'; + strcpyW(work, relative.pszSuffix); + break; + + default: + FIXME("Unexpected case %d.\n", process_case); + hr = E_INVALIDARG; + } + + if (hr == S_OK) + { + /* Reuse mrelative as temp storage as it's already allocated and not needed anymore */ + if (*combined_len == 0) + *combined_len = 1; + hr = UrlCanonicalizeW(preliminary, mrelative, combined_len, flags & ~URL_FILE_USE_PATHURL); + if (SUCCEEDED(hr) && combined) + lstrcpyW(combined, mrelative); + + TRACE("return-%d len=%d, %s\n", process_case, *combined_len, debugstr_w(combined)); + } + + heap_free(preliminary); + return hr; +} + +HRESULT WINAPI HashData(const unsigned char *src, DWORD src_len, unsigned char *dest, DWORD dest_len) +{ + INT src_count = src_len - 1, dest_count = dest_len - 1; + + if (!src || !dest) + return E_INVALIDARG; + + while (dest_count >= 0) + { + dest[dest_count] = (dest_count & 0xff); + dest_count--; + } + + while (src_count >= 0) + { + dest_count = dest_len - 1; + while (dest_count >= 0) + { + dest[dest_count] = hashdata_lookup[src[src_count] ^ dest[dest_count]]; + dest_count--; + } + src_count--; + } + + return S_OK; +} + +HRESULT WINAPI UrlHashA(const char *url, unsigned char *dest, DWORD dest_len) +{ + if (IsBadStringPtrA(url, -1) || IsBadWritePtr(dest, dest_len)) + return E_INVALIDARG; + + HashData((const BYTE *)url, (int)strlen(url), dest, dest_len); + return S_OK; +} + +HRESULT WINAPI UrlHashW(const WCHAR *url, unsigned char *dest, DWORD dest_len) +{ + char urlA[MAX_PATH]; + + TRACE("%s, %p, %d\n", debugstr_w(url), dest, dest_len); + + if (IsBadStringPtrW(url, -1) || IsBadWritePtr(dest, dest_len)) + return E_INVALIDARG; + + WideCharToMultiByte(CP_ACP, 0, url, -1, urlA, MAX_PATH, NULL, NULL); + HashData((const BYTE *)urlA, (int)strlen(urlA), dest, dest_len); + return S_OK; +} + +BOOL WINAPI IsInternetESCEnabled(void) +{ + FIXME(": stub\n"); + return FALSE; +} -- 2.20.1

1 2

[PATCH 3/3] server: Always block overlapped device requests until driver dispatches them.
by Jacek Caban 24 May '19

24 May '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/ntdll/file.c | 2 +- dlls/ntoskrnl.exe/tests/ntoskrnl.c | 18 ------------------ server/async.c | 21 +++++++++++++++++++++ server/device.c | 9 ++++++--- server/file.h | 1 + 5 files changed, 29 insertions(+), 22 deletions(-)

2 2

[PATCH v2 1/2] ntdll/directory: Add support for EXT4 case folding per directory
by Gabriel Ivăncescu 24 May '19

24 May '19

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=47099 Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- v2: Fix mistake with fstatat return value. This patch just adds support for the case-insensitive attribute on ext4 with newer kernels -- so it should be safe for upstream (barring stylistic and other changes). It has some conditional processing for perf reasons. Checking for the EXT4_CASEFOLD_FL attribute involves an ioctl, which operates on file descriptors, while all the former checks operated directly on the dir name (e.g. statfs). Obviously, it's best to avoid looking up the directory multiple times (also for correctness, so it refers to the same dir). So in the case that we *do* use a file descriptor, then use it (e.g. fstatfs) everywhere. However, to avoid a perf regression or downgrade on systems that don't support the EXT2_IOC_GETFLAGS ioctl (e.g. MacOS, FreeBSD), we continue using statfs and the like directly, this shaves off two syscalls (open/close). But in the case the EXT4_CASEFOLD_FL is not supported on Linux (i.e. on current kernels) or the directory doesn't have it (think of dirs outside drive_c), this will unfortunately involve a bit more syscalls now, because it has to open() and close() the fd. I'd really like if the fstatfs and fstatat can stay if we do use the fd, to somehow make it less impactful on current systems, so they won't have to lookup the directory again. So that's basically why the GET_DIR_CASE_SENSITIVITY_USE_FD constant is there. One last thing: as it is now, on Linux, we always set the EXT4_CASEFOLD_FL flag ourselves since it does no harm even if it's not supported. Thus, I can of course remove the .ciopfs old code and keep just the fstatat() call by assuming we always use fd on Linux, if you prefer it that way. I didn't remove it because I didn't want to "hardcode" this assumption, so I'm waiting for feedback. dlls/ntdll/directory.c | 66 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 63 insertions(+), 3 deletions(-) diff --git a/dlls/ntdll/directory.c b/dlls/ntdll/directory.c index bbdbbe9..e5fa48d 100644 --- a/dlls/ntdll/directory.c +++ b/dlls/ntdll/directory.c @@ -115,6 +115,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(file); /* just in case... */ #undef VFAT_IOCTL_READDIR_BOTH +#undef EXT2_IOC_GETFLAGS +#undef EXT4_CASEFOLD_FL #ifdef linux @@ -130,6 +132,12 @@ typedef struct /* Define the VFAT ioctl to get both short and long file names */ #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, KERNEL_DIRENT [2] ) +/* Define the ext2 ioctl for handling extra attributes */ +#define EXT2_IOC_GETFLAGS _IOR('f', 1, long) + +/* Case-insensitivity attribute */ +#define EXT4_CASEFOLD_FL 0x40000000 + #ifndef O_DIRECTORY # define O_DIRECTORY 0200000 /* must be directory */ #endif @@ -977,6 +985,25 @@ static char *get_device_mount_point( dev_t dev ) } +/*********************************************************************** + * get_dir_case_sensitivity_ioctl + * + * Checks if the specified directory is case sensitive or not. Uses ioctl(2). + */ +static int get_dir_case_sensitivity_ioctl(int fd) +{ +#define GET_DIR_CASE_SENSITIVITY_USE_FD 1 +#if defined(EXT2_IOC_GETFLAGS) && defined(EXT4_CASEFOLD_FL) + int flags; + if (ioctl(fd, EXT2_IOC_GETFLAGS, &flags) != -1 && (flags & EXT4_CASEFOLD_FL)) + return FALSE; +#else +#undef GET_DIR_CASE_SENSITIVITY_USE_FD +#define GET_DIR_CASE_SENSITIVITY_USE_FD 0 +#endif + return -1; +} + #if defined(HAVE_GETATTRLIST) && defined(ATTR_VOL_CAPABILITIES) && \ defined(VOL_CAPABILITIES_FORMAT) && defined(VOL_CAP_FMT_CASE_SENSITIVE) @@ -1115,12 +1142,16 @@ static int get_dir_case_sensitivity_attr( const char *dir ) * Checks if the volume containing the specified directory is case * sensitive or not. Uses statfs(2) or statvfs(2). */ -static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) +static BOOLEAN get_dir_case_sensitivity_stat( const char *dir, int fd ) { #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) struct statfs stfs; +#if GET_DIR_CASE_SENSITIVITY_USE_FD + if (fstatfs( fd, &stfs ) == -1) return FALSE; +#else if (statfs( dir, &stfs ) == -1) return FALSE; +#endif /* Assume these file systems are always case insensitive on Mac OS. * For FreeBSD, only assume CIOPFS is case insensitive (AFAIK, Mac OS * is the only UNIX that supports case-insensitive lookup). @@ -1157,7 +1188,11 @@ static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) #elif defined(__NetBSD__) struct statvfs stfs; +#if GET_DIR_CASE_SENSITIVITY_USE_FD + if (fstatvfs( fd, &stfs ) == -1) return FALSE; +#else if (statvfs( dir, &stfs ) == -1) return FALSE; +#endif /* Only assume CIOPFS is case insensitive. */ if (strcmp( stfs.f_fstypename, "fusefs" ) || strncmp( stfs.f_mntfromname, "ciopfs", 5 )) @@ -1170,7 +1205,11 @@ static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) char *cifile; /* Only assume CIOPFS is case insensitive. */ +#if GET_DIR_CASE_SENSITIVITY_USE_FD + if (fstatfs( fd, &stfs ) == -1) return FALSE; +#else if (statfs( dir, &stfs ) == -1) return FALSE; +#endif if (stfs.f_type != 0x65735546 /* FUSE_SUPER_MAGIC */) return TRUE; /* Normally, we'd have to parse the mtab to find out exactly what @@ -1180,6 +1219,13 @@ static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) * This will break if somebody puts a file named ".ciopfs" in a non- * CIOPFS directory. */ + if (GET_DIR_CASE_SENSITIVITY_USE_FD) + { + if (fstatat( fd, ".ciopfs", &st, AT_NO_AUTOMOUNT ) == 0) + return FALSE; + return TRUE; + } + cifile = RtlAllocateHeap( GetProcessHeap(), 0, strlen( dir )+sizeof("/.ciopfs") ); if (!cifile) return TRUE; strcpy( cifile, dir ); @@ -1205,12 +1251,26 @@ static BOOLEAN get_dir_case_sensitivity_stat( const char *dir ) */ static BOOLEAN get_dir_case_sensitivity( const char *dir ) { + int case_sensitive, fd = -1; + #if defined(HAVE_GETATTRLIST) && defined(ATTR_VOL_CAPABILITIES) && \ defined(VOL_CAPABILITIES_FORMAT) && defined(VOL_CAP_FMT_CASE_SENSITIVE) - int case_sensitive = get_dir_case_sensitivity_attr( dir ); + case_sensitive = get_dir_case_sensitivity_attr( dir ); if (case_sensitive != -1) return case_sensitive; #endif - return get_dir_case_sensitivity_stat( dir ); + + if (GET_DIR_CASE_SENSITIVITY_USE_FD) + { + if ((fd = open(dir, O_RDONLY | O_NONBLOCK | O_LARGEFILE)) == -1) + return TRUE; + if ((case_sensitive = get_dir_case_sensitivity_ioctl(fd)) != -1) + goto end; + } + case_sensitive = get_dir_case_sensitivity_stat(dir, fd); + +end: + if (GET_DIR_CASE_SENSITIVITY_USE_FD) close(fd); + return case_sensitive; } -- 2.21.0

3 6

Syscall thunks in ntoskrnl
by Derek Lesho 24 May '19

24 May '19

Hello, I have written some prototype patches that allow EasyAntiCheat.sys's syscall scanner to succeed, but the aren't clean and I'd like some direction on which path I should take for the patch I end up submitting here. Somebody on github has gone through the effort of reverse engineering this check already, and you can find that code here: https://github.com/adrianyy/EACReversing/blob/master/EasyAntiCheat.sys/serv… As you can see, the driver reads a ntoskrnl's Zw* syscall export, replaces the syscall id operand with the one it found from reading ntdll, and scans the section for the right appropriate Zw function. For this to work, we need to have the ids from the syscall thunks that exist in ntdll (on staging from the fake-dlls patchset) match the ids in the thunks we add for the Zw* functions in ntoskrnl. There are a couple ways of doing this, at first I manually put in the assembly to see if it would work, and it did, but that's a clean solution. My current solution adds all Zw exports from ntdll.spec to ntoskrnl.exe.spec and has winebuild generate the exports in alphabetical order, but this solution requires that ntdll.spec and ntoskrnl.exe.spec be kept in sync, which I'm not sure is a good idea. Another solution I thought of is having a syscall table be read by winebuild, so that ntoskrnl and ntdll can export different syscall numbers and still share the same ids, but maybe this is over-engineering the problem. Thank you all for your input!

2 2

← Newer
1
...
14
15
16
17
18
19
20
...
79
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel May 2019