I'm not really sure if the last patch is the right way to fix the issue since I couldn't find where tls_w.c originates from.
--
v2: ldap: Free the output buffer after every InitializeSecurityContextA() call (Valgrind).
wldap32: Fix a message leak in ldap_parse_resultW() (Valgrind).
https://gitlab.winehq.org/wine/wine/-/merge_requests/3462
> moreover it means that we'd want two different behaviors when receiving SIGINT (whether it's a genuine unix signal or one sent by the server if we follow the tests result above) perhaps, the solution would be in the default_ctrl_handler to only terminate the program if attached to a console, or in the program group of a unix console
One way or another, terminating GUI process in response to Unix SIGINT is a Wine thing, it's not something we can express in Windows terms. If kernelbase part is not suitable, maybe we may just terminate process from ntdll when we're not connected to console. We know that in this case the signal originated from the host.
> remark: Wine unix console is the sole case where launching a GUI program from command line doesn't return immediately to prompt (native & builtin cmd implementation only wait on CUI programs completion). But that's conform to unix behavior.
I'm not sure what exactly you mean by conforming to unix behavior, but it's arguably a bug that will cause problems similar to !3145, under different conditions. I'd rather avoid depending on this behavior in the solution for SIGINT if possible.
> note: I'm not even sure tweeking with setsid whould be useful as anyway the unix console is in raw mode, so only conhost regenerates the signals
It's in raw mode only if a console application reads input. In this case, taking more control by conhost seems justified.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3312#note_40761
This get us pass the "Update your browser" blocker in adobe's sign-in page. The page itself doesn't make use of `window.MutationObserver`.
However the sign-in page is still broken.
--
v24: mshtml: add stubs for MutationObserver methods
mshtml: implement window.MutationObserver with MutationObserver stub
https://gitlab.winehq.org/wine/wine/-/merge_requests/3391
By default, synchronously completed socket operations will still send completions, we currently don't mind that in winhttp. The most essential part is patch 1, which will also avoid stacking those completions. Patch 2 is not strictly necessary since now we indeed shouldn't be getting unexpected completions, but it seems to me it is better not to fully rely on that and skip unexpected ones just in case.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3446
Some applications (e.g. UE4) requires
the DriverVersion string in the registry.
The string is taken from `dlls/wbemprox/builtin.c`
--
v6: win32u: Add DriverVersion string for GPUs to registry.
https://gitlab.winehq.org/wine/wine/-/merge_requests/3104
Some applications (e.g. UE4) requires
the DriverVersion string in the registry.
The string is taken from `dlls/wbemprox/builtin.c`
--
v5: win32u: Add DriverVersion string for GPUs to registry
https://gitlab.winehq.org/wine/wine/-/merge_requests/3104
Let The Good Life able to play its intro video, the game creates a source reader from a `http://localhost:6000/<random-hash>` URL. This should also probably work with other games playing streams over http(s).
This is a very basic implementation, using urlmon, and it will download the entire stream to a local temporary file before playback. An more optimized implementation would probably use WinHttp and range requests to partially download the requested stream segments, but this can be implemented in a future change.
--
v2: mfreadwrite: Allow URL source resolution to not match extension or mime type.
mf/scheme_handler: Implement http(s):// scheme handler using urlmon.
mf/scheme_handler: Split file scheme handler to scheme_handler.c.
mfplat: Support MF_BYTESTREAM_EFFECTIVE_URL attribute.
mf/tests: Add some network scheme resolver tests.
include: Add MF_BYTESTREAM_EFFECTIVE_URL GUID declaration.
https://gitlab.winehq.org/wine/wine/-/merge_requests/3439
Signed-off-by: Fan WenJie <fanwj(a)mail.ustc.edu.cn>
Hook mmap and munmap seem to be the only solution for drivers such as OpenGL to allocate over 32-bit address. For example, Fairy and Sword 4 has some render problems on master branch of wine. The patch can solve the problems.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3460
This is meant to simplify testing conditions that generally hold true
but may occasionally fail due to interference from external factors
(such as processes that start / stop, network connections being
opened / closed, etc).
The trick is to loop a few times on the set of flaky conditions until
they succeed. During the last attempt all failures are recorded as
usual, while in the previous runs, the tryok() failures area ignored
but cause one more attempt to be made.
The simplest case looks like this:
LOOP_ON_FLAKY_TESTS(3)
{
// ok() failures are never ignored and not retried
ok(..., "check 1", ...);
// tryok() failures are ignored except on the last attempt
tryok(..., "check 2", ...);
}
There is also:
* attempt_retry() which marks the current attempt as failed as if
calling tryok(0), and returns true if another attempt can be made.
* attempt_failed() which returns true if an ok() call failed.
---
This is independent from the 'flaky' mechanism which adds some naming
constraints. The loop macro is still called LOOP_ON_FLAKY_TESTS()
despite being unrelated to the flaky mechanism. The attempt_retry()
and attempt_failed() macro names also don't make it obvious that they
are related to tryok().
I think this mechanism is better than the flaky one because a flaky test
can go bad without anyone noticing, whereas if a tryok() starts failing
systematically it will cause a real failure.
The other side of that coin is that, unlike flaky, the tryok()
mechanism does not entirely eliminate the possibility of getting a
failure, it just reduces it; though by adjusting the maximum number of
attempts one can achieve an arbitrarily low failure rate. For instance
if an ok() call fails 10% of the time and one wants a maximum of 1 in
a million failure rate, use LOOP_ON_FLAKY_TESTS(6). The cost is an
increased run time in the worst case.
This also limits the use of this mechanism to tests that have a
reasonably low failure rate to start with (otherwise one has to loop
too many times). Also note that there are cases where looping
essentially reduce the failure rate to zero. For instance
ieframe:webbrowser fails if IE creates a net session while the test is
counting them. But IE only creates the one net session on start up so
trying even one more time should guarantee that the test will succeed.
Other cases like scheduling delays and the creation of network
connections are more probabilistic in nature. Maybe a comment in test.h
should offer some guideline as to the target failure rate.
Eventually this may replace the flaky mechanism but that depends on
how well it works in practice and how practical it is to loop on flaky
tests. It seems to be going well in the few cases I looked at. But I
think this mechanism has value even if the two end up coexisting
indefinitely.
This MR uses the tryok() in some actual tests for illustration and testing purposes. The final MR will probably split most of those off to separate MRs.
--
v3: mmdevapi/tests: Replace flaky with tryok() in the capture tests.
mmdevapi/tests: Replace flaky with tryok() in the render tests.
quartz/tests: Replace flaky() with tryok() to work around scheduling delays.
DEBUG ieframe/tests: tryok() framework testing ground.
ieframe/tests: Work around a network session race condition.
advapi32/tests: Replace the custom loop with tryok() mechanism.
ntdll/tests: Use tryok() to fix a free disk space race with other processes.
kernel32/tests: Use tryok() to fix a heap race with other processes.
FIXME(traces) tests: Add tryok() for tests that may need multiple tries to succeed.
tests: Update the documentation.
https://gitlab.winehq.org/wine/wine/-/merge_requests/3418
This is required to avoid silencing (potentially fatal) exceptions from timer procedures.
--
v3: win32u: Ignore unhandled info index in NtUserSetObjectInformation.
win32u/tests: Add tests for NtUserSetObjectInformation.
user32: Implement UOI_TIMERPROC_EXCEPTION_SUPPRESSION.
user32/tests: Add tests for UOI_TIMERPROC_EXCEPTION_SUPPRESSION.
https://gitlab.winehq.org/wine/wine/-/merge_requests/3454
This fixes a bug in wine when running on 9pfs where short reads would occur, causing binaries to be loaded incorrectly. All other filesystems on Linux ignore O_NONBLOCK for regular files, so this should not affect them.
Thanks to Paul Gofman for the advice on this fix.
---
Ref https://gitlab.winehq.org/wine/wine/-/merge_requests/3390 for my original attempt at fixing this, particularly https://gitlab.winehq.org/wine/wine/-/merge_requests/3390#note_40093 which describes the strange situation `O_NONBLOCK` finds itself in on filesystems.
The risk with this MR is that fifo, unix sockets or other special files opened via `open_unix_file` in ntdll will now have changed behaviour - but my quick look suggests that this is unlikely, as `open_unix_file` is only used for:
- `dlls/ntdll/unix/file.c`: `NtCreateFile` and `NtDeleteFile`
- `dlls/ntdll/unix/process.c`: loading PE information and getting a dirfd for the current directory
- `dlls/ntdll/unix/env.c`: `open_nls_data_file`
- `dlls/ntdll/unix/loader.c`: dll load functions
- `dlls/ntdll/unix/registry.c`: `NtLoadKeyEx`
cc @gofman
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3445
The read and pread syscalls are permitted to return fewer bytes than requested (unlike the fread libc call which will only perform a short read on error or EOF). This is most likely to occur when binaries are located on slower filesystems (e.g. NFS or 9pfs)
ffab9d9 is a relatively recent regression here, but a lot of the code appears to be much older (e.g. the read call in 341b7dc)
In this MR I've focused on ntdll, but I see a lot of similar mishandling of the pread return value in `server/`. I will raise a bug as I don't intend to create a follow up MR at this time.
--
v3: ntdll: Correctly handle pread short reads
https://gitlab.winehq.org/wine/wine/-/merge_requests/3390
On Fri Jul 28 02:22:22 2023 +0000, **** wrote:
> Marvin replied on the mailing list:
> ```
> Hi,
> It looks like your patch introduced the new failures shown below.
> Please investigate and fix them before resubmitting your patch.
> If they are not new, fixing them anyway would help a lot. Otherwise
> please ask for the known failures list to be updated.
> The tests also ran into some preexisting test failures. If you know how
> to fix them that would be helpful. See the TestBot job for the details:
> The full results can be found at:
> https://testbot.winehq.org/JobDetails.pl?Key=135341
> Your paranoid android.
> === debian11 (32 bit zh:CN report) ===
> Report validation errors:
> d3d11:d3d11 crashed (c0000005)
> ```
This looks like https://bugs.winehq.org/show_bug.cgi?id=53217 so I don't think it's new
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3431#note_40653
This serie:
- adds a couple of tests to CreateProcess to cover ctrl-c blocking inheritance flag
and process group creation
- populates RTL_USER_PROCESS_PARAMETERS.ProcessGroupId
- separates new process group creation from ctrl-c inheritance flag
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3442
Giovanni Mascellani (@giomasce) commented about libs/vkd3d-shader/dxil.c:
> FIXME("Unhandled dxil instruction %u.\n", record->code);
> return VKD3D_ERROR_INVALID_SHADER;
> }
> + /* Allocation failure. */
That's not necessarily the case, is it? Any call to `vkd3d_shader_parser_error()`, such as in `dxil_record_validate_operand_min_count()`, could trigger this failure.
More in general, I think we there is some confusion between whether to use the parser `failed` bit vs using the return value. We could use the same convention as the HLSL compiler: `failed` is set as soon as an error is found, and it should always set via `vkd3d_shader_parser_error()` so that a diagnostic is always available; an error return value should only be used when an error was found and parsing must halt immediately.
In this scheme you should never look at `failed` to decide what to return, because you don't know if `failed` was set because of an error that still allows parsing or not. You have to genuinely propagate the return code at each level.
It is useful to have memory allocation functions that also set the `failed` bit, like the HLSL compiler.
--
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/283#note_40646
Giovanni Mascellani (@giomasce) commented about libs/vkd3d-shader/dxil.c:
> ++block_idx;
> code_block = (block_idx < function->block_count) ? function->blocks[block_idx] : NULL;
This was already here before, but I just realized that setting `code_block` to `NULL` might give a few problems if there are some other instructions (which shouldn't be there, but the shader might be untrusted input). Specifically, various lines in this loop assume that `code_block` is valid, and if it's not an `assert()` could be triggered.
--
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/283#note_40645
Let The Good Life able to play its intro video, the game creates a source reader from a `http://localhost:6000/<random-hash>` URL. This should also probably work with other games playing streams over http(s).
This is a very basic implementation, using urlmon, and it will download the entire stream to a local temporary file before playback. An more optimized implementation would probably use WinHttp and range requests to partially download the requested stream segments, but this can be implemented in a future change.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3439
This get us pass the "Update your browser" blocker in adobe's sign-in page. The page itself doesn't make use of `window.MutationObserver`.
However the sign-in page is still broken.
--
v23: mshtml: add stubs for MutationObserver methods
mshtml: implement window.MutationObserver with MutationObserver stub
https://gitlab.winehq.org/wine/wine/-/merge_requests/3391
@huw I had a look at the output of the failure from MR #3423, but I can't see why it is trying to use `-lpcsclite`. Rhe configure check for it fails, but the one for PCSC.framework succeeds, so it should be using that. I'll try to look further.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3389#note_40620
It looks like this is breaking `build-mac` on gitlab.
```
ld: library not found for -lpcsclite
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make: *** [dlls/winscard/winscard.so] Error 1
```
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3389#note_40617
Some applications (e.g. UE4) requires
the DriverVersion string in the registry.
The string is taken from `dlls/wbemprox/builtin.c`
--
v4: win32u: Add DriverVersion string for GPUs to registry
https://gitlab.winehq.org/wine/wine/-/merge_requests/3104
Recap:
I implemented relative addressing in !229, but I was suggested to handle register indexes by moving all the registers to the heap, which I did in my [nonconst-offsets-6](https://gitlab.winehq.org/fcasas/vkd3d/-/commits/noncon… branch. A part of this implementation required !269, but I was asked to try to turn the sm4 register structs into the vkd3d-shader register structs instead, to get closer to a common low level IR.
This is the first part of that transformation. The whole thing is in my [use_vkd3d_reg](https://gitlab.winehq.org/fcasas/vkd3d/-/commits/use_vkd3d_r… branch.
~~This is built on top of !225 (the first two patches), so it may be good to get that upstream first.~~
---
This patch series aims to do the following replacements:
```
struct sm4_register -> struct vkd3d_shader_register
struct sm4_dst_register -> struct vkd3d_shader_dst_param
struct sm4_src_register -> struct vkd3d_shader_src_param
```
to get us closer to a common level IR and simplify the implementation of relative-addressing.
To achieve this, the fields in the sm4 register structs are replaced with fields in the vkd3d-shader structs or removed altogether, one at the time.
As can be seen when looking at the whole branch, it is possible to do this transformation without having to add additional fields to `struct vkd3d_shader_register`, by restricting each register type to a single `enum vkd3d_sm4_dimension` (and its src registers to a single `enum vkd3d_sm4_swizzle_type`) by default.
The only exception we need so far is for sampler registers: They always have dimension NONE, except when used as arguments of gather instructions, in which case they have dimension VEC4 and SCALAR swizzle. This, and similar exceptions we may find in the future, can be handled using the opcode_info, as in 7/8 [81e17506](https://gitlab.winehq.org/fcasas/vkd3d/-/commit/81e17506ba2cb1fbf….
--
v4: vkd3d-shader/tpf: Get rid of sm4_register.dim.
vkd3d-shader/tpf: Use 's' in src_info to expect sampler register with vec4 dimension.
vkd3d-shader/tpf: Separate dst register write function.
vkd3d-shader/tpf: Separate src register write function.
vkd3d-shader/tpf: Make register_type_table an array of structs with lookup tables.
vkd3d-shader/tpf: Pass ctx to sm4_encode_register().
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/281
This is probably the most ugly and controversial bit of API. I don't really know
if this is the right approach to solving this.
sm4 registers match by register index, such that shaders can mostly be compiled
in isolation. sm1 does not—registers may be specified in any order in the vertex
and pixel shaders, and will be matched by usage and usage index.
By itself this is not much of a problem. Where it gets hairy is that we want to
do some degree of caching, as well as pre-compilation, and avoid recompiling
either shader every time it's matched with a new one.
Wine currently deals with this problem, for GLSL, by generating a "main" GLSL
shader for the vertex shader, and then an extra function setup_vs_output(), and
linking the two together every time a new pixel shader is used. This could in
theory be used for SPIR-V, but it requires the use of extra, probably external,
code to link SPIR-V shaders together, which I do not particularly anticipate
being well-received.
(I'm not sure how Wine deals with this problem in the ARB backend. It seems to
take the pixel shader signature into account when generating the vertex shader—
cf. init_output_registers()—but it doesn't take it into account when looking up
a vertex shader variant? I didn't look too closely at the code, so maybe I'm
missing something.)
--
The vkd3d parts of this patch are quite straightforward, and looking at them, I
think the design is quite intuitive in isolation. There may be some room for
internal refactoring (in particular with an eye to not so much overloading
the "register_index" field of struct shader_signature_element) but I'm
relatively happy with the way it turned out. In isolation, that is.
The Wine part is worse. I've uploaded branches for vkd3d and Wine that use this
API, and correctly handle shaders with some nontrivial reordering:
https://gitlab.winehq.org/zfigura/vkd3d/-/commits/himavant5https://gitlab.winehq.org/zfigura/wine/-/commits/himavant_cb
The test can be run, as before, like so:
make tests/shader_runner.exe && WINE_D3D_CONFIG=renderer=vulkan wine tests/shader_runner.exe ../vkd3d/tests/hlsl/sm1-interstage-interface.shader_test
The interesting Wine parts are concentrated in a single patch, 5cfb9d930f11e.
The patch takes a few shortcuts, partly because I wanted not to block the vkd3d
API design questions, but also because while writing it I came up with a couple
of problems that I wasn't sure how to fix. There are two main problems I see:
(1) This patch has the user pass the signature from the pixel shader when
compiling the vertex shader, and looks up register indices already
arbitrarily allocated by the pixel shader. This is problematic when trying
to use this signature as a cache key, by virtue of it not being clear (or
even defined) which fields are key elements and which aren't. It's also not
particularly kind to lookup, on account of not being directly comparable
with memcmp(). There are a few options I see:
(a) Provide an internal function to compare key elements. This feels... odd,
like a very special-purpose function, but perhaps workable.
(b) Just make the user deal with it, and assert that all fields are key
elements.
(c) Use some alternative, perhaps shortened structure as a field of
vkd3d_shader_next_stage_info. This has the disadvantage that it is not
as simple for a hypothetical user to retrieve from the pixel shader, but
we would presumably provide a function to generate one from a shader
signature. This would probably also be kinder to cache lookup if it's
shorter.
(d) Make caching vkd3d's responsibility, to some degree. This seems
daunting, but the more we optimize, the more difficult it may be to
design API that allows for nice caching.
(2) Assuming we use signatures, there is a memory management problem that
5cfb9d930f11e spells out. This is probably a matter of "just fix it", but
I suppose another option is to take the GLSL or ARB architecture.
--
April is the cruellest month, breeding
Lilacs out of the dead land, mixing
Memory and desire, stirring
Dull roots with spring rain.
--
v2: vkd3d-shader: Implement a function to build a varying map between sm1 stages.
vkd3d-shader: Implement remapping shader output registers to match the next shader's semantics.
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/280
--
v11: vkd3d-shader/tpf: Add support for writing 'resinfo' instruction.
vkd3d-shader/tpf: Add support for writing 'sampleinfo' instruction.
vkd3d-shader/hlsl: Parse GetDimensions() method.
tests: Add some tests for GetDimensions().
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/218
DirectX's FFP normalizes the zero vector to the zero vector, but GLSL
normalizes them to all NaN.
This patch creates `ffp_normalize`, which normalizes vectors but
has DirectX's behavior on 0 vectors. Further patches in this set switch
other calls from GLSL's `normalize` to the 0-safe version.
This fixes [36564](https://bugs.winehq.org/show_bug.cgi?id=36564).
--
v2: wined3d: Use ffp_normalize in shader_glsl_ffp_vertex_lighting_footer.
wined3d: Use ffp_normalize in shader_glsl_ffp_vertex_lighting.
wined3d: Implement a zero-safe normalize function for FFP.
https://gitlab.winehq.org/wine/wine/-/merge_requests/3419
When the sample size is too small, we were releasing it from the memory,
but kept the next_sample pointer set. Later, when the transform removes
the sample from the allocator, its refcount was decremented one more
time, effectively leaking the sample.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3427
On Thu Jul 27 20:38:34 2023 +0000, Zebediah Figura wrote:
> > Beyond the test included in the patches, I did roughly the following:
> ptr = VirtualAlloc(NULL 4096 \* 2, PAGE_NOACCESS); VirtualProtect(ptr,
> 4096, PAGE_READWRITE); params = ptr + 4096 - sizeof(\*params). And used
> that pointer. So far it doesn't access it beyond the end of accessible
> memory (that succeeds).
> Ah yes, that definitely sounds convincing to me :-)
> > It might happen that with some other values for unknown parameter it
> is using more data from the structure, but IMO exploring more details
> about those parameters, in the absence of any known app which uses those
> functions, looks like a waste of time to me. It is relatively easy here
> with nsi and was already explored for other functions so I didn't want
> to break this tradition in nsi, but in general it seems impractical to
> me to spend huge amount of time reversing the exact parameters of the
> undocumented functions which nothing is using directly. Not feasible for
> implementing larger APIs and the benefit is not obvious. And once
> something is using directly in a way we don't support we can rather
> easily look how and test with those parameters.
> Sure. I don't think we necessarily need to figure out the unknown
> parameter, or spend too much effort on reverse-engineering undocumented
> things in general, or closely matching undocumented APIs.
> I only get nervous about the prospect of implementing undocumented APIs
> that are incorrect in ways that would be subtle or hard to debug—wrong
> number of parameters, wrong struct sizes, and so on. To a degree, the
> fact that an application even uses such APIs means that it's a first
> place to look when debugging, but that's not exactly the kind of thing
> that's trivial to notice.
> > I could possibly add a fixme for nonzero unk parameter?
> That sounds like a unilaterally good idea to me, at least.
Now when this patchset is split in two this first part has only a stub FIXME there anyway; I will update the second part with the specific fixme for unknown parameter.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3423#note_40573
> Beyond the test included in the patches, I did roughly the following: ptr = VirtualAlloc(NULL 4096 \* 2, PAGE_NOACCESS); VirtualProtect(ptr, 4096, PAGE_READWRITE); params = ptr + 4096 - sizeof(\*params). And used that pointer. So far it doesn't access it beyond the end of accessible memory (that succeeds).
Ah yes, that definitely sounds convincing to me :-)
> It might happen that with some other values for unknown parameter it is using more data from the structure, but IMO exploring more details about those parameters, in the absence of any known app which uses those functions, looks like a waste of time to me. It is relatively easy here with nsi and was already explored for other functions so I didn't want to break this tradition in nsi, but in general it seems impractical to me to spend huge amount of time reversing the exact parameters of the undocumented functions which nothing is using directly. Not feasible for implementing larger APIs and the benefit is not obvious. And once something is using directly in a way we don't support we can rather easily look how and test with those parameters.
Sure. I don't think we necessarily need to figure out the unknown parameter, or spend too much effort on reverse-engineering undocumented things in general, or closely matching undocumented APIs.
I only get nervous about the prospect of implementing undocumented APIs that are incorrect in ways that would be subtle or hard to debug—wrong number of parameters, wrong struct sizes, and so on. To a degree, the fact that an application even uses such APIs means that it's a first place to look when debugging, but that's not exactly the kind of thing that's trivial to notice.
> I could possibly add a fixme for nonzero unk parameter?
That sounds like a unilaterally good idea to me, at least.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3423#note_40571
Beyond the test included in the patches, I did roughly the following: ptr = VirtualAlloc(NULL 4096 * 2, PAGE_NOACCESS); VirtualProtect(ptr, 4096, PAGE_READWRITE); params = ptr + 4096 - sizeof(*params). And used that pointer. So far it doesn't access it beyond the end of accessible memory (that succeeds). It might happen that with some other values for unknown parameter it is using more data from the structure, but IMO exploring more details about those parameters, in the absence of any known app which uses those functions, looks like a waste of time to me. It is relatively easy here with nsi and was already explored for other functions so I didn't want to break this tradition in nsi, but in general it seems impractical to me to spend huge amount of time reversing the exact parameters of the undocumented functions which nothing is using directly. Not feasible for implementing larger APIs and the benefit is not obvious. And once something is using directly in a way we don't support we
can rather easily look how and test with those parameters. I could possibly add a fixme for nonzero unk parameter?
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3423#note_40570
On Thu Jul 27 08:45:24 2023 +0000, Huw Davies wrote:
> > So far I don't have anything for the other iphlpapi notification
> functions (e. g., NotifyIpInterfaceChange).
> I suspect the newer notifications like this one use the
> `Nsi(De)RegisterChangeNotification()` api instead.
Yes, it seems like it, I was just reasoning on how that could work (most notably, those notifications will need to deliver changed row).
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3423#note_40564
v2:
- split the MR (stop after handle caching commit);
- test and add NsiRequestChangeNotificationEx (and move the implementation there);
- Mind alphabetical sort when adding NsiCancelChangeNotification.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/3423#note_40563