- Wine-Devel - list.winehq.org

[PATCH 3/7] win32u: Move NtUserSetClipboardViewer implementation from user32.
by Jacek Caban April 22, 2022

April 22, 2022

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/user32/clipboard.c | 25 ------------------------- dlls/user32/user32.spec | 2 +- dlls/win32u/clipboard.c | 26 ++++++++++++++++++++++++++ dlls/win32u/gdiobj.c | 1 + dlls/win32u/win32u.spec | 2 +- dlls/win32u/win32u_private.h | 1 + dlls/win32u/wrappers.c | 6 ++++++ include/ntuser.h | 1 + 8 files changed, 37 insertions(+), 27 deletions(-)

2 1

[PATCH 2/7] win32u: Move NtUserSetMenuDefaultItem implementation from user32.
by Jacek Caban April 22, 2022

April 22, 2022

2 1

[PATCH 1/7] win32u: Move NtUserThunkedMenuInfo implementation from user32.
by Jacek Caban April 22, 2022

April 22, 2022

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/user32/menu.c | 50 ++++++-------------------------------- dlls/win32u/menu.c | 53 +++++++++++++++++++++++++++++++++++++++++ dlls/win32u/syscall.c | 1 + dlls/win32u/win32u.spec | 2 +- dlls/wow64win/syscall.h | 1 + dlls/wow64win/user.c | 29 ++++++++++++++++++++++ include/ntuser.h | 1 + 7 files changed, 93 insertions(+), 44 deletions(-)

2 1

[PATCH] ntdll: Fix passing timeout to FUTEX_WAIT when _TIME_BITS 64 is defined.
by Piotr Caban April 22, 2022

April 22, 2022

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/ntdll/unix/sync.c | 27 +++++++++++++++++++++------ 1 file changed, 21 insertions(+), 6 deletions(-)

2 1

[PATCH v2 1/2] kernel32/tests: Mark activatableClass wrong xmlns test as broken on w1064v1909.
by Rémi Bernon April 22, 2022

April 22, 2022

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/kernel32/tests/actctx.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/kernel32/tests/actctx.c b/dlls/kernel32/tests/actctx.c index 71337c0f38e..bec04b7f066 100644 --- a/dlls/kernel32/tests/actctx.c +++ b/dlls/kernel32/tests/actctx.c @@ -1108,7 +1108,7 @@ static void test_create_fail(void) trace("wrong_manifest10\n"); test_create_and_fail(wrong_manifest10, NULL, 0, TRUE /* WinXP */); trace("wrong_manifest11\n"); - test_create_and_fail(wrong_manifest11, NULL, 1, FALSE); + test_create_and_fail(wrong_manifest11, NULL, 1, TRUE /* w1064v1909 */); trace("UTF-16 manifest1 without BOM\n"); test_create_wide_and_fail(manifest1, FALSE ); trace("manifest2\n"); -- 2.35.1

1 1

[PATCH v2 1/6] jscript: Implement Number.prototype.toLocaleString.
by Gabriel Ivăncescu April 22, 2022

April 22, 2022

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- I kept the fraction removal since I couldn't think of a better way for now. However, the other improvements have been done. dlls/jscript/jscript.h | 1 + dlls/jscript/number.c | 82 ++++++++++++++++++++++++++++++++++++++- dlls/jscript/tests/api.js | 7 ++++ 3 files changed, 88 insertions(+), 2 deletions(-) diff --git a/dlls/jscript/jscript.h b/dlls/jscript/jscript.h index 7ed4425..406efa9 100644 --- a/dlls/jscript/jscript.h +++ b/dlls/jscript/jscript.h @@ -449,6 +449,7 @@ HRESULT regexp_string_match(script_ctx_t*,jsdisp_t*,jsstr_t*,jsval_t*) DECLSPEC_ BOOL bool_obj_value(jsdisp_t*) DECLSPEC_HIDDEN; unsigned array_get_length(jsdisp_t*) DECLSPEC_HIDDEN; +HRESULT localize_number(script_ctx_t*,DOUBLE,jsstr_t**) DECLSPEC_HIDDEN; HRESULT JSGlobal_eval(script_ctx_t*,jsval_t,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN; HRESULT Object_get_proto_(script_ctx_t*,jsval_t,WORD,unsigned,jsval_t*,jsval_t*) DECLSPEC_HIDDEN; diff --git a/dlls/jscript/number.c b/dlls/jscript/number.c index be733fb..64404ba 100644 --- a/dlls/jscript/number.c +++ b/dlls/jscript/number.c @@ -17,6 +17,7 @@ */ #include <math.h> +#include <locale.h> #include <assert.h> #include "jscript.h" @@ -341,11 +342,88 @@ static HRESULT Number_toString(script_ctx_t *ctx, jsval_t vthis, WORD flags, uns return S_OK; } +HRESULT localize_number(script_ctx_t *ctx, DOUBLE val, jsstr_t **ret) +{ + WCHAR buf[314], *numstr, *p, *frac = NULL; + BOOL remove_fraction = FALSE; + jsstr_t *str, *tmp; + _locale_t locale; + unsigned convlen; + int len; + + /* FIXME: Localize this? */ + if(!isfinite(val)) + return to_string(ctx, jsval_number(val), ret); + + /* Native never uses an exponent, even if the number is very large, it will in fact + return all the digits (with thousands separators). jscript.dll uses two digits for + fraction even if they are zero (likely default numDigits) and always returns them, + while mshtml's jscript only if they are non-zero (on same locale settings); this + applies even for very small numbers, such as 0.0000999, which will simply be 0 */ + if(!(locale = _create_locale(LC_ALL, "C"))) + return E_OUTOFMEMORY; + len = _swprintf_l(buf, ARRAY_SIZE(buf), L"%.2f", locale, val); + _free_locale(locale); + + if(!(convlen = GetNumberFormatW(ctx->lcid, 0, buf, NULL, NULL, 0)) || + !(str = jsstr_alloc_buf(convlen - 1, &numstr))) + return E_OUTOFMEMORY; + + if(!GetNumberFormatW(ctx->lcid, 0, buf, NULL, numstr, convlen)) { + jsstr_release(str); + return E_OUTOFMEMORY; + } + + if(ctx->version >= SCRIPTLANGUAGEVERSION_ES5) { + while(len--) { + if(buf[len] != '0') { + if(buf[len] == '.') + remove_fraction = TRUE; + break; + } + } + } + + if(remove_fraction && GetLocaleInfoW(ctx->lcid, LOCALE_SDECIMAL, buf, ARRAY_SIZE(buf))) { + p = numstr; + while(*p) { + if(!(p = wcsstr(p, buf))) + break; + frac = p++; + } + if(frac) { + tmp = jsstr_alloc_len(numstr, frac - numstr); + jsstr_release(str); + if(!tmp) + return E_OUTOFMEMORY; + str = tmp; + } + } + + *ret = str; + return S_OK; +} + static HRESULT Number_toLocaleString(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r) { - FIXME("\n"); - return E_NOTIMPL; + jsstr_t *str; + HRESULT hres; + DOUBLE val; + + TRACE("\n"); + + hres = numberval_this(vthis, &val); + if(FAILED(hres)) + return hres; + + if(r) { + hres = localize_number(ctx, val, &str); + if(FAILED(hres)) + return hres; + *r = jsval_string(str); + } + return S_OK; } static HRESULT Number_toFixed(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, diff --git a/dlls/jscript/tests/api.js b/dlls/jscript/tests/api.js index 1efc023..8653946 100644 --- a/dlls/jscript/tests/api.js +++ b/dlls/jscript/tests/api.js @@ -1365,6 +1365,11 @@ ok(tmp === "0", "num().toString = " + tmp); tmp = (new Number(5.5)).toString(2); ok(tmp === "101.1", "num(5.5).toString(2) = " + tmp); +tmp = (new Number(12)).toLocaleString(); +ok(tmp.indexOf(String.fromCharCode(0)) == -1, "invalid null byte"); +tmp = Number.prototype.toLocaleString.call(NaN); +ok(tmp.indexOf(String.fromCharCode(0)) == -1, "invalid null byte"); + tmp = (new Number(3)).toFixed(3); ok(tmp === "3.000", "num(3).toFixed(3) = " + tmp); tmp = (new Number(3)).toFixed(); @@ -2594,6 +2599,8 @@ testException(function() {arr.test();}, "E_NO_PROPERTY"); testException(function() {[1,2,3].sort(nullDisp);}, "E_JSCRIPT_EXPECTED"); testException(function() {Number.prototype.toString.call(arr);}, "E_NOT_NUM"); testException(function() {Number.prototype.toFixed.call(arr);}, "E_NOT_NUM"); +testException(function() {Number.prototype.toLocaleString.call(arr);}, "E_NOT_NUM"); +testException(function() {Number.prototype.toLocaleString.call(null);}, "E_NOT_NUM"); testException(function() {(new Number(3)).toString(1);}, "E_INVALID_CALL_ARG"); testException(function() {(new Number(3)).toFixed(21);}, "E_FRACTION_DIGITS_OUT_OF_RANGE"); testException(function() {(new Number(1)).toPrecision(0);}, "E_PRECISION_OUT_OF_RANGE"); -- 2.34.1

3 12

[PATCH 6/6] winealsa: Implement Wow64 midi entry points in the Unix library.
by Huw Davies April 22, 2022

April 22, 2022

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winealsa.drv/alsa.c | 6 +- dlls/winealsa.drv/alsamidi.c | 354 +++++++++++++++++++++++++++++++++++ dlls/winealsa.drv/unixlib.h | 6 + 3 files changed, 363 insertions(+), 3 deletions(-) diff --git a/dlls/winealsa.drv/alsa.c b/dlls/winealsa.drv/alsa.c index db654bd75b9..8b6a87aa864 100644 --- a/dlls/winealsa.drv/alsa.c +++ b/dlls/winealsa.drv/alsa.c @@ -2869,9 +2869,9 @@ unixlib_entry_t __wine_unix_call_wow64_funcs[] = is_started, wow64_get_prop_value, midi_release, - midi_out_message, - midi_in_message, - midi_notify_wait, + wow64_midi_out_message, + wow64_midi_in_message, + wow64_midi_notify_wait, }; #endif /* _WIN64 */ diff --git a/dlls/winealsa.drv/alsamidi.c b/dlls/winealsa.drv/alsamidi.c index b226dac310f..c09547cdcf0 100644 --- a/dlls/winealsa.drv/alsamidi.c +++ b/dlls/winealsa.drv/alsamidi.c @@ -1499,3 +1499,357 @@ NTSTATUS midi_notify_wait(void *args) return STATUS_SUCCESS; } + +#ifdef _WIN64 + +typedef UINT PTR32; + +struct notify_context32 +{ + BOOL send_notify; + WORD dev_id; + WORD msg; + UINT param_1; + UINT param_2; + UINT callback; + UINT flags; + PTR32 device; + UINT instance; +}; + +static void notify_to_notify32(struct notify_context32 *notify32, + const struct notify_context *notify) +{ + notify32->send_notify = notify->send_notify; + notify32->dev_id = notify->dev_id; + notify32->msg = notify->msg; + notify32->param_1 = notify->param_1; + notify32->param_2 = notify->param_2; + notify32->callback = notify->callback; + notify32->flags = notify->flags; + notify32->device = PtrToUlong(notify->device); + notify32->instance = notify->instance; +} + +struct midi_open_desc32 +{ + PTR32 hMidi; + UINT dwCallback; + UINT dwInstance; + UINT dnDevNode; + UINT cIds; + MIDIOPENSTRMID rgIds; +}; + +struct midi_hdr32 +{ + PTR32 lpData; + UINT dwBufferLength; + UINT dwBytesRecorded; + UINT dwUser; + UINT dwFlags; + PTR32 lpNext; + UINT reserved; + UINT dwOffset; + UINT dwReserved[8]; +}; + +static UINT wow64_midi_out_prepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (hdr->dwFlags & MHDR_PREPARED) + return MMSYSERR_NOERROR; + + hdr->lpNext = 0; + hdr->dwFlags |= MHDR_PREPARED; + hdr->dwFlags &= ~(MHDR_DONE | MHDR_INQUEUE); + return MMSYSERR_NOERROR; +} + +static UINT wow64_midi_out_unprepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (!(hdr->dwFlags & MHDR_PREPARED)) + return MMSYSERR_NOERROR; + if (hdr->dwFlags & MHDR_INQUEUE) + return MIDIERR_STILLPLAYING; + + hdr->dwFlags &= ~MHDR_PREPARED; + return MMSYSERR_NOERROR; +} + +NTSTATUS wow64_midi_out_message(void *args) +{ + struct + { + UINT dev_id; + UINT msg; + UINT user; + UINT param_1; + UINT param_2; + PTR32 err; + PTR32 notify; + } *params32 = args; + struct notify_context32 *notify32 = ULongToPtr(params32->notify); + struct midi_open_desc32 *desc32; + struct midi_hdr32 *hdr32; + struct notify_context notify; + MIDIOPENDESC open_desc; + MIDIHDR hdr; + struct midi_out_message_params params = + { + .dev_id = params32->dev_id, + .msg = params32->msg, + .user = params32->user, + .param_1 = params32->param_1, + .param_2 = params32->param_2, + .err = ULongToPtr(params32->err), + .notify = &notify + }; + notify32->send_notify = FALSE; + + switch (params32->msg) + { + case MODM_OPEN: + desc32 = ULongToPtr(params32->param_1); + + open_desc.hMidi = ULongToPtr(desc32->hMidi); + open_desc.dwCallback = desc32->dwCallback; + open_desc.dwInstance = desc32->dwInstance; + open_desc.dnDevNode = desc32->dnDevNode; + open_desc.cIds = desc32->cIds; + open_desc.rgIds.dwStreamID = desc32->rgIds.dwStreamID; + open_desc.rgIds.wDeviceID = desc32->rgIds.wDeviceID; + + params.param_1 = (UINT_PTR)&open_desc; + break; + + case MODM_LONGDATA: + hdr32 = ULongToPtr(params32->param_1); + + memset(&hdr, 0, sizeof(hdr)); + hdr.lpData = ULongToPtr(hdr32->lpData); + hdr.dwBufferLength = hdr32->dwBufferLength; + hdr.dwFlags = hdr32->dwFlags; + + params.param_1 = (UINT_PTR)&hdr; + params.param_2 = sizeof(hdr); + break; + + case MODM_PREPARE: /* prepare and unprepare are easier to handle explicitly */ + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_out_prepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + + case MODM_UNPREPARE: + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_out_unprepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + } + + midi_out_message(&params); + + switch (params32->msg) + { + case MODM_LONGDATA: + hdr32 = ULongToPtr(params32->param_1); + + hdr32->dwFlags = hdr.dwFlags; + break; + } + + if (notify.send_notify) + { + notify_to_notify32(notify32, &notify); + + if (notify.msg == MOM_DONE) + notify32->param_1 = params32->param_1; /* restore the 32-bit hdr */ + } + return STATUS_SUCCESS; +} + +static UINT wow64_midi_in_prepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (hdr->dwFlags & MHDR_PREPARED) + return MMSYSERR_NOERROR; + + hdr->lpNext = 0; + hdr->dwFlags |= MHDR_PREPARED; + hdr->dwFlags &= ~(MHDR_DONE | MHDR_INQUEUE); + + return MMSYSERR_NOERROR; +} + +static UINT wow64_midi_in_unprepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (!(hdr->dwFlags & MHDR_PREPARED)) + return MMSYSERR_NOERROR; + if (hdr->dwFlags & MHDR_INQUEUE) + return MIDIERR_STILLPLAYING; + + hdr->dwFlags &= ~MHDR_PREPARED; + + return MMSYSERR_NOERROR; +} + +NTSTATUS wow64_midi_in_message(void *args) +{ + struct + { + UINT dev_id; + UINT msg; + UINT user; + UINT param_1; + UINT param_2; + PTR32 err; + PTR32 notify; + } *params32 = args; + struct notify_context32 *notify32 = ULongToPtr(params32->notify); + struct midi_open_desc32 *desc32; + struct midi_hdr32 *hdr32; + struct notify_context notify; + MIDIOPENDESC open_desc; + MIDIHDR *hdr = NULL; + struct midi_in_message_params params = + { + .dev_id = params32->dev_id, + .msg = params32->msg, + .user = params32->user, + .param_1 = params32->param_1, + .param_2 = params32->param_2, + .err = ULongToPtr(params32->err), + .notify = &notify + }; + notify32->send_notify = FALSE; + + switch (params32->msg) + { + case MIDM_OPEN: + desc32 = ULongToPtr(params32->param_1); + + open_desc.hMidi = ULongToPtr(desc32->hMidi); + open_desc.dwCallback = desc32->dwCallback; + open_desc.dwInstance = desc32->dwInstance; + open_desc.dnDevNode = desc32->dnDevNode; + open_desc.cIds = desc32->cIds; + open_desc.rgIds.dwStreamID = desc32->rgIds.dwStreamID; + open_desc.rgIds.wDeviceID = desc32->rgIds.wDeviceID; + + params.param_1 = (UINT_PTR)&open_desc; + break; + + case MIDM_ADDBUFFER: + hdr32 = ULongToPtr(params32->param_1); + + hdr = calloc(1, sizeof(*hdr)); + hdr->lpData = ULongToPtr(hdr32->lpData); + hdr->dwBufferLength = hdr32->dwBufferLength; + hdr->dwFlags = hdr32->dwFlags; + hdr->dwReserved[7] = params32->param_1; /* keep hdr32 for MIM_LONGDATA notification */ + + params.param_1 = (UINT_PTR)hdr; + params.param_2 = sizeof(*hdr); + break; + + case MIDM_PREPARE: /* prepare and unprepare are easier to handle explicitly */ + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_in_prepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + + case MIDM_UNPREPARE: + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_in_unprepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + } + + midi_in_message(&params); + + switch (params32->msg) + { + case MIDM_ADDBUFFER: + hdr32 = ULongToPtr(params32->param_1); + + if (!*params.err) + { + hdr32->dwFlags = hdr->dwFlags; + hdr32->dwBytesRecorded = hdr->dwBytesRecorded; + hdr32->lpNext = 0; + } + else + free(hdr); + break; + } + + if (notify.send_notify) + { + notify_to_notify32(notify32, &notify); + + if (notify.msg == MIM_LONGDATA) + { + hdr = (MIDIHDR *)notify.param_1; + notify32->param_1 = hdr->dwReserved[7]; + hdr32 = ULongToPtr(notify32->param_1); + hdr32->dwBytesRecorded = hdr->dwBytesRecorded; + hdr32->dwFlags = hdr->dwFlags; + free(hdr); + } + } + return STATUS_SUCCESS; +} + +NTSTATUS wow64_midi_notify_wait(void *args) +{ + struct + { + PTR32 quit; + PTR32 notify; + } *params32 = args; + struct notify_context32 *notify32 = ULongToPtr(params32->notify); + struct midi_hdr32 *hdr32; + struct notify_context notify; + MIDIHDR *hdr; + struct midi_notify_wait_params params = + { + .quit = ULongToPtr(params32->quit), + .notify = &notify + }; + notify32->send_notify = FALSE; + + midi_notify_wait(&params); + + if (!*params.quit && notify.send_notify) + { + notify_to_notify32(notify32, &notify); + + if (notify.msg == MIM_LONGDATA) + { + hdr = (MIDIHDR *)notify.param_1; + notify32->param_1 = hdr->dwReserved[7]; + hdr32 = ULongToPtr(notify32->param_1); + hdr32->dwBytesRecorded = hdr->dwBytesRecorded; + hdr32->dwFlags = hdr->dwFlags; + free(hdr); + } + } + return STATUS_SUCCESS; +} + +#endif /* _WIN64 */ diff --git a/dlls/winealsa.drv/unixlib.h b/dlls/winealsa.drv/unixlib.h index 56507ef9f0a..dea3b5ebdc9 100644 --- a/dlls/winealsa.drv/unixlib.h +++ b/dlls/winealsa.drv/unixlib.h @@ -284,6 +284,12 @@ NTSTATUS midi_out_message(void *args) DECLSPEC_HIDDEN; NTSTATUS midi_in_message(void *args) DECLSPEC_HIDDEN; NTSTATUS midi_notify_wait(void *args) DECLSPEC_HIDDEN; +#ifdef _WIN64 +NTSTATUS wow64_midi_out_message(void *args) DECLSPEC_HIDDEN; +NTSTATUS wow64_midi_in_message(void *args) DECLSPEC_HIDDEN; +NTSTATUS wow64_midi_notify_wait(void *args) DECLSPEC_HIDDEN; +#endif + extern unixlib_handle_t alsa_handle; #define ALSA_CALL(func, params) __wine_unix_call(alsa_handle, alsa_ ## func, params) -- 2.25.1

2 1

[PATCH 5/6] winealsa: Implement Wow64 mmdevapi entry points in the Unix libraray.
by Huw Davies April 22, 2022

April 22, 2022

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winealsa.drv/alsa.c | 408 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 408 insertions(+) diff --git a/dlls/winealsa.drv/alsa.c b/dlls/winealsa.drv/alsa.c index 272040f8047..db654bd75b9 100644 --- a/dlls/winealsa.drv/alsa.c +++ b/dlls/winealsa.drv/alsa.c @@ -2467,3 +2467,411 @@ unixlib_entry_t __wine_unix_call_funcs[] = midi_in_message, midi_notify_wait, }; + +#ifdef _WIN64 + +typedef UINT PTR32; + +static NTSTATUS wow64_get_endpoint_ids(void *args) +{ + struct + { + EDataFlow flow; + PTR32 endpoints; + unsigned int size; + HRESULT result; + unsigned int num; + unsigned int default_idx; + } *params32 = args; + struct get_endpoint_ids_params params = + { + .flow = params32->flow, + .endpoints = ULongToPtr(params32->endpoints), + .size = params32->size + }; + get_endpoint_ids(&params); + params32->size = params.size; + params32->result = params.result; + params32->num = params.num; + params32->default_idx = params.default_idx; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_create_stream(void *args) +{ + struct + { + PTR32 alsa_name; + EDataFlow flow; + AUDCLNT_SHAREMODE share; + DWORD flags; + REFERENCE_TIME duration; + REFERENCE_TIME period; + PTR32 fmt; + HRESULT result; + PTR32 stream; + } *params32 = args; + struct create_stream_params params = + { + .alsa_name = ULongToPtr(params32->alsa_name), + .flow = params32->flow, + .share = params32->share, + .flags = params32->flags, + .duration = params32->duration, + .period = params32->period, + .fmt = ULongToPtr(params32->fmt), + .stream = ULongToPtr(params32->stream) + }; + create_stream(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_release_stream(void *args) +{ + struct + { + stream_handle stream; + PTR32 timer_thread; + HRESULT result; + } *params32 = args; + struct release_stream_params params = + { + .stream = params32->stream, + .timer_thread = ULongToHandle(params32->timer_thread) + }; + release_stream(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_render_buffer(void *args) +{ + struct + { + stream_handle stream; + UINT32 frames; + HRESULT result; + PTR32 data; + } *params32 = args; + BYTE *data = NULL; + struct get_render_buffer_params params = + { + .stream = params32->stream, + .frames = params32->frames, + .data = &data + }; + get_render_buffer(&params); + params32->result = params.result; + *(unsigned int *)ULongToPtr(params32->data) = PtrToUlong(data); + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_capture_buffer(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 data; + PTR32 frames; + PTR32 flags; + PTR32 devpos; + PTR32 qpcpos; + } *params32 = args; + BYTE *data = NULL; + struct get_capture_buffer_params params = + { + .stream = params32->stream, + .data = &data, + .frames = ULongToPtr(params32->frames), + .flags = ULongToPtr(params32->flags), + .devpos = ULongToPtr(params32->devpos), + .qpcpos = ULongToPtr(params32->qpcpos) + }; + get_capture_buffer(&params); + params32->result = params.result; + *(unsigned int *)ULongToPtr(params32->data) = PtrToUlong(data); + return STATUS_SUCCESS; +}; + +static NTSTATUS wow64_is_format_supported(void *args) +{ + struct + { + PTR32 alsa_name; + EDataFlow flow; + AUDCLNT_SHAREMODE share; + PTR32 fmt_in; + PTR32 fmt_out; + HRESULT result; + } *params32 = args; + struct is_format_supported_params params = + { + .alsa_name = ULongToPtr(params32->alsa_name), + .flow = params32->flow, + .share = params32->share, + .fmt_in = ULongToPtr(params32->fmt_in), + .fmt_out = ULongToPtr(params32->fmt_out) + }; + is_format_supported(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_mix_format(void *args) +{ + struct + { + PTR32 alsa_name; + EDataFlow flow; + PTR32 fmt; + HRESULT result; + } *params32 = args; + struct get_mix_format_params params = + { + .alsa_name = ULongToPtr(params32->alsa_name), + .flow = params32->flow, + .fmt = ULongToPtr(params32->fmt) + }; + get_mix_format(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_buffer_size(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 size; + } *params32 = args; + struct get_buffer_size_params params = + { + .stream = params32->stream, + .size = ULongToPtr(params32->size) + }; + get_buffer_size(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_latency(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 latency; + } *params32 = args; + struct get_latency_params params = + { + .stream = params32->stream, + .latency = ULongToPtr(params32->latency) + }; + get_latency(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_current_padding(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 padding; + } *params32 = args; + struct get_current_padding_params params = + { + .stream = params32->stream, + .padding = ULongToPtr(params32->padding) + }; + get_current_padding(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_next_packet_size(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 frames; + } *params32 = args; + struct get_next_packet_size_params params = + { + .stream = params32->stream, + .frames = ULongToPtr(params32->frames) + }; + get_next_packet_size(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_frequency(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 freq; + } *params32 = args; + struct get_frequency_params params = + { + .stream = params32->stream, + .freq = ULongToPtr(params32->freq) + }; + get_frequency(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_position(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 pos; + PTR32 qpctime; + } *params32 = args; + struct get_position_params params = + { + .stream = params32->stream, + .pos = ULongToPtr(params32->pos), + .qpctime = ULongToPtr(params32->qpctime) + }; + get_position(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_set_volumes(void *args) +{ + struct + { + stream_handle stream; + float master_volume; + PTR32 volumes; + PTR32 session_volumes; + } *params32 = args; + struct set_volumes_params params = + { + .stream = params32->stream, + .master_volume = params32->master_volume, + .volumes = ULongToPtr(params32->volumes), + .session_volumes = ULongToPtr(params32->session_volumes) + }; + return set_volumes(&params); +} + +static NTSTATUS wow64_set_event_handle(void *args) +{ + struct + { + stream_handle stream; + PTR32 event; + HRESULT result; + } *params32 = args; + struct set_event_handle_params params = + { + .stream = params32->stream, + .event = ULongToHandle(params32->event) + }; + + set_event_handle(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_prop_value(void *args) +{ + struct propvariant32 + { + WORD vt; + WORD pad1, pad2, pad3; + union + { + ULONG ulVal; + PTR32 ptr; + ULARGE_INTEGER uhVal; + }; + } *value32; + struct + { + PTR32 alsa_name; + EDataFlow flow; + PTR32 guid; + PTR32 prop; + HRESULT result; + PTR32 value; + PTR32 buffer; /* caller allocated buffer to hold value's strings */ + PTR32 buffer_size; + } *params32 = args; + PROPVARIANT value; + struct get_prop_value_params params = + { + .alsa_name = ULongToPtr(params32->alsa_name), + .flow = params32->flow, + .guid = ULongToPtr(params32->guid), + .prop = ULongToPtr(params32->prop), + .value = &value, + .buffer = ULongToPtr(params32->buffer), + .buffer_size = ULongToPtr(params32->buffer_size) + }; + get_prop_value(&params); + params32->result = params.result; + if (SUCCEEDED(params.result)) + { + value32 = UlongToPtr(params32->value); + value32->vt = value.vt; + switch (value.vt) + { + case VT_UI4: + value32->ulVal = value.ulVal; + break; + case VT_LPWSTR: + value32->ptr = params32->buffer; + break; + default: + FIXME("Unhandled vt %04x\n", value.vt); + } + } + return STATUS_SUCCESS; +} + +unixlib_entry_t __wine_unix_call_wow64_funcs[] = +{ + wow64_get_endpoint_ids, + wow64_create_stream, + wow64_release_stream, + start, + stop, + reset, + timer_loop, + wow64_get_render_buffer, + release_render_buffer, + wow64_get_capture_buffer, + release_capture_buffer, + wow64_is_format_supported, + wow64_get_mix_format, + wow64_get_buffer_size, + wow64_get_latency, + wow64_get_current_padding, + wow64_get_next_packet_size, + wow64_get_frequency, + wow64_get_position, + wow64_set_volumes, + wow64_set_event_handle, + is_started, + wow64_get_prop_value, + midi_release, + midi_out_message, + midi_in_message, + midi_notify_wait, +}; + +#endif /* _WIN64 */ -- 2.25.1

2 1

[PATCH 4/6] winealsa: Limit Wow64 buffer allocations to 32-bit addresses.
by Huw Davies April 22, 2022

April 22, 2022

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winealsa.drv/alsa.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/dlls/winealsa.drv/alsa.c b/dlls/winealsa.drv/alsa.c index 0e86185e441..272040f8047 100644 --- a/dlls/winealsa.drv/alsa.c +++ b/dlls/winealsa.drv/alsa.c @@ -766,6 +766,15 @@ static void silence_buffer(struct alsa_stream *stream, BYTE *buffer, UINT32 fram memset(buffer, 0, frames * stream->fmt->nBlockAlign); } +static ULONG_PTR zero_bits(void) +{ +#ifdef _WIN64 + return !NtCurrentTeb()->WowTebOffset ? 0 : 0x7fffffff; +#else + return 0; +#endif +} + static NTSTATUS create_stream(void *args) { struct create_stream_params *params = args; @@ -948,7 +957,7 @@ static NTSTATUS create_stream(void *args) stream->fmt = &fmtex->Format; size = stream->bufsize_frames * params->fmt->nBlockAlign; - if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->local_buffer, 0, &size, + if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->local_buffer, zero_bits(), &size, MEM_COMMIT, PAGE_READWRITE)){ params->result = E_OUTOFMEMORY; goto exit; @@ -1661,7 +1670,7 @@ static NTSTATUS get_render_buffer(void *args) stream->tmp_buffer = NULL; } size = frames * stream->fmt->nBlockAlign; - if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, 0, &size, + if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, zero_bits(), &size, MEM_COMMIT, PAGE_READWRITE)){ stream->tmp_buffer_frames = 0; return alsa_unlock_result(stream, &params->result, E_OUTOFMEMORY); @@ -1764,7 +1773,7 @@ static NTSTATUS get_capture_buffer(void *args) stream->tmp_buffer = NULL; } size = *frames * stream->fmt->nBlockAlign; - if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, 0, &size, + if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, zero_bits(), &size, MEM_COMMIT, PAGE_READWRITE)){ stream->tmp_buffer_frames = 0; return alsa_unlock_result(stream, &params->result, E_OUTOFMEMORY); -- 2.25.1

2 1

[PATCH 3/6] winealsa: Return offsets rather than ptrs to the strings.
by Huw Davies April 22, 2022

April 22, 2022

This will make the Wow64 syscall rather simpler. Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winealsa.drv/alsa.c | 26 +++++++++++++++----------- dlls/winealsa.drv/mmdevdrv.c | 9 ++++++--- dlls/winealsa.drv/unixlib.h | 4 ++-- 3 files changed, 23 insertions(+), 16 deletions(-) diff --git a/dlls/winealsa.drv/alsa.c b/dlls/winealsa.drv/alsa.c index 9cf99f5b459..0e86185e441 100644 --- a/dlls/winealsa.drv/alsa.c +++ b/dlls/winealsa.drv/alsa.c @@ -291,10 +291,16 @@ static WCHAR *construct_device_id(EDataFlow flow, const WCHAR *chunk1, const WCH return ret; } +struct endpt +{ + WCHAR *name; + char *device; +}; + struct endpoints_info { unsigned int num, size; - struct endpoint *endpoints; + struct endpt *endpoints; }; static void endpoints_add(struct endpoints_info *endpoints, WCHAR *name, char *device) @@ -467,10 +473,9 @@ static NTSTATUS get_endpoint_ids(void *args) static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0}; struct get_endpoint_ids_params *params = args; struct endpoints_info endpoints_info; - unsigned int i, needed, name_len, device_len; + unsigned int i, needed, name_len, device_len, offset; struct endpoint *endpoint; int err, card; - char *ptr; card = -1; @@ -505,9 +510,8 @@ static NTSTATUS get_endpoint_ids(void *args) if(err != 0) WARN("Got a failure during card enumeration: %d (%s)\n", err, snd_strerror(err)); - needed = endpoints_info.num * sizeof(*params->endpoints); + offset = needed = endpoints_info.num * sizeof(*params->endpoints); endpoint = params->endpoints; - ptr = (char *)(endpoint + endpoints_info.num); for(i = 0; i < endpoints_info.num; i++){ name_len = wcslen(endpoints_info.endpoints[i].name) + 1; @@ -515,12 +519,12 @@ static NTSTATUS get_endpoint_ids(void *args) needed += name_len * sizeof(WCHAR) + ((device_len + 1) & ~1); if(needed <= params->size){ - endpoint->name = (WCHAR *)ptr; - memcpy(endpoint->name, endpoints_info.endpoints[i].name, name_len * sizeof(WCHAR)); - ptr += name_len * sizeof(WCHAR); - endpoint->device = ptr; - memcpy(endpoint->device, endpoints_info.endpoints[i].device, device_len); - ptr += (device_len + 1) & ~1; + endpoint->name = offset; + memcpy((char *)params->endpoints + offset, endpoints_info.endpoints[i].name, name_len * sizeof(WCHAR)); + offset += name_len * sizeof(WCHAR); + endpoint->device = offset; + memcpy((char *)params->endpoints + offset, endpoints_info.endpoints[i].device, device_len); + offset += (device_len + 1) & ~1; endpoint++; } free(endpoints_info.endpoints[i].name); diff --git a/dlls/winealsa.drv/mmdevdrv.c b/dlls/winealsa.drv/mmdevdrv.c index 24e778db931..1a99f0ac26c 100644 --- a/dlls/winealsa.drv/mmdevdrv.c +++ b/dlls/winealsa.drv/mmdevdrv.c @@ -366,14 +366,17 @@ HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids_out, GUID **gu } for(i = 0; i < params.num; i++){ - unsigned int size = (wcslen(params.endpoints[i].name) + 1) * sizeof(WCHAR); + WCHAR *name = (WCHAR *)((char *)params.endpoints + params.endpoints[i].name); + char *device = (char *)params.endpoints + params.endpoints[i].device; + unsigned int size = (wcslen(name) + 1) * sizeof(WCHAR); + ids[i] = HeapAlloc(GetProcessHeap(), 0, size); if(!ids[i]){ params.result = E_OUTOFMEMORY; goto end; } - memcpy(ids[i], params.endpoints[i].name, size); - get_device_guid(flow, params.endpoints[i].device, guids + i); + memcpy(ids[i], name, size); + get_device_guid(flow, device, guids + i); } *def_index = params.default_idx; diff --git a/dlls/winealsa.drv/unixlib.h b/dlls/winealsa.drv/unixlib.h index ed769d81948..56507ef9f0a 100644 --- a/dlls/winealsa.drv/unixlib.h +++ b/dlls/winealsa.drv/unixlib.h @@ -22,8 +22,8 @@ typedef UINT64 stream_handle; struct endpoint { - WCHAR *name; - char *device; + unsigned int name; + unsigned int device; }; struct get_endpoint_ids_params -- 2.25.1

2 1