If a Windows program writes a registry key of type REG_DWORD but puts more than 4 bytes of data in—I can't imagine why, but I am working with such a program—currently it is persisted as-is in the `WINEPATH` but `regedit` exports it as a `dword:%08x`, truncating the data.
This patch makes sure that only 4-byte DWORDs are exported as `dword:`; any other size falls through as a `hex(4):`.
(I chose to use the literal `4` here instead of `sizeof(DWORD)` because this value isn't directly coupled to the size of a `DWORD` as the compiler sees it; in the (extremely hypothetical?) world in which Wine is compiled with a `DWORD` of some other size, this value should still be 4, because `export_dword_data` will only correctly export something that can be represented in 8 hexadecimal characters.)
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3793
Rainbow 6 Siege and some other games require this. Type is printed in the FIXME to determine which type the application requires.
--
v4: gdi32: Add stub for D3DKMTQueryAdapterInfo.
https://gitlab.winehq.org/wine/wine/-/merge_requests/3777
Based on a finding here: https://github.com/ValveSoftware/Proton/issues/6709#issuecomment-1626059391
On Windows, small (or 0) receive buffer works a bit differently when async IO is concerned. It is supposed to bypass some system buffering and receive the data directly to the user buffer if async receive is pending. So the apps may be using 0 buffer size as a small optimization to skip extra buffer copies in the system. On Unix, if the buffer is too small to receive the network packet the packet will just be dropped. As I interpret my tests though, Windows doesn't actually drop the packets with async socket even if there is no receive currently pending (looking like setting smaller buffer have no effect at all).
This behaves differently with synchronous IO, Windows can also drop packets which don't fit the smaller set buffer in this case.
I think that we can just never set receive buffers smaller than the default one on Unix sockets. The only effect of actually setting that which I can think of is that the system starts dropping packets more eagerly. Which is wrong for async socket I/O case. That might be not so wrong for sync socket I/O case, but implementing that specific to I/O type will add a lot of complication and will only lead that we will dropping packets more eagerly. While we are probably still won't be doing it exactly like on Windows as it depends on multiple factors in Unix and Windows network stack.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3705
This resolves 2 of 8 missing features needed by the Kirikiri visual novel engine.
--
v2: quartz: Delete some redundant members from struct quartz_vmr
quartz: Add test for VMR9SurfaceAllocatorNotify_ChangeD3DDevice
Add test for VMR9SurfaceAllocatorNotify_NotifyEvent
Recreate surfaces in VMR9SurfaceAllocatorNotify_ChangeD3DDevice
quartz: Fill in VMR9SurfaceAllocatorNotify_NotifyEvent stub
https://gitlab.winehq.org/wine/wine/-/merge_requests/3792
I have an application that creates its special registry key using
NtCreateKey(parent, "Something\0"), and then expects to be able to
open this key with NtOpenKey("Something\0") on start up. Currently
this fails because terminating '\0' in the key name doesn't survive
saving/loading the registry. parse_strW() helper already supports
loading such key names.
As the tests show after creating a kernel object with the name "Something\0"
it's possible to only open it as "Something\0", and an attempt opening it
as "Something" fails with STATUS_OBJECT_NAME_NOT_FOUND, and vice versa.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3790
In certain circumstances unmarshalling an object stream from the RunningObjectTable can cause the unmarshalling routines to interrogate the same
table (maybe to resolve a dependant object?) in a different thread causing a deadlock while getting the critical section lock. Leaving the Critical Section before unmarshalling the object stream solve this problem.
Visual Studio 2019 deadlock on start without this.
I'm not sure how to test this properly.
Also add debug info for this critical section so it show a significant name in the log.
Signed-off-by: Lorenzo Ferrillo <lorenzofersteam(a)live.it>
--
v3: ole32: Add debug info to RunningObjectTable critical section
https://gitlab.winehq.org/wine/wine/-/merge_requests/3372
The validation code is meant both as a check that the frontend is behaving properly and as a sort of the documentation to establish what is allowed and what is not in the IR.
~~Currently an assertion is thrown if validation fails. I realize this is a rather strong proposal, but it's of course up for debate. In theory asserting here is the right thing, as it is expected that the frontend is generating correct IR code. However vkd3d is already used in production for many programs, and it could very well be that some of those are working properly even if the generated IR is somewhat out of specs; allowing the assertion might cause regressions as soon as enough checks are implemented in the validator. Please let me know your opinions.~~ **Solved in favor of a softer failure, and only when validation is enabled**
--
v6: vkd3d-shader/ir: Validate source parameters.
vkd3d-shader/ir: Validate destination parameters.
vkd3d-shader/ir: Validate register types.
vkd3d-shader/ir: Validate instruction handlers.
vkd3d-shader/ir: Introduce a boilerplate to validate the generated IR.
vkd3d-shader: Embed the parsing location in vkd3d_shader_instruction.
vkd3d-shader/dxil: Destroy the SM6 parser on parsing errors.
vkd3d-shader/tpf: Destroy the SM4 parser on parsing errors.
vkd3d-shader/d3dbc: Destroy the SM1 parser on parsing errors.
vkd3d-shader/d3dbc: Ignore DCL source parameters.
vkd3d-shader/ir: Simplify the control flow in shader_instruction_normalise_io_params().
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/317
This is the last series I have to use hlsl_block instead of list manipulation.
There is still some list manipulation around, but it's a little trickier to get
rid of, and questionably worthwhile. At any rate things are a lot better now
than they were.
--
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/334
`getpeername()` is currently handled in ntdll. This merge request changes ntdll to forward `getpeername()` to wineserver. The implementation utilises new `peer_addr` and `peer_addr_len` fields in wineserver's `struct sock`.
This fixes multiple `todo_wine`s in `ws2_32/tests` and allows for more accurate peer names to be provided in case the address the socket is bound to on the Unix side does not match what `bind()` was called with on the Windows side.
*This merge request was originally intended to be included in !2786 (Add support for AF_UNIX sockets) but was split into its own merge request because this is not an insignificant change.*
--
v26: server: Move getpeername() implementation from ntdll/unix.
https://gitlab.winehq.org/wine/wine/-/merge_requests/3074
On Mon Sep 11 08:05:33 2023 +0000, Etaash Mathamsetty wrote:
> might have gotten the wow64 thunk wrong, so pls tell me how to fix it if
> that's the case :)
wow64 needs to be added to wow64win/syscall.h.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3777#note_44868
Windows 10 [received support](https://devblogs.microsoft.com/commandline/af_unix-comes-to-window… for AF_UNIX sockets in Insider Build 17063. This merge request adds basic support for AF_UNIX sockets to ws2_32 and wineserver.
Of particular note is the difficulty in handling `sun_path`. Most of the functions that allow for translating Windows paths to Unix paths are not accessible from ws2_32. I considered the following options:
* Pass the Windows path to wineserver and do the conversion there.
* This is, as far as I can tell, not possible without major rearchitecting. wineserver does not have functions to translate Windows paths to Unix paths, for obvious reasons.
* Obtain the current working directory of the requesting process and temporarily change directories to there.
* This only handles relative paths and fails for absolute paths, UNC paths, etc.
* Conditionally change directories based on whether the path is relative or not.
* This is error-prone and wineserver does not have the requisite functions to do this cleanly.
I ultimately decided to pass the translated Unix path to wineserver, which changes directories to `dirname(path)`. It then provides `bind` and `connect` with `basename(path)`. This is not threadsafe, but wineserver is not (currently) multithreaded.
Abstract sockets are not fully supported by this patch, matching the behavior of Windows.
--
v52: ws2_32/tests: Add test for AF_UNIX sockets fix.
server: Fix getsockname() and accept() on AF_UNIX sockets.
server: Introduce error when attempting to create a SOCK_DGRAM AF_UNIX socket.
server: Allow for deletion of socket files.
ws2_32: Add support for AF_UNIX sockets.
ntdll/unix: Add support for AF_UNIX sockets to multiple functions.
ws2_32: Add afunix.h header.
https://gitlab.winehq.org/wine/wine/-/merge_requests/2786
This MR fixes this random failure: http://test.winehq.org/data/126363ea5f9056449e8bd22cc69b51bd2d7dd9aa/linux_…
It happens mostly in d3d9, but if you try hard enough you can see it on d3d8 too.
There are more random failures in test_window_position that I have seen when running on an actual display but not in a dummy X server or Xephyr. One failure mode is that we lose focus in the initial create_device and minimize ourselves. This particular problem is specific to focus follows mouse. Another is that fvwm seems to place the window slightly offscreen, maybe shifted by the size of the window decoration. I am still looking into those issues.
Unrelated to test_windoow_position, there is at least one more random failure in test_wndproc (Test failed: Expected message 0x46 for window 0, but didn't receive it, i=0.), so expect more fvwm3 related MRs after this one...
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3778
In certain circumstances unmarshalling an object stream from the RunningObjectTable can cause the unmarshalling routines to interrogate the same
table (maybe to resolve a dependant object?) in a different thread causing a deadlock while getting the critical section lock. Leaving the Critical Section before unmarshalling the object stream solve this problem.
Visual Studio 2019 deadlock on start without this.
I'm not sure how to test this properly.
Also add debug info for this critical section so it show a significant name in the log.
Signed-off-by: Lorenzo Ferrillo <lorenzofersteam(a)live.it>
--
v2: ole32: Add debug info to RunningObjectTable critical section
ole32: Leave the RunningObjectTable Critical Section before umarshalling object
https://gitlab.winehq.org/wine/wine/-/merge_requests/3372
In certain circumstances unmarshalling an object stream from the RunningObjectTable can cause the unmarshalling routines to interrogate the same
table (maybe to resolve a dependant object?) in a different thread causing a deadlock while getting the critical section lock. Leaving the Critical Section before unmarshalling the object stream solve this problem.
Visual Studio 2019 deadlock on start without this.
I'm not sure how to test this properly.
Signed-off-by: Lorenzo Ferrillo <lorenzofersteam(a)live.it>
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3372
I wanted to use ._xy element access to make it shorter, but that attempt was crushed by the reality - such indexing apparently compiles but does not produce correct element access loads. I'm going to update once this is fixed.
--
v4: vkd3d-shader/hlsl: Add determinant() function.
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/329