April 2021 - wine-devel

[PATCH 1/2] qedit/tests: Check the Sample Grabber's buffer during and after flushing.
by Gabriel Ivăncescu 04 Oct '22

04 Oct '22

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/qedit/tests/samplegrabber.c | 234 +++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) diff --git a/dlls/qedit/tests/samplegrabber.c b/dlls/qedit/tests/samplegrabber.c index 8e68e3e..e66180f 100644 --- a/dlls/qedit/tests/samplegrabber.c +++ b/dlls/qedit/tests/samplegrabber.c @@ -1036,6 +1036,239 @@ static void test_connect_pin(void) ok(!ref, "Got outstanding refcount %d.\n", ref); } +struct frame_thread_params +{ + IMemInputPin *sink; + IMediaSample *sample; + DWORD delay; +}; + +static DWORD WINAPI frame_thread(void *arg) +{ + struct frame_thread_params *params = arg; + HRESULT hr; + + if (params->delay) + { + if (winetest_debug > 1) trace("%04x: Sleeping %u ms.\n", GetCurrentThreadId(), params->delay); + Sleep(params->delay); + } + if (winetest_debug > 1) trace("%04x: Sending frame.\n", GetCurrentThreadId()); + hr = IMemInputPin_Receive(params->sink, params->sample); + if (winetest_debug > 1) trace("%04x: Returned %#x.\n", GetCurrentThreadId(), hr); + IMediaSample_Release(params->sample); + free(params); + return hr; +} + +static HANDLE send_frame_time(IMemInputPin *sink, REFERENCE_TIME start_time, unsigned char color, DWORD delay) +{ + struct frame_thread_params *params = malloc(sizeof(*params)); + IMemAllocator *allocator; + REFERENCE_TIME end_time; + IMediaSample *sample; + HANDLE thread; + HRESULT hr; + BYTE *data; + + hr = IMemInputPin_GetAllocator(sink, &allocator); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMemAllocator_GetBuffer(allocator, &sample, NULL, NULL, 0); + if (hr == VFW_E_NOT_COMMITTED) + { + IMemAllocator_Commit(allocator); + hr = IMemAllocator_GetBuffer(allocator, &sample, NULL, NULL, 0); + } + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSample_GetPointer(sample, &data); + ok(hr == S_OK, "Got hr %#x.\n", hr); + memset(data, 0x55, 32 * 16 * 2); + + hr = IMediaSample_SetActualDataLength(sample, 32 * 16 * 2); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + start_time *= 10000000; + end_time = start_time + 10000000; + hr = IMediaSample_SetTime(sample, &start_time, &end_time); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + params->sink = sink; + params->sample = sample; + params->delay = delay; + thread = CreateThread(NULL, 0, frame_thread, params, 0, NULL); + + IMemAllocator_Release(allocator); + return thread; +} + +static HANDLE send_frame(IMemInputPin *sink, DWORD delay) +{ + return send_frame_time(sink, 0, 0x55, delay); /* purple */ +} + +static HRESULT join_thread_(int line, HANDLE thread) +{ + DWORD ret; + ok_(__FILE__, line)(!WaitForSingleObject(thread, 1000), "Wait failed.\n"); + GetExitCodeThread(thread, &ret); + CloseHandle(thread); + return ret; +} +#define join_thread(a) join_thread_(__LINE__, a) + +static void test_buffer_flush(void) +{ + AM_MEDIA_TYPE req_mt = + { + .majortype = MEDIATYPE_Video, + .subtype = MEDIASUBTYPE_RGB565, + .formattype = FORMAT_VideoInfo, + .bTemporalCompression = TRUE, + }; + LONG buf[(32 * 16 * 2) / sizeof(LONG)], size = sizeof(buf); + IPin *sink, *source, *renderer_pin; + struct testfilter testsource; + ISampleGrabber *grabber; + IMediaControl *control; + IFilterGraph2 *graph; + IMemInputPin *input; + IBaseFilter *filter; + OAFilterState state; + IMediaFilter *mf; + HANDLE thread; + DWORD ticks; + unsigned i; + HRESULT hr; + ULONG ref; + + testfilter_init(&testsource); + CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, + &IID_IFilterGraph2, (void **)&graph); + CoCreateInstance(&CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, + &IID_IBaseFilter, (void **)&filter); + IFilterGraph2_AddFilter(graph, filter, L"sink"); + IBaseFilter_FindPin(filter, L"In", &renderer_pin); + IBaseFilter_Release(filter); + + filter = create_sample_grabber(); + IFilterGraph2_AddFilter(graph, &testsource.filter.IBaseFilter_iface, L"source"); + IFilterGraph2_AddFilter(graph, filter, L"sample grabber"); + IBaseFilter_FindPin(filter, L"In", &sink); + IBaseFilter_FindPin(filter, L"Out", &source); + IBaseFilter_QueryInterface(filter, &IID_ISampleGrabber, (void **)&grabber); + IFilterGraph2_QueryInterface(graph, &IID_IMediaControl, (void **)&control); + IPin_QueryInterface(sink, &IID_IMemInputPin, (void **)&input); + + ISampleGrabber_SetMediaType(grabber, &req_mt); + ISampleGrabber_SetBufferSamples(grabber, TRUE); + + testsource.sink_mt = &req_mt; + hr = IFilterGraph2_ConnectDirect(graph, &testsource.source.pin.IPin_iface, sink, &req_mt); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IFilterGraph2_ConnectDirect(graph, source, renderer_pin, &req_mt); + ok(hr == S_OK, "Got hr %#x.\n", hr); + IPin_Release(renderer_pin); + + IFilterGraph2_QueryInterface(graph, &IID_IMediaFilter, (void **)&mf); + IMediaFilter_SetSyncSource(mf, NULL); + IMediaFilter_Release(mf); + + hr = IMemInputPin_ReceiveCanBlock(input); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == VFW_E_WRONG_STATE, "Got hr %#x.\n", hr); + + hr = IMediaControl_Pause(control); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + thread = send_frame(input, 0); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Thread should block in Receive().\n"); + + for (i = 0; i < 3; i++) + { + ticks = GetTickCount(); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + } + + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = join_thread(thread); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(state == State_Stopped, "Got state %d.\n", state); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_Pause(control); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + thread = send_frame(input, 0); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Thread should block in Receive().\n"); + + for (i = 0; i < 3; i++) + { + ticks = GetTickCount(); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + } + + IPin_BeginFlush(sink); + hr = join_thread(thread); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == S_OK, "Got hr %#x.\n", hr); + IPin_EndFlush(sink); + + hr = IMediaControl_GetState(control, 0, &state); + todo_wine ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + ticks = GetTickCount(); + thread = send_frame(input, 150); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = join_thread(thread); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + IPin_Release(sink); + IPin_Release(source); + IMemInputPin_Release(input); + IMediaControl_Release(control); + ref = IFilterGraph2_Release(graph); + ok(!ref, "Got outstanding refcount %d.\n", ref); + ISampleGrabber_Release(grabber); + ref = IBaseFilter_Release(filter); + ok(!ref, "Got outstanding refcount %d.\n", ref); + ref = IBaseFilter_Release(&testsource.filter.IBaseFilter_iface); + ok(!ref, "Got outstanding refcount %d.\n", ref); +} + START_TEST(samplegrabber) { IBaseFilter *filter; @@ -1059,6 +1292,7 @@ START_TEST(samplegrabber) test_aggregation(); test_media_types(); test_connect_pin(); + test_buffer_flush(); CoUninitialize(); } -- 2.21.0

5 7

[PATCH] include: add AV1 support to dxva.h
by Steve Lhomme 09 Aug '21

09 Aug '21

Based on the DXVA AV1 specs https://www.microsoft.com/en-us/download/details.aspx?id=101577 The structures and the associated define are available in Windows SDK since at least 10.0.20231.0. The GUIDs were present in previous SDKs as well. --- include/dxva.h | 279 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 279 insertions(+) diff --git a/include/dxva.h b/include/dxva.h index 4f18f2e60da..b474bd87111 100644 --- a/include/dxva.h +++ b/include/dxva.h @@ -563,6 +563,285 @@ typedef struct _DXVA_Status_VPx USHORT wNumMbsAffected; } DXVA_Status_VPx, *LPDXVA_Status_VPx; + +#define _DIRECTX_AV1_VA_ + +/* AV1 decoder GUIDs */ +DEFINE_GUID(DXVA_ModeAV1_VLD_Profile0, 0xb8be4ccb, 0xcf53, 0x46ba, 0x8d, 0x59, 0xd6, 0xb8, 0xa6, 0xda, 0x5d, 0x2a); +DEFINE_GUID(DXVA_ModeAV1_VLD_Profile1, 0x6936ff0f, 0x45b1, 0x4163, 0x9c, 0xc1, 0x64, 0x6e, 0xf6, 0x94, 0x61, 0x08); +DEFINE_GUID(DXVA_ModeAV1_VLD_Profile2, 0x0c5f2aa1, 0xe541, 0x4089, 0xbb, 0x7b, 0x98, 0x11, 0x0a, 0x19, 0xd7, 0xc8); +DEFINE_GUID(DXVA_ModeAV1_VLD_12bit_Profile2, 0x17127009, 0xa00f, 0x4ce1, 0x99, 0x4e, 0xbf, 0x40, 0x81, 0xf6, 0xf3, 0xf0); +DEFINE_GUID(DXVA_ModeAV1_VLD_12bit_Profile2_420, 0x2d80bed6, 0x9cac, 0x4835, 0x9e, 0x91, 0x32, 0x7b, 0xbc, 0x4f, 0x9e, 0xe8); + +/* AV1 picture entry data structure */ +typedef struct _DXVA_PicEntry_AV1 { + UINT width; + UINT height; + + // Global motion parameters + INT wmmat[6]; + union { + struct { + UCHAR wminvalid : 1; + UCHAR wmtype : 2; + UCHAR Reserved : 5; + }; + UCHAR GlobalMotionFlags; + }; + UCHAR Index; + USHORT Reserved16Bits; +} DXVA_PicEntry_AV1, *LPDXVA_PicEntry_AV1; + +/* AV1 picture parameters data structure */ +typedef struct _DXVA_PicParams_AV1 { + UINT width; + UINT height; + + UINT max_width; + UINT max_height; + + UCHAR CurrPicTextureIndex; + UCHAR superres_denom; + UCHAR bitdepth; + UCHAR seq_profile; + + // Tiles: + struct { + UCHAR cols; + UCHAR rows; + USHORT context_update_id; + USHORT widths[64]; + USHORT heights[64]; + } tiles; + + // Coding Tools + union { + struct { + UINT use_128x128_superblock : 1; + UINT intra_edge_filter : 1; + UINT interintra_compound : 1; + UINT masked_compound : 1; + UINT warped_motion : 1; + UINT dual_filter : 1; + UINT jnt_comp : 1; + UINT screen_content_tools : 1; + UINT integer_mv : 1; + UINT cdef : 1; + UINT restoration : 1; + UINT film_grain : 1; + UINT intrabc : 1; + UINT high_precision_mv : 1; + UINT switchable_motion_mode : 1; + UINT filter_intra : 1; + UINT disable_frame_end_update_cdf : 1; + UINT disable_cdf_update : 1; + UINT reference_mode : 1; + UINT skip_mode : 1; + UINT reduced_tx_set : 1; + UINT superres : 1; + UINT tx_mode : 2; + UINT use_ref_frame_mvs : 1; + UINT enable_ref_frame_mvs : 1; + UINT reference_frame_update : 1; + UINT Reserved : 5; + }; + UINT32 CodingParamToolFlags; + } coding; + + // Format & Picture Info flags + union { + struct { + UCHAR frame_type : 2; + UCHAR show_frame : 1; + UCHAR showable_frame : 1; + UCHAR subsampling_x : 1; + UCHAR subsampling_y : 1; + UCHAR mono_chrome : 1; + UCHAR Reserved : 1; + }; + UCHAR FormatAndPictureInfoFlags; + } format; + + // References + UCHAR primary_ref_frame; + UCHAR order_hint; + UCHAR order_hint_bits; + + DXVA_PicEntry_AV1 frame_refs[7]; + UCHAR RefFrameMapTextureIndex[8]; + + // Loop filter parameters + struct { + UCHAR filter_level[2]; + UCHAR filter_level_u; + UCHAR filter_level_v; + + UCHAR sharpness_level; + union { + struct { + UCHAR mode_ref_delta_enabled : 1; + UCHAR mode_ref_delta_update : 1; + UCHAR delta_lf_multi : 1; + UCHAR delta_lf_present : 1; + UCHAR Reserved : 4; + }; + UCHAR ControlFlags; + } DUMMYUNIONNAME; + CHAR ref_deltas[8]; + CHAR mode_deltas[2]; + UCHAR delta_lf_res; + UCHAR frame_restoration_type[3]; + USHORT log2_restoration_unit_size[3]; + UINT16 Reserved16Bits; + } loop_filter; + + // Quantization + struct { + union { + struct { + UCHAR delta_q_present : 1; + UCHAR delta_q_res : 2; + UCHAR Reserved : 5; + }; + UCHAR ControlFlags; + } DUMMYUNIONNAME; + + UCHAR base_qindex; + CHAR y_dc_delta_q; + CHAR u_dc_delta_q; + CHAR v_dc_delta_q; + CHAR u_ac_delta_q; + CHAR v_ac_delta_q; + // using_qmatrix: + UCHAR qm_y; + UCHAR qm_u; + UCHAR qm_v; + UINT16 Reserved16Bits; + } quantization; + + // Cdef parameters + struct { + union { + struct { + UCHAR damping : 2; + UCHAR bits : 2; + UCHAR Reserved : 4; + }; + UCHAR ControlFlags; + } DUMMYUNIONNAME; + + union { + struct { + UCHAR primary : 6; + UCHAR secondary : 2; + }; + UCHAR combined; + } y_strengths[8]; + + union { + struct { + UCHAR primary : 6; + UCHAR secondary : 2; + }; + UCHAR combined; + } uv_strengths[8]; + + } cdef; + + UCHAR interp_filter; + + // Segmentation + struct { + union { + struct { + UCHAR enabled : 1; + UCHAR update_map : 1; + UCHAR update_data : 1; + UCHAR temporal_update : 1; + UCHAR Reserved : 4; + }; + UCHAR ControlFlags; + } DUMMYUNIONNAME; + UCHAR Reserved24Bits[3]; + + union { + struct { + UCHAR alt_q : 1; + UCHAR alt_lf_y_v : 1; + UCHAR alt_lf_y_h : 1; + UCHAR alt_lf_u : 1; + UCHAR alt_lf_v : 1; + UCHAR ref_frame : 1; + UCHAR skip : 1; + UCHAR globalmv : 1; + }; + UCHAR mask; + } feature_mask[8]; + + SHORT feature_data[8][8]; + + } segmentation; + + struct { + union { + struct { + USHORT apply_grain : 1; + USHORT scaling_shift_minus8 : 2; + USHORT chroma_scaling_from_luma : 1; + USHORT ar_coeff_lag : 2; + USHORT ar_coeff_shift_minus6 : 2; + USHORT grain_scale_shift : 2; + USHORT overlap_flag : 1; + USHORT clip_to_restricted_range : 1; + USHORT matrix_coeff_is_identity : 1; + USHORT Reserved : 3; + }; + USHORT ControlFlags; + } DUMMYUNIONNAME; + + USHORT grain_seed; + UCHAR scaling_points_y[14][2]; + UCHAR num_y_points; + UCHAR scaling_points_cb[10][2]; + UCHAR num_cb_points; + UCHAR scaling_points_cr[10][2]; + UCHAR num_cr_points; + UCHAR ar_coeffs_y[24]; + UCHAR ar_coeffs_cb[25]; + UCHAR ar_coeffs_cr[25]; + UCHAR cb_mult; + UCHAR cb_luma_mult; + UCHAR cr_mult; + UCHAR cr_luma_mult; + UCHAR Reserved8Bits; + SHORT cb_offset; + SHORT cr_offset; + } film_grain; + + UINT Reserved32Bits; + UINT StatusReportFeedbackNumber; +} DXVA_PicParams_AV1, *LPDXVA_PicParams_AV1; + +/* AV1 tile data structure */ +typedef struct _DXVA_Tile_AV1 { + UINT DataOffset; + UINT DataSize; + USHORT row; + USHORT column; + USHORT Reserved16Bits; + UCHAR anchor_frame; + UCHAR Reserved8Bits; +} DXVA_Tile_AV1, *LPDXVA_Tile_AV1; + +typedef struct _DXVA_Status_AV1 { + UINT StatusReportFeedbackNumber; + DXVA_PicEntry_AV1 CurrPic; + UCHAR bBufType; + UCHAR bStatus; + UCHAR bReserved8Bits; + USHORT wNumMbsAffected; +} DXVA_Status_AV1, *LPDXVA_Status_AV1; + #include <poppack.h> typedef enum _DXVA_VideoChromaSubsampling -- 2.26.2

4 7

[PATCH vkd3d] build: Make the default symbol visibility "hidden".
by Zebediah Figura 12 Jul '21

12 Jul '21

We tag far fewer symbols this way. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- configure.ac | 1 + include/private/vkd3d_common.h | 6 + include/private/vkd3d_debug.h | 19 ++- include/private/vkd3d_memory.h | 3 +- include/private/vkd3d_utf8.h | 2 +- libs/vkd3d-common/debug.c | 2 +- libs/vkd3d-shader/dxbc.c | 6 +- libs/vkd3d-shader/vkd3d_shader_main.c | 24 +-- libs/vkd3d-shader/vkd3d_shader_private.h | 48 +++--- libs/vkd3d-utils/vkd3d_utils_main.c | 22 +-- libs/vkd3d/command.c | 6 +- libs/vkd3d/device.c | 16 +- libs/vkd3d/resource.c | 6 +- libs/vkd3d/utils.c | 4 +- libs/vkd3d/vkd3d_main.c | 10 +- libs/vkd3d/vkd3d_private.h | 188 +++++++++++------------ 16 files changed, 184 insertions(+), 179 deletions(-) diff --git a/configure.ac b/configure.ac index d5f6588..e9c135a 100644 --- a/configure.ac +++ b/configure.ac @@ -47,6 +47,7 @@ AC_SUBST([VKD3D_CFLAGS]) AS_IF([test "x${GCC}" = "xyes"], [VKD3D_CFLAGS="-Wall -pipe" VKD3D_CHECK_CFLAGS([-std=c99]) + VKD3D_CHECK_CFLAGS([-fvisibility=hidden]) VKD3D_CHECK_CFLAGS([-Wdeclaration-after-statement]) VKD3D_CHECK_CFLAGS([-Wimplicit-fallthrough]) VKD3D_CHECK_CFLAGS([-Wmissing-prototypes]) diff --git a/include/private/vkd3d_common.h b/include/private/vkd3d_common.h index ac217e9..fd62ae8 100644 --- a/include/private/vkd3d_common.h +++ b/include/private/vkd3d_common.h @@ -53,6 +53,12 @@ static inline size_t align(size_t addr, size_t alignment) # define VKD3D_UNUSED #endif /* __GNUC__ */ +#if defined(__GNUC__) && !defined(__MINGW32__) +# define VKD3D_API __attribute__((visibility("default"))) +#else +# define VKD3D_API +#endif + static inline unsigned int vkd3d_popcount(unsigned int v) { #ifdef _MSC_VER diff --git a/include/private/vkd3d_debug.h b/include/private/vkd3d_debug.h index c37c841..a206a92 100644 --- a/include/private/vkd3d_debug.h +++ b/include/private/vkd3d_debug.h @@ -44,15 +44,14 @@ enum vkd3d_dbg_level VKD3D_DBG_LEVEL_TRACE, }; -enum vkd3d_dbg_level vkd3d_dbg_get_level(void) DECLSPEC_HIDDEN; +enum vkd3d_dbg_level vkd3d_dbg_get_level(void); -void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, - const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN; +void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4); -const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2) DECLSPEC_HIDDEN; -const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args) DECLSPEC_HIDDEN; -const char *debugstr_a(const char *str) DECLSPEC_HIDDEN; -const char *debugstr_w(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN; +const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2); +const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args); +const char *debugstr_a(const char *str); +const char *debugstr_w(const WCHAR *wstr, size_t wchar_size); #define VKD3D_DBG_LOG(level) \ do { \ @@ -103,7 +102,7 @@ static inline const char *debugstr_guid(const GUID *guid) guid->Data4[5], guid->Data4[6], guid->Data4[7]); } -unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value) DECLSPEC_HIDDEN; +unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value); struct vkd3d_debug_option { @@ -111,8 +110,8 @@ struct vkd3d_debug_option uint64_t flag; }; -bool vkd3d_debug_list_has_member(const char *string, const char *member) DECLSPEC_HIDDEN; +bool vkd3d_debug_list_has_member(const char *string, const char *member); uint64_t vkd3d_parse_debug_options(const char *string, - const struct vkd3d_debug_option *options, unsigned int option_count) DECLSPEC_HIDDEN; + const struct vkd3d_debug_option *options, unsigned int option_count); #endif /* __VKD3D_DEBUG_H */ diff --git a/include/private/vkd3d_memory.h b/include/private/vkd3d_memory.h index df93abf..8bbc691 100644 --- a/include/private/vkd3d_memory.h +++ b/include/private/vkd3d_memory.h @@ -54,7 +54,6 @@ static inline void vkd3d_free(void *ptr) free(ptr); } -bool vkd3d_array_reserve(void **elements, size_t *capacity, - size_t element_count, size_t element_size) DECLSPEC_HIDDEN; +bool vkd3d_array_reserve(void **elements, size_t *capacity, size_t element_count, size_t element_size); #endif /* __VKD3D_MEMORY_H */ diff --git a/include/private/vkd3d_utf8.h b/include/private/vkd3d_utf8.h index ab32884..ccb9e17 100644 --- a/include/private/vkd3d_utf8.h +++ b/include/private/vkd3d_utf8.h @@ -21,6 +21,6 @@ #include "vkd3d_common.h" -char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN; +char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size); #endif /* __VKD3D_UTF8_H */ diff --git a/libs/vkd3d-common/debug.c b/libs/vkd3d-common/debug.c index 33deed6..a4d5a3d 100644 --- a/libs/vkd3d-common/debug.c +++ b/libs/vkd3d-common/debug.c @@ -31,7 +31,7 @@ #define VKD3D_DEBUG_BUFFER_COUNT 64 #define VKD3D_DEBUG_BUFFER_SIZE 512 -extern const char *vkd3d_dbg_env_name DECLSPEC_HIDDEN; +extern const char *vkd3d_dbg_env_name; static const char *debug_level_names[] = { diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 973a80d..231c48b 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -2726,7 +2726,7 @@ static int rts0_handler(const char *data, DWORD data_size, DWORD tag, void *cont return shader_parse_root_signature(data, data_size, desc); } -int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc, +VKD3D_API int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_versioned_root_signature_desc *root_signature, char **messages) { struct vkd3d_shader_message_context message_context; @@ -3288,7 +3288,7 @@ static int validate_root_signature_desc(const struct vkd3d_shader_versioned_root return ret; } -int vkd3d_shader_serialize_root_signature(const struct vkd3d_shader_versioned_root_signature_desc *root_signature, +VKD3D_API int vkd3d_shader_serialize_root_signature(const struct vkd3d_shader_versioned_root_signature_desc *root_signature, struct vkd3d_shader_code *dxbc, char **messages) { struct root_signature_writer_context context; @@ -3592,7 +3592,7 @@ fail: return ret; } -int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signature_desc *dst, +VKD3D_API int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signature_desc *dst, enum vkd3d_shader_root_signature_version version, const struct vkd3d_shader_versioned_root_signature_desc *src) { int ret; diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index 16d895f..4d49eef 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -292,14 +292,14 @@ static int vkd3d_shader_validate_compile_info(const struct vkd3d_shader_compile_ return VKD3D_OK; } -void vkd3d_shader_free_messages(char *messages) +VKD3D_API void vkd3d_shader_free_messages(char *messages) { TRACE("messages %p.\n", messages); vkd3d_free(messages); } -int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, +VKD3D_API int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out, char **messages) { struct vkd3d_shader_scan_descriptor_info scan_descriptor_info; @@ -837,7 +837,7 @@ static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *conte return VKD3D_OK; } -int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages) +VKD3D_API int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages) { struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info; struct vkd3d_shader_message_context *message_context; @@ -912,14 +912,14 @@ done: return ret; } -void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info) +VKD3D_API void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info) { TRACE("scan_descriptor_info %p.\n", scan_descriptor_info); vkd3d_free(scan_descriptor_info->descriptors); } -void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *shader_code) +VKD3D_API void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *shader_code) { TRACE("shader_code %p.\n", shader_code); @@ -960,7 +960,7 @@ static void vkd3d_shader_free_root_signature_v_1_1(struct vkd3d_shader_root_sign memset(root_signature, 0, sizeof(*root_signature)); } -void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signature_desc *desc) +VKD3D_API void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signature_desc *desc) { TRACE("desc %p.\n", desc); @@ -981,7 +981,7 @@ void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signatu desc->version = 0; } -int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc, +VKD3D_API int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_signature *signature, char **messages) { struct vkd3d_shader_message_context message_context; @@ -1004,7 +1004,7 @@ int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc, return ret; } -struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element( +VKD3D_API struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element( const struct vkd3d_shader_signature *signature, const char *semantic_name, unsigned int semantic_index, unsigned int stream_index) { @@ -1026,7 +1026,7 @@ struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element( return NULL; } -void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature) +VKD3D_API void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature) { TRACE("signature %p.\n", signature); @@ -1034,7 +1034,7 @@ void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature signature->elements = NULL; } -const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor) +VKD3D_API const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor) { int x, y; @@ -1052,7 +1052,7 @@ const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor) return "vkd3d-shader " PACKAGE_VERSION VKD3D_VCS_ID; } -const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(unsigned int *count) +VKD3D_API const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(unsigned int *count) { static const enum vkd3d_shader_source_type types[] = { @@ -1065,7 +1065,7 @@ const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(uns return types; } -const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types( +VKD3D_API const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types( enum vkd3d_shader_source_type source_type, unsigned int *count) { static const enum vkd3d_shader_target_type dxbc_tpf_types[] = diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 1acb01f..1291148 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -809,18 +809,18 @@ static inline bool vkd3d_shader_register_is_output(const struct vkd3d_shader_reg return reg->type == VKD3DSPR_OUTPUT || reg->type == VKD3DSPR_COLOROUT; } -void vkd3d_shader_trace(void *data) DECLSPEC_HIDDEN; +void vkd3d_shader_trace(void *data); -const char *shader_get_type_prefix(enum vkd3d_shader_type type) DECLSPEC_HIDDEN; +const char *shader_get_type_prefix(enum vkd3d_shader_type type); void *shader_sm4_init(const DWORD *byte_code, size_t byte_code_size, - const struct vkd3d_shader_signature *output_signature) DECLSPEC_HIDDEN; -void shader_sm4_free(void *data) DECLSPEC_HIDDEN; + const struct vkd3d_shader_signature *output_signature); +void shader_sm4_free(void *data); void shader_sm4_read_header(void *data, const DWORD **ptr, - struct vkd3d_shader_version *shader_version) DECLSPEC_HIDDEN; + struct vkd3d_shader_version *shader_version); void shader_sm4_read_instruction(void *data, const DWORD **ptr, - struct vkd3d_shader_instruction *ins) DECLSPEC_HIDDEN; -bool shader_sm4_is_end(void *data, const DWORD **ptr) DECLSPEC_HIDDEN; + struct vkd3d_shader_instruction *ins); +bool shader_sm4_is_end(void *data, const DWORD **ptr); struct vkd3d_string_buffer { @@ -829,9 +829,9 @@ struct vkd3d_string_buffer unsigned int content_size; }; -void vkd3d_string_buffer_cleanup(struct vkd3d_string_buffer *buffer) DECLSPEC_HIDDEN; -bool vkd3d_string_buffer_init(struct vkd3d_string_buffer *buffer) DECLSPEC_HIDDEN; -int vkd3d_string_buffer_vprintf(struct vkd3d_string_buffer *buffer, const char *format, va_list args) DECLSPEC_HIDDEN; +void vkd3d_string_buffer_cleanup(struct vkd3d_string_buffer *buffer); +bool vkd3d_string_buffer_init(struct vkd3d_string_buffer *buffer); +int vkd3d_string_buffer_vprintf(struct vkd3d_string_buffer *buffer, const char *format, va_list args); struct vkd3d_shader_message_context { @@ -841,39 +841,39 @@ struct vkd3d_shader_message_context struct vkd3d_string_buffer messages; }; -void vkd3d_shader_message_context_cleanup(struct vkd3d_shader_message_context *context) DECLSPEC_HIDDEN; -char *vkd3d_shader_message_context_copy_messages(struct vkd3d_shader_message_context *context) DECLSPEC_HIDDEN; +void vkd3d_shader_message_context_cleanup(struct vkd3d_shader_message_context *context); +char *vkd3d_shader_message_context_copy_messages(struct vkd3d_shader_message_context *context); bool vkd3d_shader_message_context_init(struct vkd3d_shader_message_context *context, - enum vkd3d_shader_log_level log_level, const char *source_name) DECLSPEC_HIDDEN; + enum vkd3d_shader_log_level log_level, const char *source_name); void vkd3d_shader_message_context_trace_messages_(const struct vkd3d_shader_message_context *context, - const char *function) DECLSPEC_HIDDEN; + const char *function); #define vkd3d_shader_message_context_trace_messages(context) \ vkd3d_shader_message_context_trace_messages_(context, __FUNCTION__) void vkd3d_shader_error(struct vkd3d_shader_message_context *context, enum vkd3d_shader_error error, - const char *format, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN; + const char *format, ...) VKD3D_PRINTF_FUNC(3, 4); void vkd3d_shader_verror(struct vkd3d_shader_message_context *context, - enum vkd3d_shader_error error, const char *format, va_list args) DECLSPEC_HIDDEN; + enum vkd3d_shader_error error, const char *format, va_list args); int shader_extract_from_dxbc(const void *dxbc, size_t dxbc_length, - struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_desc *desc) DECLSPEC_HIDDEN; -void free_shader_desc(struct vkd3d_shader_desc *desc) DECLSPEC_HIDDEN; + struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_desc *desc); +void free_shader_desc(struct vkd3d_shader_desc *desc); int shader_parse_input_signature(const void *dxbc, size_t dxbc_length, - struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_signature *signature) DECLSPEC_HIDDEN; + struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_signature *signature); struct vkd3d_dxbc_compiler; struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version, const struct vkd3d_shader_desc *shader_desc, const struct vkd3d_shader_compile_info *compile_info, const struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info, - struct vkd3d_shader_message_context *message_context) DECLSPEC_HIDDEN; + struct vkd3d_shader_message_context *message_context); int vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) DECLSPEC_HIDDEN; + const struct vkd3d_shader_instruction *instruction); int vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler, - const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *spirv) DECLSPEC_HIDDEN; -void vkd3d_dxbc_compiler_destroy(struct vkd3d_dxbc_compiler *compiler) DECLSPEC_HIDDEN; + const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *spirv); +void vkd3d_dxbc_compiler_destroy(struct vkd3d_dxbc_compiler *compiler); -void vkd3d_compute_dxbc_checksum(const void *dxbc, size_t size, uint32_t checksum[4]) DECLSPEC_HIDDEN; +void vkd3d_compute_dxbc_checksum(const void *dxbc, size_t size, uint32_t checksum[4]); static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_type( enum vkd3d_data_type data_type) diff --git a/libs/vkd3d-utils/vkd3d_utils_main.c b/libs/vkd3d-utils/vkd3d_utils_main.c index c19fe7f..b64693e 100644 --- a/libs/vkd3d-utils/vkd3d_utils_main.c +++ b/libs/vkd3d-utils/vkd3d_utils_main.c @@ -21,14 +21,14 @@ VKD3D_DEBUG_ENV_NAME("VKD3D_DEBUG"); -HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug) +VKD3D_API HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug) { FIXME("iid %s, debug %p stub!\n", debugstr_guid(iid), debug); return E_NOTIMPL; } -HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_feature_level, +VKD3D_API HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device, enum vkd3d_api_version api_version) { struct vkd3d_optional_instance_extensions_info optional_extensions_info; @@ -85,13 +85,13 @@ HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minim return vkd3d_create_device(&device_create_info, iid, device); } -HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, +VKD3D_API HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device) { return D3D12CreateDeviceVKD3D(adapter, minimum_feature_level, iid, device, VKD3D_API_VERSION_1_0); } -HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T data_size, +VKD3D_API HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer) { TRACE("data %p, data_size %lu, iid %s, deserializer %p.\n", @@ -100,7 +100,7 @@ HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T dat return vkd3d_create_root_signature_deserializer(data, data_size, iid, deserializer); } -HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, SIZE_T data_size, +VKD3D_API HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, SIZE_T data_size, REFIID iid,void **deserializer) { TRACE("data %p, data_size %lu, iid %s, deserializer %p.\n", @@ -109,7 +109,7 @@ HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, S return vkd3d_create_versioned_root_signature_deserializer(data, data_size, iid, deserializer); } -HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc, +VKD3D_API HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc, D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob) { TRACE("desc %p, version %#x, blob %p, error_blob %p.\n", desc, version, blob, error_blob); @@ -117,7 +117,7 @@ HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc return vkd3d_serialize_root_signature(desc, version, blob, error_blob); } -HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, +VKD3D_API HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, ID3DBlob **blob, ID3DBlob **error_blob) { TRACE("desc %p, blob %p, error_blob %p.\n", desc, blob, error_blob); @@ -126,7 +126,7 @@ HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_S } /* Events */ -HANDLE vkd3d_create_event(void) +VKD3D_API HANDLE vkd3d_create_event(void) { struct vkd3d_event *event; int rc; @@ -157,7 +157,7 @@ HANDLE vkd3d_create_event(void) return event; } -unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds) +VKD3D_API unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds) { struct vkd3d_event *impl = event; int rc; @@ -200,7 +200,7 @@ unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds) return VKD3D_WAIT_FAILED; } -HRESULT vkd3d_signal_event(HANDLE event) +VKD3D_API HRESULT vkd3d_signal_event(HANDLE event) { struct vkd3d_event *impl = event; int rc; @@ -219,7 +219,7 @@ HRESULT vkd3d_signal_event(HANDLE event) return S_OK; } -void vkd3d_destroy_event(HANDLE event) +VKD3D_API void vkd3d_destroy_event(HANDLE event) { struct vkd3d_event *impl = event; int rc; diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index e5c6791..4ff510a 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -6251,21 +6251,21 @@ HRESULT d3d12_command_queue_create(struct d3d12_device *device, return S_OK; } -uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue) +VKD3D_API uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue) { struct d3d12_command_queue *d3d12_queue = impl_from_ID3D12CommandQueue(queue); return d3d12_queue->vkd3d_queue->vk_family_index; } -VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue) +VKD3D_API VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue) { struct d3d12_command_queue *d3d12_queue = impl_from_ID3D12CommandQueue(queue); return vkd3d_queue_acquire(d3d12_queue->vkd3d_queue); } -void vkd3d_release_vk_queue(ID3D12CommandQueue *queue) +VKD3D_API void vkd3d_release_vk_queue(ID3D12CommandQueue *queue) { struct d3d12_command_queue *d3d12_queue = impl_from_ID3D12CommandQueue(queue); diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index bef6477..38d3d56 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -589,7 +589,7 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance, return S_OK; } -HRESULT vkd3d_create_instance(const struct vkd3d_instance_create_info *create_info, +VKD3D_API HRESULT vkd3d_create_instance(const struct vkd3d_instance_create_info *create_info, struct vkd3d_instance **instance) { struct vkd3d_instance *object; @@ -637,7 +637,7 @@ static void vkd3d_destroy_instance(struct vkd3d_instance *instance) vkd3d_free(instance); } -ULONG vkd3d_instance_incref(struct vkd3d_instance *instance) +VKD3D_API ULONG vkd3d_instance_incref(struct vkd3d_instance *instance) { ULONG refcount = InterlockedIncrement(&instance->refcount); @@ -646,7 +646,7 @@ ULONG vkd3d_instance_incref(struct vkd3d_instance *instance) return refcount; } -ULONG vkd3d_instance_decref(struct vkd3d_instance *instance) +VKD3D_API ULONG vkd3d_instance_decref(struct vkd3d_instance *instance) { ULONG refcount = InterlockedDecrement(&instance->refcount); @@ -658,7 +658,7 @@ ULONG vkd3d_instance_decref(struct vkd3d_instance *instance) return refcount; } -VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance) +VKD3D_API VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance) { return instance->vk_instance; } @@ -3828,28 +3828,28 @@ HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_ha return hr; } -IUnknown *vkd3d_get_device_parent(ID3D12Device *device) +VKD3D_API IUnknown *vkd3d_get_device_parent(ID3D12Device *device) { struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device); return d3d12_device->parent; } -VkDevice vkd3d_get_vk_device(ID3D12Device *device) +VKD3D_API VkDevice vkd3d_get_vk_device(ID3D12Device *device) { struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device); return d3d12_device->vk_device; } -VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device) +VKD3D_API VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device) { struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device); return d3d12_device->vk_physical_device; } -struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device) +VKD3D_API struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device) { struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device); diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index a9d4d46..a432806 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -1983,7 +1983,7 @@ HRESULT d3d12_reserved_resource_create(struct d3d12_device *device, return S_OK; } -HRESULT vkd3d_create_image_resource(ID3D12Device *device, +VKD3D_API HRESULT vkd3d_create_image_resource(ID3D12Device *device, const struct vkd3d_image_resource_create_info *create_info, ID3D12Resource **resource) { struct d3d12_device *d3d12_device = unsafe_impl_from_ID3D12Device(device); @@ -2035,13 +2035,13 @@ HRESULT vkd3d_create_image_resource(ID3D12Device *device, return S_OK; } -ULONG vkd3d_resource_incref(ID3D12Resource *resource) +VKD3D_API ULONG vkd3d_resource_incref(ID3D12Resource *resource) { TRACE("resource %p.\n", resource); return d3d12_resource_incref(impl_from_ID3D12Resource(resource)); } -ULONG vkd3d_resource_decref(ID3D12Resource *resource) +VKD3D_API ULONG vkd3d_resource_decref(ID3D12Resource *resource) { TRACE("resource %p.\n", resource); return d3d12_resource_decref(impl_from_ID3D12Resource(resource)); diff --git a/libs/vkd3d/utils.c b/libs/vkd3d/utils.c index 7abfd42..ea11f3a 100644 --- a/libs/vkd3d/utils.c +++ b/libs/vkd3d/utils.c @@ -506,7 +506,7 @@ void vkd3d_format_copy_data(const struct vkd3d_format *format, const uint8_t *sr } } -VkFormat vkd3d_get_vk_format(DXGI_FORMAT format) +VKD3D_API VkFormat vkd3d_get_vk_format(DXGI_FORMAT format) { const struct vkd3d_format *vkd3d_format; @@ -516,7 +516,7 @@ VkFormat vkd3d_get_vk_format(DXGI_FORMAT format) return vkd3d_format->vk_format; } -DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format) +VKD3D_API DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format) { DXGI_FORMAT dxgi_format; VkFormat vk_format; diff --git a/libs/vkd3d/vkd3d_main.c b/libs/vkd3d/vkd3d_main.c index 327cdf8..4c0d6c5 100644 --- a/libs/vkd3d/vkd3d_main.c +++ b/libs/vkd3d/vkd3d_main.c @@ -21,7 +21,7 @@ VKD3D_DEBUG_ENV_NAME("VKD3D_DEBUG"); -HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info, +VKD3D_API HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info, REFIID iid, void **device) { struct vkd3d_instance *instance; @@ -216,7 +216,7 @@ static HRESULT d3d12_root_signature_deserializer_init(struct d3d12_root_signatur return S_OK; } -HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size, +VKD3D_API HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer) { struct vkd3d_shader_code dxbc = {data, data_size}; @@ -400,7 +400,7 @@ static HRESULT d3d12_versioned_root_signature_deserializer_init(struct d3d12_ver return S_OK; } -HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZE_T data_size, +VKD3D_API HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer) { struct d3d12_versioned_root_signature_deserializer *object; @@ -537,7 +537,7 @@ static HRESULT d3d_blob_create(void *buffer, SIZE_T size, struct d3d_blob **blob return S_OK; } -HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc, +VKD3D_API HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc, D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob) { struct vkd3d_shader_versioned_root_signature_desc vkd3d_desc; @@ -592,7 +592,7 @@ HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc, return S_OK; } -HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, +VKD3D_API HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, ID3DBlob **blob, ID3DBlob **error_blob) { const struct vkd3d_shader_versioned_root_signature_desc *vkd3d_desc; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 9f0982d..54077f9 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -82,9 +82,9 @@ struct vkd3d_vk_device_procs }; #undef DECLARE_VK_PFN -HRESULT hresult_from_errno(int rc) DECLSPEC_HIDDEN; -HRESULT hresult_from_vk_result(VkResult vr) DECLSPEC_HIDDEN; -HRESULT hresult_from_vkd3d_result(int vkd3d_result) DECLSPEC_HIDDEN; +HRESULT hresult_from_errno(int rc); +HRESULT hresult_from_vk_result(VkResult vr); +HRESULT hresult_from_vkd3d_result(int vkd3d_result); struct vkd3d_vulkan_info { @@ -161,8 +161,8 @@ union vkd3d_thread_handle }; HRESULT vkd3d_create_thread(struct vkd3d_instance *instance, - PFN_vkd3d_thread thread_main, void *data, union vkd3d_thread_handle *thread) DECLSPEC_HIDDEN; -HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_handle *thread) DECLSPEC_HIDDEN; + PFN_vkd3d_thread thread_main, void *data, union vkd3d_thread_handle *thread); +HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_handle *thread); struct vkd3d_waiting_fence { @@ -199,9 +199,9 @@ struct vkd3d_fence_worker }; HRESULT vkd3d_fence_worker_start(struct vkd3d_fence_worker *worker, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); HRESULT vkd3d_fence_worker_stop(struct vkd3d_fence_worker *worker, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); struct vkd3d_gpu_va_allocation { @@ -230,11 +230,11 @@ struct vkd3d_gpu_va_allocator }; D3D12_GPU_VIRTUAL_ADDRESS vkd3d_gpu_va_allocator_allocate(struct vkd3d_gpu_va_allocator *allocator, - size_t alignment, size_t size, void *ptr) DECLSPEC_HIDDEN; + size_t alignment, size_t size, void *ptr); void *vkd3d_gpu_va_allocator_dereference(struct vkd3d_gpu_va_allocator *allocator, - D3D12_GPU_VIRTUAL_ADDRESS address) DECLSPEC_HIDDEN; + D3D12_GPU_VIRTUAL_ADDRESS address); void vkd3d_gpu_va_allocator_free(struct vkd3d_gpu_va_allocator *allocator, - D3D12_GPU_VIRTUAL_ADDRESS address) DECLSPEC_HIDDEN; + D3D12_GPU_VIRTUAL_ADDRESS address); struct vkd3d_render_pass_key { @@ -257,11 +257,11 @@ struct vkd3d_render_pass_cache }; void vkd3d_render_pass_cache_cleanup(struct vkd3d_render_pass_cache *cache, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); HRESULT vkd3d_render_pass_cache_find(struct vkd3d_render_pass_cache *cache, struct d3d12_device *device, const struct vkd3d_render_pass_key *key, - VkRenderPass *vk_render_pass) DECLSPEC_HIDDEN; -void vkd3d_render_pass_cache_init(struct vkd3d_render_pass_cache *cache) DECLSPEC_HIDDEN; + VkRenderPass *vk_render_pass); +void vkd3d_render_pass_cache_init(struct vkd3d_render_pass_cache *cache); struct vkd3d_private_store { @@ -317,11 +317,11 @@ static inline void vkd3d_private_store_destroy(struct vkd3d_private_store *store } HRESULT vkd3d_get_private_data(struct vkd3d_private_store *store, - const GUID *tag, unsigned int *out_size, void *out) DECLSPEC_HIDDEN; + const GUID *tag, unsigned int *out_size, void *out); HRESULT vkd3d_set_private_data(struct vkd3d_private_store *store, - const GUID *tag, unsigned int data_size, const void *data) DECLSPEC_HIDDEN; + const GUID *tag, unsigned int data_size, const void *data); HRESULT vkd3d_set_private_data_interface(struct vkd3d_private_store *store, - const GUID *tag, const IUnknown *object) DECLSPEC_HIDDEN; + const GUID *tag, const IUnknown *object); struct vkd3d_signaled_semaphore { @@ -362,7 +362,7 @@ struct d3d12_fence }; HRESULT d3d12_fence_create(struct d3d12_device *device, - uint64_t initial_value, D3D12_FENCE_FLAGS flags, struct d3d12_fence **fence) DECLSPEC_HIDDEN; + uint64_t initial_value, D3D12_FENCE_FLAGS flags, struct d3d12_fence **fence); /* ID3D12Heap */ struct d3d12_heap @@ -386,8 +386,8 @@ struct d3d12_heap }; HRESULT d3d12_heap_create(struct d3d12_device *device, const D3D12_HEAP_DESC *desc, - const struct d3d12_resource *resource, struct d3d12_heap **heap) DECLSPEC_HIDDEN; -struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface) DECLSPEC_HIDDEN; + const struct d3d12_resource *resource, struct d3d12_heap **heap); +struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface); #define VKD3D_RESOURCE_PUBLIC_FLAGS \ (VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION) @@ -435,29 +435,29 @@ static inline bool d3d12_resource_is_texture(const struct d3d12_resource *resour return resource->desc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER; } -bool d3d12_resource_is_cpu_accessible(const struct d3d12_resource *resource) DECLSPEC_HIDDEN; -HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc, struct d3d12_device *device) DECLSPEC_HIDDEN; +bool d3d12_resource_is_cpu_accessible(const struct d3d12_resource *resource); +HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc, struct d3d12_device *device); HRESULT d3d12_committed_resource_create(struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; + const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_heap *heap, uint64_t heap_offset, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; + const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); HRESULT d3d12_reserved_resource_create(struct d3d12_device *device, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; -struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface) DECLSPEC_HIDDEN; + const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); +struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface); HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - VkDeviceMemory *vk_memory, uint32_t *vk_memory_type, VkDeviceSize *vk_memory_size) DECLSPEC_HIDDEN; + VkDeviceMemory *vk_memory, uint32_t *vk_memory_type, VkDeviceSize *vk_memory_size); HRESULT vkd3d_create_buffer(struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer) DECLSPEC_HIDDEN; + const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer); HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, - const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info) DECLSPEC_HIDDEN; + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info); enum vkd3d_view_type { @@ -495,8 +495,8 @@ struct vkd3d_view } info; }; -void vkd3d_view_decref(struct vkd3d_view *view, struct d3d12_device *device) DECLSPEC_HIDDEN; -void vkd3d_view_incref(struct vkd3d_view *view) DECLSPEC_HIDDEN; +void vkd3d_view_decref(struct vkd3d_view *view, struct d3d12_device *device); +void vkd3d_view_incref(struct vkd3d_view *view); struct vkd3d_texture_view_desc { @@ -511,9 +511,9 @@ struct vkd3d_texture_view_desc }; bool vkd3d_create_buffer_view(struct d3d12_device *device, VkBuffer vk_buffer, const struct vkd3d_format *format, - VkDeviceSize offset, VkDeviceSize size, struct vkd3d_view **view) DECLSPEC_HIDDEN; + VkDeviceSize offset, VkDeviceSize size, struct vkd3d_view **view); bool vkd3d_create_texture_view(struct d3d12_device *device, VkImage vk_image, - const struct vkd3d_texture_view_desc *desc, struct vkd3d_view **view) DECLSPEC_HIDDEN; + const struct vkd3d_texture_view_desc *desc, struct vkd3d_view **view); struct d3d12_desc { @@ -537,24 +537,24 @@ static inline struct d3d12_desc *d3d12_desc_from_gpu_handle(D3D12_GPU_DESCRIPTOR } void d3d12_desc_copy(struct d3d12_desc *dst, const struct d3d12_desc *src, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); void d3d12_desc_create_cbv(struct d3d12_desc *descriptor, - struct d3d12_device *device, const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc) DECLSPEC_HIDDEN; + struct d3d12_device *device, const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc); void d3d12_desc_create_srv(struct d3d12_desc *descriptor, struct d3d12_device *device, struct d3d12_resource *resource, - const D3D12_SHADER_RESOURCE_VIEW_DESC *desc) DECLSPEC_HIDDEN; + const D3D12_SHADER_RESOURCE_VIEW_DESC *desc); void d3d12_desc_create_uav(struct d3d12_desc *descriptor, struct d3d12_device *device, struct d3d12_resource *resource, struct d3d12_resource *counter_resource, - const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc) DECLSPEC_HIDDEN; + const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc); void d3d12_desc_create_sampler(struct d3d12_desc *sampler, - struct d3d12_device *device, const D3D12_SAMPLER_DESC *desc) DECLSPEC_HIDDEN; + struct d3d12_device *device, const D3D12_SAMPLER_DESC *desc); void d3d12_desc_write_atomic(struct d3d12_desc *dst, const struct d3d12_desc *src, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); bool vkd3d_create_raw_buffer_view(struct d3d12_device *device, - D3D12_GPU_VIRTUAL_ADDRESS gpu_address, VkBufferView *vk_buffer_view) DECLSPEC_HIDDEN; + D3D12_GPU_VIRTUAL_ADDRESS gpu_address, VkBufferView *vk_buffer_view); HRESULT vkd3d_create_static_sampler(struct d3d12_device *device, - const D3D12_STATIC_SAMPLER_DESC *desc, VkSampler *vk_sampler) DECLSPEC_HIDDEN; + const D3D12_STATIC_SAMPLER_DESC *desc, VkSampler *vk_sampler); struct d3d12_rtv_desc { @@ -574,7 +574,7 @@ static inline struct d3d12_rtv_desc *d3d12_rtv_desc_from_cpu_handle(D3D12_CPU_DE } void d3d12_rtv_desc_create_rtv(struct d3d12_rtv_desc *rtv_desc, struct d3d12_device *device, - struct d3d12_resource *resource, const D3D12_RENDER_TARGET_VIEW_DESC *desc) DECLSPEC_HIDDEN; + struct d3d12_resource *resource, const D3D12_RENDER_TARGET_VIEW_DESC *desc); struct d3d12_dsv_desc { @@ -594,7 +594,7 @@ static inline struct d3d12_dsv_desc *d3d12_dsv_desc_from_cpu_handle(D3D12_CPU_DE } void d3d12_dsv_desc_create_dsv(struct d3d12_dsv_desc *dsv_desc, struct d3d12_device *device, - struct d3d12_resource *resource, const D3D12_DEPTH_STENCIL_VIEW_DESC *desc) DECLSPEC_HIDDEN; + struct d3d12_resource *resource, const D3D12_DEPTH_STENCIL_VIEW_DESC *desc); /* ID3D12DescriptorHeap */ struct d3d12_descriptor_heap @@ -612,7 +612,7 @@ struct d3d12_descriptor_heap }; HRESULT d3d12_descriptor_heap_create(struct d3d12_device *device, - const D3D12_DESCRIPTOR_HEAP_DESC *desc, struct d3d12_descriptor_heap **descriptor_heap) DECLSPEC_HIDDEN; + const D3D12_DESCRIPTOR_HEAP_DESC *desc, struct d3d12_descriptor_heap **descriptor_heap); /* ID3D12QueryHeap */ struct d3d12_query_heap @@ -630,8 +630,8 @@ struct d3d12_query_heap }; HRESULT d3d12_query_heap_create(struct d3d12_device *device, const D3D12_QUERY_HEAP_DESC *desc, - struct d3d12_query_heap **heap) DECLSPEC_HIDDEN; -struct d3d12_query_heap *unsafe_impl_from_ID3D12QueryHeap(ID3D12QueryHeap *iface) DECLSPEC_HIDDEN; + struct d3d12_query_heap **heap); +struct d3d12_query_heap *unsafe_impl_from_ID3D12QueryHeap(ID3D12QueryHeap *iface); /* A Vulkan query has to be issued at least one time before the result is * available. In D3D12 it is legal to get query reults for not issued queries. @@ -731,11 +731,11 @@ struct d3d12_root_signature }; HRESULT d3d12_root_signature_create(struct d3d12_device *device, const void *bytecode, - size_t bytecode_length, struct d3d12_root_signature **root_signature) DECLSPEC_HIDDEN; -struct d3d12_root_signature *unsafe_impl_from_ID3D12RootSignature(ID3D12RootSignature *iface) DECLSPEC_HIDDEN; + size_t bytecode_length, struct d3d12_root_signature **root_signature); +struct d3d12_root_signature *unsafe_impl_from_ID3D12RootSignature(ID3D12RootSignature *iface); int vkd3d_parse_root_signature_v_1_0(const struct vkd3d_shader_code *dxbc, - struct vkd3d_shader_versioned_root_signature_desc *desc) DECLSPEC_HIDDEN; + struct vkd3d_shader_versioned_root_signature_desc *desc); struct d3d12_graphics_pipeline_state { @@ -829,13 +829,13 @@ static inline bool d3d12_pipeline_state_has_unknown_dsv_format(struct d3d12_pipe } HRESULT d3d12_pipeline_state_create_compute(struct d3d12_device *device, - const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state) DECLSPEC_HIDDEN; + const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state); HRESULT d3d12_pipeline_state_create_graphics(struct d3d12_device *device, - const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state) DECLSPEC_HIDDEN; + const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state); VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_state *state, D3D12_PRIMITIVE_TOPOLOGY topology, const uint32_t *strides, VkFormat dsv_format, - VkRenderPass *vk_render_pass) DECLSPEC_HIDDEN; -struct d3d12_pipeline_state *unsafe_impl_from_ID3D12PipelineState(ID3D12PipelineState *iface) DECLSPEC_HIDDEN; + VkRenderPass *vk_render_pass); +struct d3d12_pipeline_state *unsafe_impl_from_ID3D12PipelineState(ID3D12PipelineState *iface); struct vkd3d_buffer { @@ -895,7 +895,7 @@ struct d3d12_command_allocator }; HRESULT d3d12_command_allocator_create(struct d3d12_device *device, - D3D12_COMMAND_LIST_TYPE type, struct d3d12_command_allocator **allocator) DECLSPEC_HIDDEN; + D3D12_COMMAND_LIST_TYPE type, struct d3d12_command_allocator **allocator); struct vkd3d_push_descriptor { @@ -987,7 +987,7 @@ struct d3d12_command_list HRESULT d3d12_command_list_create(struct d3d12_device *device, UINT node_mask, D3D12_COMMAND_LIST_TYPE type, ID3D12CommandAllocator *allocator_iface, - ID3D12PipelineState *initial_pipeline_state, struct d3d12_command_list **list) DECLSPEC_HIDDEN; + ID3D12PipelineState *initial_pipeline_state, struct d3d12_command_list **list); struct vkd3d_queue { @@ -1014,12 +1014,12 @@ struct vkd3d_queue VkSemaphore old_vk_semaphores[VKD3D_MAX_VK_SYNC_OBJECTS]; }; -VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue) DECLSPEC_HIDDEN; +VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue); HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index, const VkQueueFamilyProperties *properties, - struct vkd3d_queue **queue) DECLSPEC_HIDDEN; -void vkd3d_queue_destroy(struct vkd3d_queue *queue, struct d3d12_device *device) DECLSPEC_HIDDEN; -void vkd3d_queue_release(struct vkd3d_queue *queue) DECLSPEC_HIDDEN; + struct vkd3d_queue **queue); +void vkd3d_queue_destroy(struct vkd3d_queue *queue, struct d3d12_device *device); +void vkd3d_queue_release(struct vkd3d_queue *queue); /* ID3D12CommandQueue */ struct d3d12_command_queue @@ -1040,7 +1040,7 @@ struct d3d12_command_queue }; HRESULT d3d12_command_queue_create(struct d3d12_device *device, - const D3D12_COMMAND_QUEUE_DESC *desc, struct d3d12_command_queue **queue) DECLSPEC_HIDDEN; + const D3D12_COMMAND_QUEUE_DESC *desc, struct d3d12_command_queue **queue); /* ID3D12CommandSignature */ struct d3d12_command_signature @@ -1056,8 +1056,8 @@ struct d3d12_command_signature }; HRESULT d3d12_command_signature_create(struct d3d12_device *device, const D3D12_COMMAND_SIGNATURE_DESC *desc, - struct d3d12_command_signature **signature) DECLSPEC_HIDDEN; -struct d3d12_command_signature *unsafe_impl_from_ID3D12CommandSignature(ID3D12CommandSignature *iface) DECLSPEC_HIDDEN; + struct d3d12_command_signature **signature); +struct d3d12_command_signature *unsafe_impl_from_ID3D12CommandSignature(ID3D12CommandSignature *iface); /* NULL resources */ struct vkd3d_null_resources @@ -1076,9 +1076,9 @@ struct vkd3d_null_resources }; HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); void vkd3d_destroy_null_resources(struct vkd3d_null_resources *null_resources, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); struct vkd3d_format_compatibility_list { @@ -1116,8 +1116,8 @@ struct vkd3d_uav_clear_state struct vkd3d_uav_clear_pipelines pipelines_uint; }; -HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d3d12_device *device) DECLSPEC_HIDDEN; -void vkd3d_uav_clear_state_cleanup(struct vkd3d_uav_clear_state *state, struct d3d12_device *device) DECLSPEC_HIDDEN; +HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d3d12_device *device); +void vkd3d_uav_clear_state_cleanup(struct vkd3d_uav_clear_state *state, struct d3d12_device *device); /* ID3D12Device */ struct d3d12_device @@ -1173,13 +1173,13 @@ struct d3d12_device }; HRESULT d3d12_device_create(struct vkd3d_instance *instance, - const struct vkd3d_device_create_info *create_info, struct d3d12_device **device) DECLSPEC_HIDDEN; + const struct vkd3d_device_create_info *create_info, struct d3d12_device **device); struct vkd3d_queue *d3d12_device_get_vkd3d_queue(struct d3d12_device *device, - D3D12_COMMAND_LIST_TYPE type) DECLSPEC_HIDDEN; -bool d3d12_device_is_uma(struct d3d12_device *device, bool *coherent) DECLSPEC_HIDDEN; + D3D12_COMMAND_LIST_TYPE type); +bool d3d12_device_is_uma(struct d3d12_device *device, bool *coherent); void d3d12_device_mark_as_removed(struct d3d12_device *device, HRESULT reason, - const char *message, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN; -struct d3d12_device *unsafe_impl_from_ID3D12Device(ID3D12Device *iface) DECLSPEC_HIDDEN; + const char *message, ...) VKD3D_PRINTF_FUNC(3, 4); +struct d3d12_device *unsafe_impl_from_ID3D12Device(ID3D12Device *iface); static inline HRESULT d3d12_device_query_interface(struct d3d12_device *device, REFIID iid, void **object) { @@ -1254,15 +1254,15 @@ static inline bool vkd3d_format_is_compressed(const struct vkd3d_format *format) void vkd3d_format_copy_data(const struct vkd3d_format *format, const uint8_t *src, unsigned int src_row_pitch, unsigned int src_slice_pitch, uint8_t *dst, unsigned int dst_row_pitch, - unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d) DECLSPEC_HIDDEN; + unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d); const struct vkd3d_format *vkd3d_get_format(const struct d3d12_device *device, - DXGI_FORMAT dxgi_format, bool depth_stencil) DECLSPEC_HIDDEN; + DXGI_FORMAT dxgi_format, bool depth_stencil); const struct vkd3d_format *vkd3d_find_uint_format(const struct d3d12_device *device, - DXGI_FORMAT dxgi_format) DECLSPEC_HIDDEN; + DXGI_FORMAT dxgi_format); -HRESULT vkd3d_init_format_info(struct d3d12_device *device) DECLSPEC_HIDDEN; -void vkd3d_cleanup_format_info(struct d3d12_device *device) DECLSPEC_HIDDEN; +HRESULT vkd3d_init_format_info(struct d3d12_device *device); +void vkd3d_cleanup_format_info(struct d3d12_device *device); static inline const struct vkd3d_format *vkd3d_format_from_d3d12_resource_desc( const struct d3d12_device *device, const D3D12_RESOURCE_DESC *desc, DXGI_FORMAT view_format) @@ -1310,24 +1310,24 @@ static inline unsigned int vkd3d_compute_workgroup_count(unsigned int thread_cou return (thread_count + workgroup_size - 1) / workgroup_size; } -VkCompareOp vk_compare_op_from_d3d12(D3D12_COMPARISON_FUNC op) DECLSPEC_HIDDEN; -VkSampleCountFlagBits vk_samples_from_dxgi_sample_desc(const DXGI_SAMPLE_DESC *desc) DECLSPEC_HIDDEN; -VkSampleCountFlagBits vk_samples_from_sample_count(unsigned int sample_count) DECLSPEC_HIDDEN; +VkCompareOp vk_compare_op_from_d3d12(D3D12_COMPARISON_FUNC op); +VkSampleCountFlagBits vk_samples_from_dxgi_sample_desc(const DXGI_SAMPLE_DESC *desc); +VkSampleCountFlagBits vk_samples_from_sample_count(unsigned int sample_count); -bool is_valid_feature_level(D3D_FEATURE_LEVEL feature_level) DECLSPEC_HIDDEN; +bool is_valid_feature_level(D3D_FEATURE_LEVEL feature_level); -bool is_valid_resource_state(D3D12_RESOURCE_STATES state) DECLSPEC_HIDDEN; -bool is_write_resource_state(D3D12_RESOURCE_STATES state) DECLSPEC_HIDDEN; +bool is_valid_resource_state(D3D12_RESOURCE_STATES state); +bool is_write_resource_state(D3D12_RESOURCE_STATES state); HRESULT return_interface(void *iface, REFIID iface_iid, - REFIID requested_iid, void **object) DECLSPEC_HIDDEN; + REFIID requested_iid, void **object); -const char *debug_d3d12_box(const D3D12_BOX *box) DECLSPEC_HIDDEN; -const char *debug_d3d12_shader_component_mapping(unsigned int mapping) DECLSPEC_HIDDEN; -const char *debug_vk_extent_3d(VkExtent3D extent) DECLSPEC_HIDDEN; -const char *debug_vk_memory_heap_flags(VkMemoryHeapFlags flags) DECLSPEC_HIDDEN; -const char *debug_vk_memory_property_flags(VkMemoryPropertyFlags flags) DECLSPEC_HIDDEN; -const char *debug_vk_queue_flags(VkQueueFlags flags) DECLSPEC_HIDDEN; +const char *debug_d3d12_box(const D3D12_BOX *box); +const char *debug_d3d12_shader_component_mapping(unsigned int mapping); +const char *debug_vk_extent_3d(VkExtent3D extent); +const char *debug_vk_memory_heap_flags(VkMemoryHeapFlags flags); +const char *debug_vk_memory_property_flags(VkMemoryPropertyFlags flags); +const char *debug_vk_queue_flags(VkQueueFlags flags); static inline void debug_ignored_node_mask(unsigned int mask) { @@ -1336,15 +1336,15 @@ static inline void debug_ignored_node_mask(unsigned int mask) } HRESULT vkd3d_load_vk_global_procs(struct vkd3d_vk_global_procs *procs, - PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) DECLSPEC_HIDDEN; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr); HRESULT vkd3d_load_vk_instance_procs(struct vkd3d_vk_instance_procs *procs, - const struct vkd3d_vk_global_procs *global_procs, VkInstance instance) DECLSPEC_HIDDEN; + const struct vkd3d_vk_global_procs *global_procs, VkInstance instance); HRESULT vkd3d_load_vk_device_procs(struct vkd3d_vk_device_procs *procs, - const struct vkd3d_vk_instance_procs *parent_procs, VkDevice device) DECLSPEC_HIDDEN; + const struct vkd3d_vk_instance_procs *parent_procs, VkDevice device); extern const char vkd3d_build[]; -bool vkd3d_get_program_name(char program_name[PATH_MAX]) DECLSPEC_HIDDEN; +bool vkd3d_get_program_name(char program_name[PATH_MAX]); static inline void vkd3d_set_thread_name(const char *name) { @@ -1356,9 +1356,9 @@ static inline void vkd3d_set_thread_name(const char *name) } VkResult vkd3d_set_vk_object_name_utf8(struct d3d12_device *device, uint64_t vk_object, - VkDebugReportObjectTypeEXT vk_object_type, const char *name) DECLSPEC_HIDDEN; + VkDebugReportObjectTypeEXT vk_object_type, const char *name); HRESULT vkd3d_set_vk_object_name(struct d3d12_device *device, uint64_t vk_object, - VkDebugReportObjectTypeEXT vk_object_type, const WCHAR *name) DECLSPEC_HIDDEN; + VkDebugReportObjectTypeEXT vk_object_type, const WCHAR *name); static inline void vk_prepend_struct(void *header, void *structure) { -- 2.28.0

5 6

[PATCH 1/7] include: Update _XSTATE_CONFIGURATION structure definition.
by Paul Gofman 27 May '21

27 May '21

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- include/ddk/wdm.h | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/include/ddk/wdm.h b/include/ddk/wdm.h index 9fcb1387012..b8bb7bd971f 100644 --- a/include/ddk/wdm.h +++ b/include/ddk/wdm.h @@ -1207,16 +1207,24 @@ typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE typedef struct _XSTATE_FEATURE { - ULONG Offset; - ULONG Size; + ULONG Offset; + ULONG Size; } XSTATE_FEATURE, *PXSTATE_FEATURE; typedef struct _XSTATE_CONFIGURATION { - ULONG64 EnabledFeatures; - ULONG Size; - ULONG OptimizedSave:1; - XSTATE_FEATURE Features[MAXIMUM_XSTATE_FEATURES]; + ULONG64 EnabledFeatures; + ULONG64 EnabledVolatileFeatures; + ULONG Size; + ULONG OptimizedSave:1; + ULONG CompactionEnabled:1; + XSTATE_FEATURE Features[MAXIMUM_XSTATE_FEATURES]; + + ULONG64 EnabledSupervisorFeatures; + ULONG64 AlignedFeatures; + ULONG AllFeatureSize; + ULONG AllFeatures[MAXIMUM_XSTATE_FEATURES]; + ULONG64 EnabledUserVisibleSupervisorFeatures; } XSTATE_CONFIGURATION, *PXSTATE_CONFIGURATION; typedef struct _KUSER_SHARED_DATA { -- 2.26.2

3 16

WineTest failure patterns preview
by Francois Gouget 27 May '21

27 May '21

I did not get to send this patch set yet so here's a preview: * Windows test patterns http://fgouget.free.fr/tmp/winepatterns/patterns-tb-win.html * Wine test patterns http://fgouget.free.fr/tmp/winepatterns/patterns-tb-wine.html So for each test unit that had failures you have: * one line per test configuration (report tag) * one row per WineTest build (daily commit) Each cell has a one character description of the test result (with more details in the tooltip) and is color coded to help identify patterns. Each 'failure' cell also links to the corresponding report page. The main goal of these pages for me is to simplify detecting new failures in the WineTest results... and not just in cases where there was no failure before since there are so many cases with preexisting failures already. In the patterns an increase in the number of failures shows up as a color change which makes them easy to spot. A secondary goal is to allow comparing the before/after results when a test configuration (VM or otherwise) is modified. A side effect is that these can also help identify the different failure modes. For instance comctl32:monthcal fails on wednesdays, except in Korean where it's all the time: http://fgouget.free.fr/tmp/winepatterns/patterns-tb-win.html#comctl32:month… To help with these tasks the page also sorts the test units to show those that look like they have new failures first. So starting the review from the top is most likely to point to the new issues. -- Francois Gouget <fgouget(a)codeweavers.com>

2 6

[PATCH 1/2] comctl32: Set the selection if it's currently invalid in HandleTimer.
by Gabriel Ivăncescu 26 May '21

26 May '21

Don't skip MoveCaret if it would actually change the selection when it is invalid. This can happen, for example, in a combo box if the dropdown is shown by a mouse click + release followed by the mouse being moved into the dropped listbox, when the listbox has nothing selected. In this case, the item with the index zero would not be selected the first time the mouse moves over it, since the focus_item would be zero. Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- This can be easily tested with winecfg. Launch winecfg, go to `Libraries` tab, click on the combobox arrow dropdown for `New override for library` to open the listbox, then hover the mouse over the first entry (acledit). Notice that it does not get highlighted, which is the issue. If you move the mouse to the second entry (aclui) and then back to (acledit), it works. With this patch, the first hover over the first entry will also work as it should. dlls/comctl32/listbox.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/comctl32/listbox.c b/dlls/comctl32/listbox.c index 239f54a..1f5d3c9 100644 --- a/dlls/comctl32/listbox.c +++ b/dlls/comctl32/listbox.c @@ -2337,7 +2337,7 @@ static LRESULT LISTBOX_HandleTimer( LB_DESCR *descr, INT index, TIMER_DIRECTION case LB_TIMER_NONE: break; } - if (index == descr->focus_item) return FALSE; + if (index == descr->focus_item && descr->selected_item != -1) return FALSE; LISTBOX_MoveCaret( descr, index, FALSE ); return TRUE; } -- 2.30.0

2 3

[PATCH 1/4] dinput8/tests: Make input helper function more versatile.
by Arkadiusz Hiler 26 May '21

26 May '21

test_device_input() now takes properly sized appdata expected value and can be used to send any keyboard event. It also drains device's queue so it can be called multiple times on a single device instance. Signed-off-by: Arkadiusz Hiler <ahiler(a)codeweavers.com> --- dlls/dinput8/tests/device.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/dlls/dinput8/tests/device.c b/dlls/dinput8/tests/device.c index 2fc04358cc1..02574961ec1 100644 --- a/dlls/dinput8/tests/device.c +++ b/dlls/dinput8/tests/device.c @@ -80,7 +80,7 @@ static void flush_events(void) } } -static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWORD event, DWORD expected) +static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWORD event, UINT_PTR expected) { HRESULT hr; DIDEVICEOBJECTDATA obj_data; @@ -91,7 +91,7 @@ static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWO ok (SUCCEEDED(hr), "Failed to acquire device hr=%08x\n", hr); if (event_type == INPUT_KEYBOARD) - keybd_event( event, DIK_SPACE, 0, 0); + keybd_event(event, MapVirtualKeyA(event, MAPVK_VK_TO_VSC), 0, 0); if (event_type == INPUT_MOUSE) mouse_event( event, 0, 0, 0, 0); @@ -107,7 +107,7 @@ static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWO return; } - ok (obj_data.uAppData == expected, "Retrieval of action failed uAppData=%lu expected=%d\n", obj_data.uAppData, expected); + ok (obj_data.uAppData == expected, "Retrieval of action failed uAppData=%lu expected=%lu\n", obj_data.uAppData, expected); /* Check for buffer overflow */ for (i = 0; i < 17; i++) @@ -132,6 +132,14 @@ static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWO hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0); ok(hr == DI_OK && data_size == 1, "GetDeviceData() failed: %08x cnt:%d\n", hr, data_size); + /* drain device's queue */ + while (data_size == 1) + { + hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0); + ok(hr == DI_OK, "GetDeviceData() failed: %08x cnt:%d\n", hr, data_size); + if (hr != DI_OK) break; + } + IDirectInputDevice_Unacquire(lpdid); } -- 2.30.1

3 7

[PATCH] winex11: Allow user to set WM_CLASS
by Nicholas Little 26 May '21

26 May '21

This commit allows the user to optionally set the WM_CLASS by setting an environment variable WINEWMCLASS with the aim of allowing him to ensure desktop environments can correctly identify wine windows, unfortunately the executable filename isn't always sufficient as some programs share a common executable name. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=50095 --- dlls/winex11.drv/window.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dlls/winex11.drv/window.c b/dlls/winex11.drv/window.c index 457173964eb..6b87166c830 100644 --- a/dlls/winex11.drv/window.c +++ b/dlls/winex11.drv/window.c @@ -837,6 +837,7 @@ static void set_initial_wm_hints( Display *display, Window window ) Atom protocols[3]; Atom dndVersion = WINE_XDND_VERSION; XClassHint *class_hints; + char *wine_wm_class; /* wm protocols */ i = 0; @@ -849,8 +850,9 @@ static void set_initial_wm_hints( Display *display, Window window ) /* class hints */ if ((class_hints = XAllocClassHint())) { + wine_wm_class = getenv( "WINEWMCLASS" ); class_hints->res_name = process_name; - class_hints->res_class = process_name; + class_hints->res_class = wine_wm_class ? wine_wm_class : process_name; XSetClassHint( display, window, class_hints ); XFree( class_hints ); } -- 2.26.2

2 2

[PATCH resend3 1/2] ntdll: Fill in SYSTEM_CPU_INFORMATION.MaximumCpus
by Alex Henrie 24 May '21

24 May '21

Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- https://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/ex/sysinfo/pr… --- dlls/ntdll/unix/system.c | 29 +++++++++++++++++++++++++++++ include/winternl.h | 2 +- 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/dlls/ntdll/unix/system.c b/dlls/ntdll/unix/system.c index 491cdb37b8f..784fb6212a5 100644 --- a/dlls/ntdll/unix/system.c +++ b/dlls/ntdll/unix/system.c @@ -173,6 +173,31 @@ struct smbios_boot_info SYSTEM_CPU_INFORMATION cpu_info = { 0 }; +static int get_possible_cpus(void) +{ + int ret = NtCurrentTeb()->Peb->NumberOfProcessors; +#ifdef linux + FILE *f = fopen("/sys/devices/system/cpu/possible", "r"); + char line[32]; + char *value; + if (f) + { + if (fgets(line, sizeof(line), f)) + { + value = strchr(line, '-'); + if (value) + { + *value = 0; + value++; + ret = atoi(value) - atoi(line) + 1; + } + } + fclose(f); + } +#endif + return ret; +} + /******************************************************************************* * Architecture specific feature detection for CPUs * @@ -246,6 +271,8 @@ static void get_cpuinfo( SYSTEM_CPU_INFORMATION *info ) info->Architecture = PROCESSOR_ARCHITECTURE_AMD64; #endif + info->MaximumCpus = get_possible_cpus(); + /* We're at least a 386 */ info->FeatureSet = CPU_FEATURE_VME | CPU_FEATURE_X86 | CPU_FEATURE_PGE; info->Level = 3; @@ -400,6 +427,7 @@ static inline void get_cpuinfo( SYSTEM_CPU_INFORMATION *info ) FIXME("CPU Feature detection not implemented.\n"); #endif info->Architecture = PROCESSOR_ARCHITECTURE_ARM; + info->MaximumCpus = get_possible_cpus(); } #elif defined(__aarch64__) @@ -448,6 +476,7 @@ static void get_cpuinfo( SYSTEM_CPU_INFORMATION *info ) #endif info->Level = max(info->Level, 8); info->Architecture = PROCESSOR_ARCHITECTURE_ARM64; + info->MaximumCpus = get_possible_cpus(); } #endif /* End architecture specific feature detection for CPUs */ diff --git a/include/winternl.h b/include/winternl.h index dd2bdbbebbe..1104865a053 100644 --- a/include/winternl.h +++ b/include/winternl.h @@ -2132,7 +2132,7 @@ typedef struct _SYSTEM_CPU_INFORMATION { WORD Architecture; WORD Level; WORD Revision; /* combination of CPU model and stepping */ - WORD Reserved; /* always zero */ + WORD MaximumCpus; /* number of CPUs if as many as possible are hot-added */ DWORD FeatureSet; /* see bit flags below */ } SYSTEM_CPU_INFORMATION, *PSYSTEM_CPU_INFORMATION; -- 2.31.1

2 3

[PATCH v10] ntdll: Allow renaming a file/directory to a different case of itself.
by Gabriel Ivăncescu 20 May '21

20 May '21

Renaming a file or directory from e.g. foobar to FooBar (or any other case change) should work, like on Windows, instead of being a no-op. Clobbering an existing file must also respect the new case. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=46203 Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- Fix handling of '/' root component, as it has no named component, and it must be treated as a filename (not path). dlls/kernel32/tests/file.c | 4 +- dlls/ntdll/tests/file.c | 4 +- dlls/ntdll/unix/file.c | 70 +++++++++++++++++++++++-- server/fd.c | 104 +++++++++++++++++++++++++------------ server/protocol.def | 2 + 5 files changed, 144 insertions(+), 40 deletions(-) diff --git a/dlls/kernel32/tests/file.c b/dlls/kernel32/tests/file.c index 8560524..9ca56e1 100644 --- a/dlls/kernel32/tests/file.c +++ b/dlls/kernel32/tests/file.c @@ -2040,7 +2040,7 @@ static void test_MoveFileA(void) ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); if (hfile != INVALID_HANDLE_VALUE) { - todo_wine ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), + ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), "MoveFile failed to change casing on same file: got %s\n", find_data.cFileName); } CloseHandle(hfile); @@ -2085,7 +2085,7 @@ static void test_MoveFileA(void) ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); if (hfile != INVALID_HANDLE_VALUE) { - todo_wine ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), + ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), "MoveFile failed to change casing on same directory: got %s\n", find_data.cFileName); } CloseHandle(hfile); diff --git a/dlls/ntdll/tests/file.c b/dlls/ntdll/tests/file.c index d469b44..49f4e34 100644 --- a/dlls/ntdll/tests/file.c +++ b/dlls/ntdll/tests/file.c @@ -2315,7 +2315,7 @@ static void test_file_link_information(void) ok(handle != INVALID_HANDLE_VALUE, "FindFirstFileW: failed, error %d\n", GetLastError()); if (handle != INVALID_HANDLE_VALUE) { - todo_wine ok(!lstrcmpW(wcsrchr(newpath, '\\') + 1, find_data.cFileName), + ok(!lstrcmpW(wcsrchr(newpath, '\\') + 1, find_data.cFileName), "Link did not change casing on existing target file: got %s\n", wine_dbgstr_w(find_data.cFileName)); } @@ -2900,7 +2900,7 @@ static void test_file_link_information(void) ok(handle != INVALID_HANDLE_VALUE, "FindFirstFileW: failed, error %d\n", GetLastError()); if (handle != INVALID_HANDLE_VALUE) { - todo_wine ok(!lstrcmpW(wcsrchr(oldpath, '\\') + 1, find_data.cFileName), + ok(!lstrcmpW(wcsrchr(oldpath, '\\') + 1, find_data.cFileName), "Link did not change casing on same file: got %s\n", wine_dbgstr_w(find_data.cFileName)); } diff --git a/dlls/ntdll/unix/file.c b/dlls/ntdll/unix/file.c index 2f18325..1571f63 100644 --- a/dlls/ntdll/unix/file.c +++ b/dlls/ntdll/unix/file.c @@ -3400,6 +3400,62 @@ NTSTATUS nt_to_unix_file_name( const OBJECT_ATTRIBUTES *attr, char **name_ret, U } +/*********************************************************************** + * nt_to_unix_file_name_with_actual_case + * + * Same as nt_to_unix_file_name, but additionally return unix file name + * without path, with the actual case from the NT file name. + */ +static NTSTATUS nt_to_unix_file_name_with_actual_case( const OBJECT_ATTRIBUTES *attr, char **name_ret, + char **actual_case_ret, UINT disposition ) +{ + const WCHAR *nt_filename = attr->ObjectName->Buffer; + char *actual_case, *p; + NTSTATUS status; + int len; + + /* strip off trailing backslashes; we also accept '/' for unix namespaces */ + for (len = attr->ObjectName->Length / sizeof(WCHAR); len != 0; len--) + if (nt_filename[len - 1] != '\\' && nt_filename[len - 1] != '/') + break; + + /* get the last component */ + for (nt_filename += len; nt_filename != attr->ObjectName->Buffer; nt_filename--) + if (nt_filename[-1] == '\\' || nt_filename[-1] == '/') + break; + len = attr->ObjectName->Buffer + len - nt_filename; + + if (!(actual_case = malloc( len * 3 + 1 ))) return STATUS_NO_MEMORY; + + status = nt_to_unix_file_name( attr, name_ret, disposition ); + if (status != STATUS_SUCCESS && status != STATUS_NO_SUCH_FILE) + { + free( actual_case ); + return status; + } + + /* special case for '/' root itself, as it has no named components */ + for (p = *name_ret; *p == '/'; p++) { } + if (!*p) + strcpy( actual_case, "/" ); + else + { + len = ntdll_wcstoumbs( nt_filename, len, actual_case, len * 3, TRUE ); + if (len > 0) + actual_case[len] = 0; + else + { + char *p = strrchr( *name_ret, '/' ); + p = p ? p + 1 : *name_ret; + strcpy( actual_case, p ); + } + } + + *actual_case_ret = actual_case; + return status; +} + + /****************************************************************************** * wine_nt_to_unix_file_name * @@ -4522,8 +4578,8 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, { FILE_RENAME_INFORMATION *info = ptr; UNICODE_STRING name_str, redir; + char *unix_name, *file_case; OBJECT_ATTRIBUTES attr; - char *unix_name; name_str.Buffer = info->FileName; name_str.Length = info->FileNameLength; @@ -4531,7 +4587,7 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, InitializeObjectAttributes( &attr, &name_str, OBJ_CASE_INSENSITIVE, info->RootDirectory, NULL ); get_redirect( &attr, &redir ); - io->u.Status = nt_to_unix_file_name( &attr, &unix_name, FILE_OPEN_IF ); + io->u.Status = nt_to_unix_file_name_with_actual_case( &attr, &unix_name, &file_case, FILE_OPEN_IF ); if (io->u.Status == STATUS_SUCCESS || io->u.Status == STATUS_NO_SUCH_FILE) { SERVER_START_REQ( set_fd_name_info ) @@ -4539,15 +4595,18 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, req->handle = wine_server_obj_handle( handle ); req->rootdir = wine_server_obj_handle( attr.RootDirectory ); req->namelen = attr.ObjectName->Length; + req->caselen = strlen( file_case ); req->link = FALSE; req->replace = info->ReplaceIfExists; wine_server_add_data( req, attr.ObjectName->Buffer, attr.ObjectName->Length ); + wine_server_add_data( req, file_case, req->caselen ); wine_server_add_data( req, unix_name, strlen(unix_name) ); io->u.Status = wine_server_call( req ); } SERVER_END_REQ; free( unix_name ); + free( file_case ); } free( redir.Buffer ); } @@ -4559,8 +4618,8 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, { FILE_LINK_INFORMATION *info = ptr; UNICODE_STRING name_str, redir; + char *unix_name, *file_case; OBJECT_ATTRIBUTES attr; - char *unix_name; name_str.Buffer = info->FileName; name_str.Length = info->FileNameLength; @@ -4568,7 +4627,7 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, InitializeObjectAttributes( &attr, &name_str, OBJ_CASE_INSENSITIVE, info->RootDirectory, NULL ); get_redirect( &attr, &redir ); - io->u.Status = nt_to_unix_file_name( &attr, &unix_name, FILE_OPEN_IF ); + io->u.Status = nt_to_unix_file_name_with_actual_case( &attr, &unix_name, &file_case, FILE_OPEN_IF ); if (io->u.Status == STATUS_SUCCESS || io->u.Status == STATUS_NO_SUCH_FILE) { SERVER_START_REQ( set_fd_name_info ) @@ -4576,15 +4635,18 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, req->handle = wine_server_obj_handle( handle ); req->rootdir = wine_server_obj_handle( attr.RootDirectory ); req->namelen = attr.ObjectName->Length; + req->caselen = strlen( file_case ); req->link = TRUE; req->replace = info->ReplaceIfExists; wine_server_add_data( req, attr.ObjectName->Buffer, attr.ObjectName->Length ); + wine_server_add_data( req, file_case, req->caselen ); wine_server_add_data( req, unix_name, strlen(unix_name) ); io->u.Status = wine_server_call( req ); } SERVER_END_REQ; free( unix_name ); + free( file_case ); } free( redir.Buffer ); } diff --git a/server/fd.c b/server/fd.c index 481e9a8..d73ea56 100644 --- a/server/fd.c +++ b/server/fd.c @@ -2488,11 +2488,14 @@ static void set_fd_disposition( struct fd *fd, int unlink ) /* set new name for the fd */ static void set_fd_name( struct fd *fd, struct fd *root, const char *nameptr, data_size_t len, - struct unicode_str nt_name, int create_link, int replace ) + const char *file_case, data_size_t caselen, struct unicode_str nt_name, + int create_link, int replace ) { + size_t pathlen, filenamelen; struct inode *inode; struct stat st, st2; - char *name; + int different_case; + char *name, *p; if (!fd->inode || !fd->unix_name) { @@ -2526,6 +2529,29 @@ static void set_fd_name( struct fd *fd, struct fd *root, const char *nameptr, da name = combined_name; } + if (!(p = strrchr( name, '/' ))) p = name; + else if (!*(++p)) + { + /* get the last slash that's not trailing, but treat '/' root as a filename */ + while (p > name && p[-1] == '/') p--; + p[p <= name] = 0; + while (p > name && p[-1] != '/') p--; + } + pathlen = p - name; + filenamelen = strlen( p ); + different_case = (filenamelen != caselen || memcmp( p, file_case, caselen )); + + if (filenamelen < caselen) + { + p = realloc( name, pathlen + caselen + 1 ); + if (!p) + { + set_error( STATUS_NO_MEMORY ); + goto failed; + } + name = p; + } + /* when creating a hard link, source cannot be a dir */ if (create_link && !fstat( fd->unix_fd, &st ) && S_ISDIR( st.st_mode )) { @@ -2538,47 +2564,58 @@ static void set_fd_name( struct fd *fd, struct fd *root, const char *nameptr, da if (!fstat( fd->unix_fd, &st2 ) && st.st_ino == st2.st_ino && st.st_dev == st2.st_dev) { if (create_link && !replace) set_error( STATUS_OBJECT_NAME_COLLISION ); - free( name ); - return; - } + if (!different_case) + { + free( name ); + return; + } - if (!replace) - { - set_error( STATUS_OBJECT_NAME_COLLISION ); - goto failed; + /* creating a link with a different case on itself renames the file */ + create_link = 0; } - - /* can't replace directories or special files */ - if (!S_ISREG( st.st_mode )) + else { - set_error( STATUS_ACCESS_DENIED ); - goto failed; - } + if (!replace) + { + set_error( STATUS_OBJECT_NAME_COLLISION ); + goto failed; + } - /* can't replace an opened file */ - if ((inode = get_inode( st.st_dev, st.st_ino, -1 ))) - { - int is_empty = list_empty( &inode->open ); - release_object( inode ); - if (!is_empty) + /* can't replace directories or special files */ + if (!S_ISREG( st.st_mode )) { set_error( STATUS_ACCESS_DENIED ); goto failed; } - } - /* link() expects that the target doesn't exist */ - /* rename() cannot replace files with directories */ - if (create_link || S_ISDIR( st2.st_mode )) - { - if (unlink( name )) + /* can't replace an opened file */ + if ((inode = get_inode( st.st_dev, st.st_ino, -1 ))) { - file_set_error(); - goto failed; + int is_empty = list_empty( &inode->open ); + release_object( inode ); + if (!is_empty) + { + set_error( STATUS_ACCESS_DENIED ); + goto failed; + } + } + + /* link() expects that the target doesn't exist */ + /* rename() cannot replace files with directories */ + if (create_link || S_ISDIR( st2.st_mode ) || different_case) + { + if (unlink( name )) + { + file_set_error(); + goto failed; + } } } } + memcpy( name + pathlen, file_case, caselen ); + name[pathlen + caselen] = 0; + if (create_link) { if (link( fd->unix_name, name )) @@ -2879,16 +2916,19 @@ DECL_HANDLER(set_fd_disp_info) /* set fd name information */ DECL_HANDLER(set_fd_name_info) { + const char *fullname, *file_case; struct fd *fd, *root_fd = NULL; struct unicode_str nt_name; - if (req->namelen > get_req_data_size()) + if (req->namelen > get_req_data_size() || get_req_data_size() - req->namelen < req->caselen) { set_error( STATUS_INVALID_PARAMETER ); return; } nt_name.str = get_req_data(); nt_name.len = (req->namelen / sizeof(WCHAR)) * sizeof(WCHAR); + file_case = (const char *)get_req_data() + req->namelen; + fullname = file_case + req->caselen; if (req->rootdir) { @@ -2902,8 +2942,8 @@ DECL_HANDLER(set_fd_name_info) if ((fd = get_handle_fd_obj( current->process, req->handle, 0 ))) { - set_fd_name( fd, root_fd, (const char *)get_req_data() + req->namelen, - get_req_data_size() - req->namelen, nt_name, req->link, req->replace ); + set_fd_name( fd, root_fd, fullname, (const char *)get_req_data() + get_req_data_size() - fullname, + file_case, req->caselen, nt_name, req->link, req->replace ); release_object( fd ); } if (root_fd) release_object( root_fd ); diff --git a/server/protocol.def b/server/protocol.def index 9361933..34c2c50 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -3519,9 +3519,11 @@ struct handle_info obj_handle_t handle; /* handle to a file or directory */ obj_handle_t rootdir; /* root directory */ data_size_t namelen; /* length of NT name in bytes */ + data_size_t caselen; /* length of the actual case filename */ int link; /* link instead of renaming */ int replace; /* replace an existing file? */ VARARG(name,unicode_str,namelen); /* NT name */ + VARARG(actual_case,string,caselen); /* new file name's actual case (without path) */ VARARG(filename,string); /* new file name */ @END -- 2.30.0

3 6

[PATCH 1/3] include: Factor out winetest_printf().
by Zebediah Figura 17 May '21

17 May '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- include/wine/test.h | 58 ++++++++++++++++++++++----------------------- 1 file changed, 28 insertions(+), 30 deletions(-) diff --git a/include/wine/test.h b/include/wine/test.h index 078b0147c4f..6864619f8c9 100644 --- a/include/wine/test.h +++ b/include/wine/test.h @@ -295,19 +295,31 @@ const char *winetest_elapsed(void) return wine_dbg_sprintf( "%.3f", (now - winetest_start_time) / 1000.0); } -void winetest_subtest( const char* name ) +static void winetest_vprintf( const char *msg, __winetest_va_list args ) { struct tls_data *data = get_tls_data(); - printf( "%s:%d:%s Subtest %s\n", - data->current_file, data->current_line, winetest_elapsed(), name ); + + printf( "%s:%d:%s ", data->current_file, data->current_line, winetest_elapsed() ); + vprintf( msg, args ); +} + +static void winetest_printf( const char *msg, ... ) +{ + __winetest_va_list valist; + + __winetest_va_start( valist, msg ); + winetest_vprintf( msg, valist ); + __winetest_va_end( valist ); +} + +void winetest_subtest( const char* name ) +{ + winetest_printf( "Subtest %s\n", name ); } void winetest_ignore_exceptions( BOOL ignore ) { - struct tls_data *data = get_tls_data(); - printf( "%s:%d:%s IgnoreExceptions=%d\n", - data->current_file, data->current_line, winetest_elapsed(), - ignore ? 1 : 0 ); + winetest_printf( "IgnoreExceptions=%d\n", ignore ? 1 : 0 ); } int broken( int condition ) @@ -327,9 +339,7 @@ static LONG winetest_add_line( void ) index = data->current_line % ARRAY_SIZE(line_counters); count = InterlockedIncrement(line_counters + index) - 1; if (count == winetest_mute_threshold) - printf( "%s:%d:%s Line has been silenced after %d occurrences\n", - data->current_file, data->current_line, winetest_elapsed(), - winetest_mute_threshold ); + winetest_printf( "Line has been silenced after %d occurrences\n", winetest_mute_threshold ); return count; } @@ -352,8 +362,7 @@ int winetest_vok( int condition, const char *msg, __winetest_va_list args ) { if (condition) { - printf( "%s:%d:%s Test succeeded inside todo block: ", - data->current_file, data->current_line, winetest_elapsed() ); + winetest_printf( "Test succeeded inside todo block: " ); vprintf(msg, args); InterlockedIncrement(&todo_failures); return 0; @@ -365,8 +374,7 @@ int winetest_vok( int condition, const char *msg, __winetest_va_list args ) { if (winetest_debug > 0) { - printf( "%s:%d:%s Test marked todo: ", - data->current_file, data->current_line, winetest_elapsed() ); + winetest_printf( "Test marked todo: " ); vprintf(msg, args); } InterlockedIncrement(&todo_successes); @@ -380,8 +388,7 @@ int winetest_vok( int condition, const char *msg, __winetest_va_list args ) { if (!condition) { - printf( "%s:%d:%s Test failed: ", - data->current_file, data->current_line, winetest_elapsed() ); + winetest_printf( "Test failed: " ); vprintf(msg, args); InterlockedIncrement(&failures); return 0; @@ -391,8 +398,7 @@ int winetest_vok( int condition, const char *msg, __winetest_va_list args ) if (winetest_report_success || (winetest_time && GetTickCount() >= winetest_last_time + 1000)) { - printf( "%s:%d:%s Test succeeded\n", - data->current_file, data->current_line, winetest_elapsed() ); + winetest_printf( "Test succeeded\n" ); } InterlockedIncrement(&successes); return 1; @@ -417,10 +423,8 @@ void __winetest_cdecl winetest_trace( const char *msg, ... ) return; if (winetest_add_line() < winetest_mute_threshold) { - struct tls_data *data = get_tls_data(); - printf( "%s:%d:%s ", data->current_file, data->current_line, winetest_elapsed() ); __winetest_va_start(valist, msg); - vprintf(msg, valist); + winetest_vprintf( msg, valist ); __winetest_va_end(valist); } else @@ -431,8 +435,7 @@ void winetest_vskip( const char *msg, __winetest_va_list args ) { if (winetest_add_line() < winetest_mute_threshold) { - struct tls_data *data = get_tls_data(); - printf( "%s:%d:%s Tests skipped: ", data->current_file, data->current_line, winetest_elapsed() ); + winetest_printf( "Tests skipped: " ); vprintf(msg, args); InterlockedIncrement(&skipped); } @@ -513,21 +516,16 @@ void winetest_wait_child_process( HANDLE process ) else { DWORD exit_code; - struct tls_data *data = get_tls_data(); GetExitCodeProcess( process, &exit_code ); if (exit_code > 255) { DWORD pid = GetProcessId( process ); - printf( "%s:%d:%s unhandled exception %08x in child process %04x\n", - data->current_file, data->current_line, winetest_elapsed(), - exit_code, pid ); + winetest_printf( "unhandled exception %08x in child process %04x\n", exit_code, pid ); InterlockedIncrement( &failures ); } else if (exit_code) { - printf( "%s:%d:%s %u failures in child process\n", - data->current_file, data->current_line, winetest_elapsed(), - exit_code ); + winetest_printf( "%u failures in child process\n", exit_code ); while (exit_code-- > 0) InterlockedIncrement(&failures); } -- 2.30.2

5 6

[PATCH vkd3d v2 1/7] vkd3d-shader: Rename name_offset to name_bytecode_offset.
by Zebediah Figura 10 May '21

10 May '21

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- v2: No changes. libs/vkd3d-shader/hlsl.h | 4 ++-- libs/vkd3d-shader/hlsl_codegen.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 3dc7a26b..0c755f46 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -136,9 +136,9 @@ struct hlsl_struct_field struct hlsl_type *type; const char *name; const char *semantic; - unsigned int reg_offset; - unsigned int name_offset; + + unsigned int name_bytecode_offset; }; struct hlsl_reg diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 1b5e8a27..2c07171b 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -1051,7 +1051,7 @@ static void write_sm1_type(struct bytecode_buffer *buffer, struct hlsl_type *typ { LIST_FOR_EACH_ENTRY(field, array_type->e.elements, struct hlsl_struct_field, entry) { - field->name_offset = buffer->count; + field->name_bytecode_offset = buffer->count; put_string(buffer, field->name); write_sm1_type(buffer, field->type, ctab_start); } @@ -1060,7 +1060,7 @@ static void write_sm1_type(struct bytecode_buffer *buffer, struct hlsl_type *typ LIST_FOR_EACH_ENTRY(field, array_type->e.elements, struct hlsl_struct_field, entry) { - put_dword(buffer, (field->name_offset - ctab_start) * sizeof(*buffer->data)); + put_dword(buffer, (field->name_bytecode_offset - ctab_start) * sizeof(*buffer->data)); put_dword(buffer, (field->type->bytecode_offset - ctab_start) * sizeof(*buffer->data)); ++field_count; } -- 2.31.1

5 23

[PATCH] msxml3: Handle SAX tags and characters for mxwriter domdoc.
by Jefferson Carpenter 09 May '21

09 May '21

Moved some code from mxwriter ISAXContentHandler implementation into free functions that can be swapped out for DOMDocument functions. For other mxwriter callback functions, immediately return E_NOTIMPL if the destination is a DOMDocument. Added test_mxwriter_domdoc_start_end_document to help check the implementation of DOMDocument locking. Added "BOOL locked" to XML documents and a private interface that allows this variable to be set and checked. (This variable is not used thread safely. `LONG refs` is thread safe, but `struct list orphans` is not.) thanks, Jefferson

3 7

[PATCH v3 2/5] msxml3/tests: Add more tests for processing instruction attributes.
by Dmitry Timoshkov 09 May '21

09 May '21

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/tests/domdoc.c | 43 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 41 insertions(+), 2 deletions(-) diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index ba8453430c6..59a8a243c87 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -46,6 +46,8 @@ #include "wine/heap.h" #include "wine/test.h" +#define XML_E_UNEXPECTED_ATTRIBUTE 0xC00CE56C + /* undef the #define in msxml2 so that we can access all versions */ #undef CLSID_DOMDocument @@ -8529,10 +8531,11 @@ static void test_createProcessingInstruction(void) static const char xml3_wine[] = "<?xml version=\"1.0\" standalone=\"yes\"?>\n<test/>\n"; IXMLDOMProcessingInstruction *pi; IXMLDOMDocument *doc; - IXMLDOMNode *node; + IXMLDOMNode *node, *item; + IXMLDOMNamedNodeMap *node_map; IXMLDOMElement *element; WCHAR buff[10]; - BSTR xml; + BSTR xml, bstr; VARIANT var; HRESULT hr; IStream *stream; @@ -8543,6 +8546,10 @@ static void test_createProcessingInstruction(void) doc = create_document(&IID_IXMLDOMDocument); + hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\" encoding=\"windows-1252\" dummy=\"value\""), &pi); +todo_wine + ok(hr == XML_E_UNEXPECTED_ATTRIBUTE, "got 0x%08x\n", hr); + /* test for BSTR handling, pass broken BSTR */ memcpy(&buff[2], L"test", 5 * sizeof(WCHAR)); /* just a big length */ @@ -8561,6 +8568,38 @@ static void test_createProcessingInstruction(void) ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXMLDOMDocument_appendChild(doc, node, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = IXMLDOMNode_get_attributes(node, &node_map); + ok(hr == S_OK, "got 0x%08x\n", hr); + + item = (void *)0xdeadbeef; + hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, _bstr_("xml"), &item); + ok(hr == S_FALSE, "got 0x%08x\n", hr); + ok(!item, "got %p\n", item); + + item = NULL; + hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, _bstr_("encoding"), &item); +todo_wine + ok(hr == S_OK, "got 0x%08x\n", hr); +todo_wine + ok(item != NULL, "got NULL\n"); + +if (hr == S_OK) +{ + hr = IXMLDOMNode_get_nodeName(item, &bstr); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(!lstrcmpW(bstr, L"encoding"), "got %s\n", wine_dbgstr_w(bstr)); + SysFreeString(bstr); + + VariantInit(&var); + hr = IXMLDOMNode_get_nodeValue(item, &var); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(V_VT(&var) == VT_BSTR, "got %u\n", V_VT(&var)); + ok(!lstrcmpW(V_BSTR(&var), L"windows-1252"), "got %s\n", wine_dbgstr_w(V_BSTR(&var))); + VariantClear(&var); +} + + IXMLDOMNamedNodeMap_Release(node_map); IXMLDOMNode_Release(node); IXMLDOMProcessingInstruction_Release(pi); -- 2.31.1

4 3

[PATCH] winnt.h: Fix MSVC variants of InterlockedIncrement16 and InterlockedDecrement16.
by Jacek Caban 07 May '21

07 May '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- FWIW, depending on distro, building in this mode may be as easy as adding CROSSCC=clang to configure. include/winnt.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)

2 11

[PATCH 1/2] mfreadwrite/tests: Test setting a non-native bit depth on the reader.
by Giovanni Mascellani 07 May '21

07 May '21

--- dlls/mfreadwrite/tests/mfplat.c | 52 +++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/dlls/mfreadwrite/tests/mfplat.c b/dlls/mfreadwrite/tests/mfplat.c index 8ea4e5038f6..8381e535d26 100644 --- a/dlls/mfreadwrite/tests/mfplat.c +++ b/dlls/mfreadwrite/tests/mfplat.c @@ -362,6 +362,8 @@ static HRESULT WINAPI test_source_CreatePresentationDescriptor(IMFMediaSource *i ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFAudioFormat_PCM); ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetUINT32(media_type, &MF_MT_AUDIO_BITS_PER_SAMPLE, 32); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); hr = MFCreateStreamDescriptor(i, 1, &media_type, &sds[i]); ok(hr == S_OK, "Failed to create stream descriptor, hr %#x.\n", hr); @@ -897,6 +899,7 @@ static void test_source_reader_from_media_source(void) struct async_callback *callback; IMFSourceReader *reader; IMFMediaSource *source; + IMFMediaType *media_type; HRESULT hr; DWORD actual_index, stream_flags; IMFSample *sample; @@ -1042,6 +1045,55 @@ static void test_source_reader_from_media_source(void) IMFSourceReader_Release(reader); IMFMediaSource_Release(source); + /* Request a non-native bit depth. */ + source = create_test_source(1); + ok(!!source, "Failed to create test source.\n"); + + hr = MFCreateSourceReaderFromMediaSource(source, NULL, &reader); + ok(hr == S_OK, "Failed to create source reader, hr %#x.\n", hr); + + hr = MFCreateMediaType(&media_type); + ok(hr == S_OK, "Failed to create media type, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFAudioFormat_PCM); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetUINT32(media_type, &MF_MT_AUDIO_BITS_PER_SAMPLE, 16); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFSourceReader_SetCurrentMediaType(reader, 0, NULL, media_type); +todo_wine + ok(hr == MF_E_TOPO_CODEC_NOT_FOUND, "Unexpected success setting current media type, hr %#x.\n", hr); + + IMFMediaType_Release(media_type); + + hr = MFCreateMediaType(&media_type); + ok(hr == S_OK, "Failed to create media type, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFAudioFormat_PCM); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetUINT32(media_type, &MF_MT_AUDIO_BITS_PER_SAMPLE, 32); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFSourceReader_SetCurrentMediaType(reader, 0, NULL, media_type); + ok(hr == S_OK, "Failed to set current media type, hr %#x.\n", hr); + + hr = IMFSourceReader_SetStreamSelection(reader, 0, TRUE); + ok(hr == S_OK, "Failed to select a stream, hr %#x.\n", hr); + + hr = IMFSourceReader_ReadSample(reader, 0, 0, &actual_index, &stream_flags, &timestamp, &sample); + ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr); + ok(actual_index == 0, "Unexpected stream index %u\n", actual_index); + ok(!stream_flags, "Unexpected stream flags %#x.\n", stream_flags); + ok(timestamp == 123, "Unexpected timestamp.\n"); + ok(!!sample, "Expected sample object.\n"); + IMFSample_Release(sample); + + IMFMediaType_Release(media_type); + IMFSourceReader_Release(reader); + IMFMediaSource_Release(source); + /* Async mode. */ source = create_test_source(3); ok(!!source, "Failed to create test source.\n"); -- 2.31.0

2 5

[PATCH v3 3/5] msxml3: Implement ::get_attributes() for "xml" processing instruction node.
by Dmitry Timoshkov 07 May '21

07 May '21

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/pi.c | 140 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 139 insertions(+), 1 deletion(-) diff --git a/dlls/msxml3/pi.c b/dlls/msxml3/pi.c index cea95708087..fe291e72af8 100644 --- a/dlls/msxml3/pi.c +++ b/dlls/msxml3/pi.c @@ -34,6 +34,7 @@ #include "ole2.h" #include "msxml6.h" +#include "xmlparser.h" #include "msxml_private.h" #include "wine/debug.h" @@ -287,6 +288,138 @@ static HRESULT WINAPI dom_pi_get_nextSibling( return node_get_next_sibling(&This->node, domNode); } +static HRESULT xml_get_value(xmlChar **p, xmlChar **value) +{ + xmlChar *v; + int len; + + while (isspace(**p)) *p += 1; + if (**p != '=') return XML_E_MISSINGEQUALS; + *p += 1; + + while (isspace(**p)) *p += 1; + if (**p != '"') return XML_E_MISSINGQUOTE; + *p += 1; + + v = *p; + while (**p && **p != '"') *p += 1; + if (!**p) return XML_E_EXPECTINGCLOSEQUOTE; + len = *p - v; + if (!len) return XML_E_MISSINGNAME; + *p += 1; + + *value = heap_alloc(len + 1); + if (!*value) return E_OUTOFMEMORY; + memcpy(*value, v, len); + *(*value + len) = 0; + + return S_OK; +} + +static void set_prop(xmlNodePtr node, xmlAttrPtr attr) +{ + xmlAttrPtr prop; + + if (!node->properties) + { + node->properties = attr; + return; + } + + prop = node->properties; + while (prop->next) prop = prop->next; + + prop->next = attr; +} + +static HRESULT parse_xml_decl(xmlNodePtr node) +{ + xmlChar *version, *encoding, *standalone, *p; + xmlAttrPtr attr; + HRESULT hr = S_OK; + + if (!node->content) return S_OK; + + version = encoding = standalone = NULL; + + p = node->content; + + while (*p) + { + while (isspace(*p)) p++; + if (!*p) break; + + if (!strncmp((const char *)p, "version", 7)) + { + p += 7; + if ((hr = xml_get_value(&p, &version)) != S_OK) goto fail; + } + else if (!strncmp((const char *)p, "encoding", 8)) + { + p += 8; + if ((hr = xml_get_value(&p, &encoding)) != S_OK) goto fail; + } + else if (!strncmp((const char *)p, "standalone", 10)) + { + p += 10; + if ((hr = xml_get_value(&p, &standalone)) != S_OK) goto fail; + } + else + { + FIXME("unexpected XML attribute %s\n", debugstr_a((const char *)p)); + hr = XML_E_UNEXPECTED_ATTRIBUTE; + goto fail; + } + } + + /* xmlSetProp/xmlSetNsProp accept only nodes of type XML_ELEMENT_NODE, + * so we have to create and assign attributes to a node by hand. + */ + + if (version) + { + attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"version", version); + if (attr) + { + attr->doc = node->doc; + set_prop(node, attr); + } + else hr = E_OUTOFMEMORY; + } + if (encoding) + { + attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"encoding", encoding); + if (attr) + { + attr->doc = node->doc; + set_prop(node, attr); + } + else hr = E_OUTOFMEMORY; + } + if (standalone) + { + attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"standalone", standalone); + if (attr) + { + attr->doc = node->doc; + set_prop(node, attr); + } + else hr = E_OUTOFMEMORY; + } + +fail: + if (hr != S_OK) + { + xmlFreePropList(node->properties); + node->properties = NULL; + } + + heap_free(version); + heap_free(encoding); + heap_free(standalone); + return hr; +} + static HRESULT WINAPI dom_pi_get_attributes( IXMLDOMProcessingInstruction *iface, IXMLDOMNamedNodeMap** map) @@ -307,7 +440,12 @@ static HRESULT WINAPI dom_pi_get_attributes( if (!strcmpW(name, xmlW)) { - FIXME("created dummy map for <?xml ?>\n"); + if (!This->node.node->properties) + { + hr = parse_xml_decl(This->node.node); + if (hr != S_OK) return S_FALSE; + } + *map = create_nodemap(This->node.node, &dom_pi_attr_map); SysFreeString(name); return S_OK; -- 2.31.1

2 3

[PATCH v3 1/5] msxml3/tests: Don't '\0' terminate output after ::save().
by Dmitry Timoshkov 06 May '21

06 May '21

This fixes heap corruption when running the domdoc tests. v3: Apparently Windows 8 and later started to \0 terminate buffer in ::save, so to avoid test failures perform comparisons with memcmp() instead of strcmp(). Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/tests/domdoc.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 6f8e2b44ed3..ba8453430c6 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -8586,8 +8586,7 @@ todo_wine hr = GetHGlobalFromStream(stream, &global); ok(hr == S_OK, "got 0x%08x\n", hr); p = GlobalLock(global); - p[GlobalSize(global)] = 0; - ok(!strcmp(p, xml2) || !strcmp(p, xml2_wine), "got %s\n", wine_dbgstr_a(p)); + ok(!memcmp(p, xml2, sizeof(xml2) - 1) || !memcmp(p, xml2_wine, sizeof(xml2_wine) - 1), "got %s\n", wine_dbgstr_a(p)); GlobalUnlock(global); /* Verify the result after load+save */ @@ -8609,8 +8608,7 @@ todo_wine hr = GetHGlobalFromStream(stream, &global); ok(hr == S_OK, "got 0x%08x\n", hr); p = GlobalLock(global); - p[GlobalSize(global)] = 0; - ok(!strcmp(p, xml2) || !strcmp(p, xml2_wine), "got %s\n", wine_dbgstr_a(p)); + ok(!memcmp(p, xml2, sizeof(xml2) - 1) || !memcmp(p, xml2_wine, sizeof(xml2_wine) - 1), "got %s\n", wine_dbgstr_a(p)); GlobalUnlock(global); IStream_Release(stream); @@ -8631,8 +8629,7 @@ todo_wine ok(hr == S_OK, "got 0x%08x\n", hr); p = GlobalLock(global); - p[GlobalSize(global)] = 0; - ok(!strcmp(p, xml3) || !strcmp(p, xml3_wine), "got %s\n", wine_dbgstr_a(p)); + ok(!memcmp(p, xml3, sizeof(xml3) - 1) || !memcmp(p, xml3_wine, sizeof(xml3_wine) - 1), "got %s\n", wine_dbgstr_a(p)); GlobalUnlock(global); IStream_Release(stream); -- 2.31.1

2 1

Re: TestBot job 89319 results: [PATCH 1/4] msxml3/tests: Add more tests for processing instruction attributes.
by Dmitry Timoshkov 06 May '21

06 May '21

Marvin <testbot(a)winehq.org> wrote: > VM Status Failures Command > build success > w2008s64 success 0 msxml3_test.exe domdoc > w7u_2qxl success 0 msxml3_test.exe domdoc > w7u_adm success 0 msxml3_test.exe domdoc > w7u_el success 0 msxml3_test.exe domdoc > w8 success 0 msxml3_test.exe domdoc > w8adm success 0 msxml3_test.exe domdoc > w864 success 0 msxml3_test.exe domdoc > w1064v1507 success 0 msxml3_test.exe domdoc > w1064v1809 success 0 msxml3_test.exe domdoc > w1064 success 0 msxml3_test.exe domdoc > w10pro64 success 0 msxml3_test.exe domdoc > wvistau64 failed 1 msxml3_test64.exe domdoc > w2008s64 failed 1 msxml3_test64.exe domdoc > w864 failed 1 msxml3_test64.exe domdoc > w1064v1507 failed 1 msxml3_test64.exe domdoc > w1064v1809 failed 1 msxml3_test64.exe domdoc > w1064 failed 1 msxml3_test64.exe domdoc > w1064_2qxl failed 1 msxml3_test64.exe domdoc > w10pro64 failed 1 msxml3_test64.exe domdoc > w10pro64_ar failed 1 msxml3_test64.exe domdoc > w10pro64_he failed 1 msxml3_test64.exe domdoc > w10pro64_ja failed 1 msxml3_test64.exe domdoc > w10pro64_zh_CN failed 1 msxml3_test64.exe domdoc > debiant2 success 0 > debiant2 failed 1 > > You can also see the results at: > https://testbot.winehq.org/JobDetails.pl?Key=89319 Same patch sent separately runs without failures: https://testbot.winehq.org/JobDetails.pl?Key=89342 -- Dmitry.

5 9

[PATCH] urlmon/tests: Allow x64 to be last in the user agent.
by Francois Gouget 06 May '21

06 May '21

Windows would normally have .Net strings that follow but Wine does not in 64-bit mode. Still the formatting makes sense so allow it. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- This fixes a test failure in Wine in wow64 mode. https://test.winehq.org/data/patterns.html#urlmon:misc https://testbot.winehq.org/JobDetails.pl?Key=89589 An alternative would be to turn it into a todo if i == 1. --- dlls/urlmon/tests/misc.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dlls/urlmon/tests/misc.c b/dlls/urlmon/tests/misc.c index 2b3df65d5fc..5b179b55770 100644 --- a/dlls/urlmon/tests/misc.c +++ b/dlls/urlmon/tests/misc.c @@ -1544,7 +1544,9 @@ static void test_user_agent(void) }else if(sizeof(void*) == 8) { p += check_prefix(p, "Win64; "); #ifdef __x86_64__ - p += check_prefix(p, "x64; "); + p += check_prefix(p, "x64"); + if (*p == ';') + p += check_prefix(p, "; "); #endif } if(i != 1) { -- 2.20.1

2 2

[PATCH] msxml3: Refcount the domdoc/xmldoc properties.
by Francois Gouget 06 May '21

06 May '21

Multiple domdoc and xmlDoc objects may need to share a common properties structure but even though they may be released independently. So add a reference count on the properties structure. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=43377 Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- {create,copy}_properties() both initialize the refcount to 1 because it's simpler that way given that the object is always used after being created. create_priv() initializes its refcount to 0 instead but then its use case seems more complex. I decided to investigate this because msxml3:domdoc started failing on 2021-03-25. https://test.winehq.org/data/patterns-tb-wine.html Given the Wine trouble the day before this looked like it could be the symptom of some widespread issue. But then I could still reproduce the issue when building from the 23rd source which was puzzling. It turns out this is an old failure (as evidenced by the bug) and we just got lucky to avoid crashes for a while. --- dlls/msxml3/domdoc.c | 42 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 38 insertions(+), 4 deletions(-) diff --git a/dlls/msxml3/domdoc.c b/dlls/msxml3/domdoc.c index cf4f0433218..73ac97ab89a 100644 --- a/dlls/msxml3/domdoc.c +++ b/dlls/msxml3/domdoc.c @@ -80,6 +80,7 @@ static const WCHAR PropertyNormalizeAttributeValuesW[] = {'N','o','r','m','a','l * We need to preserve this when reloading a document, * and also need access to it from the libxml backend. */ typedef struct { + LONG refs; MSXML_VERSION version; VARIANT_BOOL preserving; IXMLDOMSchemaCollection2* schemaCache; @@ -290,6 +291,7 @@ static domdoc_properties *create_properties(MSXML_VERSION version) { domdoc_properties *properties = heap_alloc(sizeof(domdoc_properties)); + properties->refs = 1; list_init(&properties->selectNsList); properties->preserving = VARIANT_FALSE; properties->schemaCache = NULL; @@ -316,6 +318,7 @@ static domdoc_properties* copy_properties(domdoc_properties const* properties) if (pcopy) { + pcopy->refs = 1; pcopy->version = properties->version; pcopy->preserving = properties->preserving; pcopy->schemaCache = properties->schemaCache; @@ -345,9 +348,22 @@ static domdoc_properties* copy_properties(domdoc_properties const* properties) return pcopy; } -static void free_properties(domdoc_properties* properties) +LONG properties_add_ref(domdoc_properties* properties) { - if (properties) + LONG ref = InterlockedExchangeAdd(&properties->refs, 1) + 1; + TRACE("(%p)->(%d)\n", properties, ref); + return ref; +} + +static LONG properties_release(domdoc_properties* properties) +{ + LONG ref = InterlockedExchangeAdd(&properties->refs, -1) - 1; + TRACE("(%p)->(%d)\n", properties, ref); + + if (ref < 0) + WARN("negative refcount, expect troubles\n"); + + if (ref == 0) { if (properties->schemaCache) IXMLDOMSchemaCollection2_Release(properties->schemaCache); @@ -357,6 +373,8 @@ static void free_properties(domdoc_properties* properties) IUri_Release(properties->uri); heap_free(properties); } + + return ref; } static void release_namespaces(domdoc *This) @@ -622,7 +640,8 @@ LONG xmldoc_release_refs(xmlDocPtr doc, LONG refs) xmlFreeNode( orphan->node ); heap_free( orphan ); } - free_properties(priv->properties); + if (priv->properties) + properties_release(priv->properties); heap_free(doc->_private); xmlFreeDoc(doc); @@ -679,10 +698,17 @@ static HRESULT attach_xmldoc(domdoc *This, xmlDocPtr xml ) if(This->node.node) { + if (properties_from_xmlDocPtr(get_doc(This))) + properties_release(properties_from_xmlDocPtr(get_doc(This))); priv_from_xmlDocPtr(get_doc(This))->properties = NULL; if (xmldoc_release(get_doc(This)) != 0) + { + /* The xmlDocPtr object can no longer use the properties of this + * domdoc object. So give it its own copy. + */ priv_from_xmlDocPtr(get_doc(This))->properties = copy_properties(This->properties); + } } This->node.node = (xmlNodePtr) xml; @@ -690,7 +716,11 @@ static HRESULT attach_xmldoc(domdoc *This, xmlDocPtr xml ) if(This->node.node) { xmldoc_add_ref(get_doc(This)); + /* Only attach new xmlDocPtr objects, i.e. ones for which properties + * is still NULL. + */ priv_from_xmlDocPtr(get_doc(This))->properties = This->properties; + properties_add_ref(properties_from_xmlDocPtr(get_doc(This))); } return S_OK; @@ -975,6 +1005,7 @@ static ULONG WINAPI domdoc_Release( IXMLDOMDocument3 *iface ) for (eid = 0; eid < EVENTID_LAST; eid++) if (This->events[eid]) IDispatch_Release(This->events[eid]); + properties_release(This->properties); release_namespaces(This); heap_free(This); } @@ -3676,6 +3707,8 @@ HRESULT get_domdoc_from_xmldoc(xmlDocPtr xmldoc, IXMLDOMDocument3 **document) doc->validating = 0; doc->resolving = 0; doc->properties = properties_from_xmlDocPtr(xmldoc); + if (doc->properties) + properties_add_ref(doc->properties); doc->error = S_OK; doc->site = NULL; doc->base_uri = NULL; @@ -3714,7 +3747,8 @@ HRESULT DOMDocument_create(MSXML_VERSION version, void **ppObj) hr = get_domdoc_from_xmldoc(xmldoc, (IXMLDOMDocument3**)ppObj); if(FAILED(hr)) { - free_properties(properties_from_xmlDocPtr(xmldoc)); + if (properties_from_xmlDocPtr(xmldoc)) + properties_release(properties_from_xmlDocPtr(xmldoc)); heap_free(xmldoc->_private); xmlFreeDoc(xmldoc); return hr; -- 2.20.1

2 2

[PATCH 1/5] ntoskrnl: Implement IoSetDevicePropertyData().
by Rémi Bernon 04 May '21

04 May '21

From: Arkadiusz Hiler <ahiler(a)codeweavers.com> Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- In PATCH 1, the return GetLastError() look wrong to me but the same is done in IoGetDeviceProperty so I kept them. I guess we would need to convert the setupapi error back to NTSTATUS, or implement the higher level setupapi on top of these lower level primitives intead. In PATCH 2, I moved the error case before IoInvalidateDeviceRelations, because I don't know what the call is actually expecting. Maybe it was unnecessary. dlls/ntoskrnl.exe/ntoskrnl.exe.spec | 1 + dlls/ntoskrnl.exe/pnp.c | 51 +++++++++++++++++++++++++++++ include/ddk/wdm.h | 4 +++ 3 files changed, 56 insertions(+) diff --git a/dlls/ntoskrnl.exe/ntoskrnl.exe.spec b/dlls/ntoskrnl.exe/ntoskrnl.exe.spec index 2e5e2e6e11b..4eb08faec2e 100644 --- a/dlls/ntoskrnl.exe/ntoskrnl.exe.spec +++ b/dlls/ntoskrnl.exe/ntoskrnl.exe.spec @@ -465,6 +465,7 @@ @ stdcall IoReuseIrp(ptr long) @ stub IoSetCompletionRoutineEx @ stdcall IoSetDeviceInterfaceState(ptr long) +@ stdcall IoSetDevicePropertyData(ptr ptr long long long long ptr) @ stub IoSetDeviceToVerify @ stub IoSetFileOrigin @ stub IoSetHardErrorOrVerifyDevice diff --git a/dlls/ntoskrnl.exe/pnp.c b/dlls/ntoskrnl.exe/pnp.c index 095344b1073..e425712d738 100644 --- a/dlls/ntoskrnl.exe/pnp.c +++ b/dlls/ntoskrnl.exe/pnp.c @@ -38,6 +38,12 @@ DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0); WINE_DEFAULT_DEBUG_CHANNEL(plugplay); +static inline const char *debugstr_propkey( const DEVPROPKEY *id ) +{ + if (!id) return "(null)"; + return wine_dbg_sprintf( "{%s,%04x}", wine_dbgstr_guid( &id->fmtid ), id->pid ); +} + #define MAX_SERVICE_NAME 260 struct device_interface @@ -783,6 +789,51 @@ NTSTATUS WINAPI IoSetDeviceInterfaceState( UNICODE_STRING *name, BOOLEAN enable return ret; } +/*********************************************************************** + * IoSetDevicePropertyData (NTOSKRNL.EXE.@) + */ +NTSTATUS WINAPI IoSetDevicePropertyData( DEVICE_OBJECT *device, const DEVPROPKEY *property_key, LCID lcid, + ULONG flags, DEVPROPTYPE type, ULONG size, void *data ) +{ + SP_DEVINFO_DATA sp_device = {sizeof(sp_device)}; + WCHAR device_instance_id[MAX_DEVICE_ID_LEN]; + NTSTATUS status; + HDEVINFO set; + + TRACE( "device %p, property_key %s, lcid %#x, flags %#x, type %#x, size %u, data %p.\n", + device, debugstr_propkey(property_key), lcid, flags, type, size, data ); + + /* flags is always treated as PLUGPLAY_PROPERTY_PERSISTENT starting with Win 8 / 2012 */ + + if (lcid != LOCALE_NEUTRAL) FIXME( "only LOCALE_NEUTRAL is supported\n" ); + + if ((status = get_device_instance_id( device, device_instance_id ))) return status; + + if ((set = SetupDiCreateDeviceInfoList( &GUID_NULL, NULL )) == INVALID_HANDLE_VALUE) + { + ERR( "Failed to create device list, error %#x.\n", GetLastError() ); + return GetLastError(); + } + + if (!SetupDiOpenDeviceInfoW( set, device_instance_id, NULL, 0, &sp_device )) + { + ERR( "Failed to open device, error %#x.\n", GetLastError() ); + SetupDiDestroyDeviceInfoList( set ); + return GetLastError(); + } + + if (!SetupDiSetDevicePropertyW( set, &sp_device, property_key, type, data, size, 0 )) + { + ERR( "Failed to set property, error %#x.\n", GetLastError() ); + SetupDiDestroyDeviceInfoList( set ); + return GetLastError(); + } + + SetupDiDestroyDeviceInfoList( set ); + + return STATUS_SUCCESS; +} + /*********************************************************************** * IoRegisterDeviceInterface (NTOSKRNL.EXE.@) */ diff --git a/include/ddk/wdm.h b/include/ddk/wdm.h index 51097bfe3ab..447833c4bc9 100644 --- a/include/ddk/wdm.h +++ b/include/ddk/wdm.h @@ -21,6 +21,7 @@ #define _NTDDK_ #include <ntstatus.h> +#include <devpropdef.h> #ifdef _WIN64 #define POINTER_ALIGNMENT DECLSPEC_ALIGN(8) @@ -1681,6 +1682,8 @@ void WINAPI ExReleaseResourceForThreadLite(ERESOURCE*,ERESOURCE_THREAD); ULONG WINAPI ExSetTimerResolution(ULONG,BOOLEAN); void WINAPI ExUnregisterCallback(void*); +#define PLUGPLAY_PROPERTY_PERSISTENT 0x0001 + void WINAPI IoAcquireCancelSpinLock(KIRQL*); NTSTATUS WINAPI IoAcquireRemoveLockEx(IO_REMOVE_LOCK*,void*,const char*,ULONG, ULONG); NTSTATUS WINAPI IoAllocateDriverObjectExtension(PDRIVER_OBJECT,PVOID,ULONG,PVOID*); @@ -1728,6 +1731,7 @@ void WINAPI IoReleaseRemoveLockAndWaitEx(IO_REMOVE_LOCK*,void*,ULONG); void WINAPI IoReleaseRemoveLockEx(IO_REMOVE_LOCK*,void*,ULONG); void WINAPI IoReuseIrp(IRP*,NTSTATUS); NTSTATUS WINAPI IoSetDeviceInterfaceState(UNICODE_STRING*,BOOLEAN); +NTSTATUS WINAPI IoSetDevicePropertyData(DEVICE_OBJECT*,const DEVPROPKEY*,LCID,ULONG,DEVPROPTYPE,ULONG,void*); NTSTATUS WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT,ULONG); void FASTCALL KeAcquireInStackQueuedSpinLockAtDpcLevel(KSPIN_LOCK*,KLOCK_QUEUE_HANDLE*); -- 2.31.0

4 16

[PATCH v2 1/7] d3d8/tests: Port test_sample_mask() from d3d9.
by Zebediah Figura 03 May '21

03 May '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/d3d8/tests/visual.c | 88 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/dlls/d3d8/tests/visual.c b/dlls/d3d8/tests/visual.c index fc8a05a3c40..f25549388d0 100644 --- a/dlls/d3d8/tests/visual.c +++ b/dlls/d3d8/tests/visual.c @@ -11070,6 +11070,93 @@ static void test_desktop_window(void) IDirect3D8_Release(d3d); } +static void test_sample_mask(void) +{ + IDirect3DSurface8 *rt, *ms_rt; + struct surface_readback rb; + IDirect3DDevice8 *device; + IDirect3D8 *d3d; + ULONG refcount; + DWORD colour; + HWND window; + HRESULT hr; + + static const struct + { + struct vec3 position; + DWORD diffuse; + } + quad[] = + { + {{-1.0f, -1.0f, 0.1f}, 0xffffffff}, + {{-1.0f, 1.0f, 0.1f}, 0xffffffff}, + {{ 1.0f, -1.0f, 0.1f}, 0xffffffff}, + {{ 1.0f, 1.0f, 0.1f}, 0xffffffff}, + }; + + window = create_window(); + d3d = Direct3DCreate8(D3D_SDK_VERSION); + ok(!!d3d, "Failed to create a D3D object.\n"); + + if (FAILED(IDirect3D8_CheckDeviceMultiSampleType(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, + D3DFMT_A8R8G8B8, TRUE, D3DMULTISAMPLE_2_SAMPLES))) + { + skip("Multisampling not supported for D3DFMT_A8R8G8B8.\n"); + IDirect3D8_Release(d3d); + DestroyWindow(window); + return; + } + + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a 3D device.\n"); + IDirect3D8_Release(d3d); + DestroyWindow(window); + return; + } + + hr = IDirect3DDevice8_CreateRenderTarget(device, 128, 128, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, FALSE, &rt); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_CreateRenderTarget(device, 128, 128, + D3DFMT_A8R8G8B8, D3DMULTISAMPLE_2_SAMPLES, FALSE, &ms_rt); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_SetRenderTarget(device, ms_rt, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_BeginScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_LIGHTING, FALSE); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_MULTISAMPLEMASK, 0x5); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0f, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_SetVertexShader(device, D3DFVF_XYZ | D3DFVF_DIFFUSE); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0])); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_CopyRects(device, ms_rt, NULL, 0, rt, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + get_rt_readback(rt, &rb); + colour = get_readback_color(&rb, 64, 64); + ok(color_match(colour, 0xffff8080, 1), "Got unexpected colour %08x.\n", colour); + release_surface_readback(&rb); + + hr = IDirect3DDevice8_EndScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + IDirect3DSurface8_Release(ms_rt); + IDirect3DSurface8_Release(rt); + refcount = IDirect3DDevice8_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + IDirect3D8_Release(d3d); + DestroyWindow(window); +} + START_TEST(visual) { D3DADAPTER_IDENTIFIER8 identifier; @@ -11147,4 +11234,5 @@ START_TEST(visual) test_sysmem_draw(); test_alphatest(); test_desktop_window(); + test_sample_mask(); } -- 2.30.2

5 15

[PATCH v2] winex11.drv: Handle Vulkan surface creation with NULL hwnd.
by Paul Gofman 03 May '21

03 May '21

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- For Red Dead Redemption 2. v2: - store hwnd in struct wine_vk_surface instead of a dedicated flag. dlls/vulkan-1/tests/vulkan.c | 112 ++++++++++++++++++++++++++++++++++- dlls/winex11.drv/vulkan.c | 38 +++++++++--- dlls/winex11.drv/window.c | 20 +++++++ dlls/winex11.drv/x11drv.h | 1 + 4 files changed, 160 insertions(+), 11 deletions(-) diff --git a/dlls/vulkan-1/tests/vulkan.c b/dlls/vulkan-1/tests/vulkan.c index 9061b2b6db8..e516d0d61c8 100644 --- a/dlls/vulkan-1/tests/vulkan.c +++ b/dlls/vulkan-1/tests/vulkan.c @@ -437,7 +437,102 @@ static void test_private_data(VkPhysicalDevice vk_physical_device) vkDestroyDevice(vk_device, NULL); } -static void for_each_device(void (*test_func)(VkPhysicalDevice)) +static const char *test_null_hwnd_extensions[] = +{ + "VK_KHR_surface", + "VK_KHR_win32_surface", +}; + +static void test_null_hwnd(VkInstance vk_instance, VkPhysicalDevice vk_physical_device) +{ + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR pvkGetPhysicalDeviceSurfacePresentModesKHR; + VkDeviceGroupPresentModeFlagsKHR present_mode_flags; + VkWin32SurfaceCreateInfoKHR surface_create_info; + VkSurfaceCapabilitiesKHR surf_caps; + VkSurfaceFormatKHR *formats; + uint32_t queue_family_index; + VkPresentModeKHR *modes; + VkSurfaceKHR surface; + VkDevice vk_device; + uint32_t count; + VkRect2D rect; + VkBool32 bval; + VkResult vr; + + pvkGetPhysicalDeviceSurfacePresentModesKHR = (void *)vkGetInstanceProcAddr(vk_instance, + "vkGetPhysicalDeviceSurfacePresentModesKHR"); + surface_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; + surface_create_info.pNext = NULL; + surface_create_info.flags = 0; + surface_create_info.hinstance = NULL; + surface_create_info.hwnd = NULL; + + bval = find_queue_family(vk_physical_device, VK_QUEUE_GRAPHICS_BIT, &queue_family_index); + ok(bval, "Could not find presentation queue.\n"); + + surface = 0xdeadbeef; + vr = vkCreateWin32SurfaceKHR(vk_instance, &surface_create_info, NULL, &surface); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(surface != 0xdeadbeef, "Surface not created.\n"); + + count = 0; + vr = vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device, surface, &count, NULL); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(count, "Got zero count.\n"); + formats = heap_alloc(sizeof(*formats) * count); + vr = vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device, surface, &count, formats); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + heap_free(formats); + + vr = vkGetPhysicalDeviceSurfaceSupportKHR(vk_physical_device, queue_family_index, surface, &bval); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + + vr = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_physical_device, surface, &surf_caps); + ok(vr, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR succeeded.\n"); + + count = 0; + vr = pvkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device, surface, &count, NULL); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(count, "Got zero count.\n"); + modes = heap_alloc(sizeof(*modes) * count); + vr = pvkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device, surface, &count, modes); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + heap_free(modes); + + count = 0; + vr = vkGetPhysicalDevicePresentRectanglesKHR(vk_physical_device, surface, &count, NULL); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(count == 1, "Got unexpected count %u.\n", count); + memset(&rect, 0xcc, sizeof(rect)); + vr = vkGetPhysicalDevicePresentRectanglesKHR(vk_physical_device, surface, &count, &rect); + if (vr == VK_SUCCESS) /* Fails on AMD, succeeds on Nvidia. */ + { + ok(count == 1, "Got unexpected count %u.\n", count); + ok(!rect.offset.x && !rect.offset.y && !rect.extent.width && !rect.extent.height, + "Got unexpected rect %d, %d, %u, %u.\n", + rect.offset.x, rect.offset.y, rect.extent.width, rect.extent.height); + } + + if ((vr = create_device(vk_physical_device, 0, NULL, NULL, &vk_device)) < 0) + { + skip("Failed to create device, vr %d.\n", vr); + vkDestroySurfaceKHR(vk_instance, surface, NULL); + return; + } + + if (0) + { + /* Causes access violation on Windows. */ + vr = vkGetDeviceGroupSurfacePresentModesKHR(vk_device, surface, &present_mode_flags); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + } + + vkDestroyDevice(vk_device, NULL); + vkDestroySurfaceKHR(vk_instance, surface, NULL); +} + +static void for_each_device_instance(uint32_t extension_count, const char * const *enabled_extensions, + void (*test_func_instance)(VkInstance, VkPhysicalDevice), void (*test_func)(VkPhysicalDevice)) { VkPhysicalDevice *vk_physical_devices; VkInstance vk_instance; @@ -445,7 +540,7 @@ static void for_each_device(void (*test_func)(VkPhysicalDevice)) uint32_t count; VkResult vr; - if ((vr = create_instance_skip(0, NULL, &vk_instance)) < 0) + if ((vr = create_instance_skip(extension_count, enabled_extensions, &vk_instance)) < 0) return; ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); @@ -463,13 +558,23 @@ static void for_each_device(void (*test_func)(VkPhysicalDevice)) ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); for (i = 0; i < count; ++i) - test_func(vk_physical_devices[i]); + { + if (test_func_instance) + test_func_instance(vk_instance, vk_physical_devices[i]); + else + test_func(vk_physical_devices[i]); + } heap_free(vk_physical_devices); vkDestroyInstance(vk_instance, NULL); } +static void for_each_device(void (*test_func)(VkPhysicalDevice)) +{ + for_each_device_instance(0, NULL, NULL, test_func); +} + START_TEST(vulkan) { test_instance_version(); @@ -481,4 +586,5 @@ START_TEST(vulkan) test_unsupported_instance_extensions(); for_each_device(test_unsupported_device_extensions); for_each_device(test_private_data); + for_each_device_instance(ARRAY_SIZE(test_null_hwnd_extensions), test_null_hwnd_extensions, test_null_hwnd, NULL); } diff --git a/dlls/winex11.drv/vulkan.c b/dlls/winex11.drv/vulkan.c index 139faf6b407..4ce06f3e9ca 100644 --- a/dlls/winex11.drv/vulkan.c +++ b/dlls/winex11.drv/vulkan.c @@ -62,6 +62,7 @@ struct wine_vk_surface LONG ref; Window window; VkSurfaceKHR surface; /* native surface */ + HWND hwnd; }; typedef struct VkXlibSurfaceCreateInfoKHR @@ -255,14 +256,18 @@ static VkResult X11DRV_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *create_info, const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain) { + struct wine_vk_surface *x11_surface = surface_from_handle(create_info->surface); VkSwapchainCreateInfoKHR create_info_host; TRACE("%p %p %p %p\n", device, create_info, allocator, swapchain); if (allocator) FIXME("Support for allocation callbacks not implemented yet\n"); + if (!x11_surface->hwnd) + return VK_ERROR_SURFACE_LOST_KHR; + create_info_host = *create_info; - create_info_host.surface = surface_from_handle(create_info->surface)->surface; + create_info_host.surface = x11_surface->surface; return pvkCreateSwapchainKHR(device, &create_info_host, NULL /* allocator */, swapchain); } @@ -281,7 +286,7 @@ static VkResult X11DRV_vkCreateWin32SurfaceKHR(VkInstance instance, FIXME("Support for allocation callbacks not implemented yet\n"); /* TODO: support child window rendering. */ - if (GetAncestor(create_info->hwnd, GA_PARENT) != GetDesktopWindow()) + if (create_info->hwnd && GetAncestor(create_info->hwnd, GA_PARENT) != GetDesktopWindow()) { FIXME("Application requires child window rendering, which is not implemented yet!\n"); return VK_ERROR_INCOMPATIBLE_DRIVER; @@ -292,8 +297,10 @@ static VkResult X11DRV_vkCreateWin32SurfaceKHR(VkInstance instance, return VK_ERROR_OUT_OF_HOST_MEMORY; x11_surface->ref = 1; + x11_surface->hwnd = create_info->hwnd; + x11_surface->window = x11_surface->hwnd ? create_client_window(create_info->hwnd, &default_visual) + : create_dummy_client_window(); - x11_surface->window = create_client_window(create_info->hwnd, &default_visual); if (!x11_surface->window) { ERR("Failed to allocate client window for hwnd=%p\n", create_info->hwnd); @@ -316,13 +323,16 @@ static VkResult X11DRV_vkCreateWin32SurfaceKHR(VkInstance instance, goto err; } - EnterCriticalSection(&context_section); - if (!XFindContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char **)&prev)) + if (x11_surface->hwnd) { - wine_vk_surface_release(prev); + EnterCriticalSection(&context_section); + if (!XFindContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char **)&prev)) + { + wine_vk_surface_release(prev); + } + XSaveContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char *)wine_vk_surface_grab(x11_surface)); + LeaveCriticalSection(&context_section); } - XSaveContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char *)wine_vk_surface_grab(x11_surface)); - LeaveCriticalSection(&context_section); *surface = (uintptr_t)x11_surface; @@ -456,6 +466,15 @@ static VkResult X11DRV_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(surface), count, rects); + if (!x11_surface->hwnd) + { + if (rects) + return VK_ERROR_SURFACE_LOST_KHR; + + *count = 1; + return VK_SUCCESS; + } + return pvkGetPhysicalDevicePresentRectanglesKHR(phys_dev, x11_surface->surface, count, rects); } @@ -485,6 +504,9 @@ static VkResult X11DRV_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevic TRACE("%p, 0x%s, %p\n", phys_dev, wine_dbgstr_longlong(surface), capabilities); + if (!x11_surface->hwnd) + return VK_ERROR_SURFACE_LOST_KHR; + return pvkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev, x11_surface->surface, capabilities); } diff --git a/dlls/winex11.drv/window.c b/dlls/winex11.drv/window.c index baaa30d74e3..1f0d636a142 100644 --- a/dlls/winex11.drv/window.c +++ b/dlls/winex11.drv/window.c @@ -1466,6 +1466,26 @@ static Window get_dummy_parent(void) } +/********************************************************************** + * create_dummy_window + */ +Window create_dummy_client_window(void) +{ + XSetWindowAttributes attr; + + attr.colormap = default_colormap; + attr.bit_gravity = NorthWestGravity; + attr.win_gravity = NorthWestGravity; + attr.backing_store = NotUseful; + attr.border_pixel = 0; + + return XCreateWindow( gdi_display, + get_dummy_parent(), + 0, 0, 1, 1, 0, default_visual.depth, InputOutput, + default_visual.visual, CWBitGravity | CWWinGravity | + CWBackingStore | CWColormap | CWBorderPixel, &attr ); +} + /********************************************************************** * create_client_window */ diff --git a/dlls/winex11.drv/x11drv.h b/dlls/winex11.drv/x11drv.h index 45855976607..2362dfd9563 100644 --- a/dlls/winex11.drv/x11drv.h +++ b/dlls/winex11.drv/x11drv.h @@ -601,6 +601,7 @@ extern void update_user_time( Time time ) DECLSPEC_HIDDEN; extern void read_net_wm_states( Display *display, struct x11drv_win_data *data ) DECLSPEC_HIDDEN; extern void update_net_wm_states( struct x11drv_win_data *data ) DECLSPEC_HIDDEN; extern void make_window_embedded( struct x11drv_win_data *data ) DECLSPEC_HIDDEN; +extern Window create_dummy_client_window(void) DECLSPEC_HIDDEN; extern Window create_client_window( HWND hwnd, const XVisualInfo *visual ) DECLSPEC_HIDDEN; extern void set_window_visual( struct x11drv_win_data *data, const XVisualInfo *vis, BOOL use_alpha ) DECLSPEC_HIDDEN; extern void change_systray_owner( Display *display, Window systray_window ) DECLSPEC_HIDDEN; -- 2.31.1

3 8

[PATCH] comctl32/listview: Initialize marqueeRect from left-click coordinates before starting a marquee highlight
by Hugh McMaster 03 May '21

03 May '21

The infoPtr->marqueeRect structure is not currently initialized before the marquee highlight sequence starts, resulting in the RECT having initial coordinates of (0,0)-(0,0). These coordinates cause the first item in the listview control to be identified as being within the range of the marqueeRect's coordinates. That item is then set to LVIS_SELECTED even though it is not part of the marquee selection. Signed-off-by: Hugh McMaster <hugh.mcmaster(a)outlook.com> --- dlls/comctl32/listview.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/comctl32/listview.c b/dlls/comctl32/listview.c index 799ec509f33..7d2b7874b84 100644 --- a/dlls/comctl32/listview.c +++ b/dlls/comctl32/listview.c @@ -4113,6 +4113,7 @@ static LRESULT LISTVIEW_MouseMove(LISTVIEW_INFO *infoPtr, WORD fwKeys, INT x, IN /* Begin selection and capture mouse */ infoPtr->bMarqueeSelect = TRUE; + infoPtr->marqueeRect = rect; SetCapture(infoPtr->hwndSelf); } } -- 2.31.1

2 3

[PATCH] gdi32: Fix typos for GET_DC_PHYSDEV.
by Zhiyi Zhang 03 May '21

03 May '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/gdi32/dibdrv/dc.c | 2 +- dlls/gdi32/enhmfdrv/dc.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/gdi32/dibdrv/dc.c b/dlls/gdi32/dibdrv/dc.c index e8bff37a1bc..7fd404fc2cb 100644 --- a/dlls/gdi32/dibdrv/dc.c +++ b/dlls/gdi32/dibdrv/dc.c @@ -876,7 +876,7 @@ static BOOL CDECL windrv_ArcTo( PHYSDEV dev, INT left, INT top, INT right, INT b BOOL ret; lock_surface( physdev ); - dev = GET_NEXT_PHYSDEV( dev, pArc ); + dev = GET_NEXT_PHYSDEV( dev, pArcTo ); ret = dev->funcs->pArcTo( dev, left, top, right, bottom, xstart, ystart, xend, yend ); unlock_surface( physdev ); return ret; diff --git a/dlls/gdi32/enhmfdrv/dc.c b/dlls/gdi32/enhmfdrv/dc.c index 1c87643ea96..67913f39f0c 100644 --- a/dlls/gdi32/enhmfdrv/dc.c +++ b/dlls/gdi32/enhmfdrv/dc.c @@ -365,7 +365,7 @@ BOOL CDECL EMFDRV_ScaleWindowExtEx( PHYSDEV dev, INT xNum, INT xDenom, INT yNum, DWORD CDECL EMFDRV_SetLayout( PHYSDEV dev, DWORD layout ) { - PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetMapMode ); + PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetLayout ); EMFDRV_PDEVICE *physDev = get_emf_physdev( dev ); EMRSETLAYOUT emr; DWORD ret; -- 2.30.2

2 1

[PATCH] gdi32: Enumerate scalable fonts with zero charset mask as OEM.
by Nikolay Sivov 03 May '21

03 May '21

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51041 Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/gdi32/font.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/gdi32/font.c b/dlls/gdi32/font.c index 067d76ba9fd..5ae80e7b40f 100644 --- a/dlls/gdi32/font.c +++ b/dlls/gdi32/font.c @@ -2818,7 +2818,7 @@ static BOOL enum_face_charsets( const struct gdi_font_family *family, struct gdi for (i = 0; i < count; i++) { - if (!face->scalable && face->fs.fsCsb[0] == 0) /* OEM bitmap */ + if (face->fs.fsCsb[0] == 0) /* OEM */ { elf.elfLogFont.lfCharSet = ntm.ntmTm.tmCharSet = OEM_CHARSET; load_script_name( IDS_OEM_DOS - IDS_FIRST_SCRIPT, elf.elfScript ); -- 2.30.2

2 1

[PATCH v2 1/2] ntdll/tests: Add a test for segment register contents in x86_64 exception handlers.
by Zebediah Figura 01 May '21

01 May '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- v2: Test the contents of %es, %fs, %gs as well. dlls/ntdll/tests/exception.c | 40 +++++++++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/dlls/ntdll/tests/exception.c b/dlls/ntdll/tests/exception.c index da88ca449fb..7c75606dd32 100644 --- a/dlls/ntdll/tests/exception.c +++ b/dlls/ntdll/tests/exception.c @@ -2812,7 +2812,7 @@ static void test___C_specific_handler(void) /* This is heavily based on the i386 exception tests. */ static const struct exception { - BYTE code[18]; /* asm code */ + BYTE code[40]; /* asm code */ BYTE offset; /* offset of faulting instruction */ BYTE length; /* length of faulting instruction */ NTSTATUS status; /* expected status code */ @@ -2921,6 +2921,34 @@ static const struct exception /* 35 */ { { 0xa3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3 }, /* movl %eax,0xffffffffffffffff; ret */ 0, 9, STATUS_ACCESS_VIOLATION, 2, { 1, 0xffffffffffffffff } }, + + /* test exception with cleared segment registers */ + { { + 0x8c, 0xc0, /* mov %es,%eax */ + 0x50, /* push %rax */ + 0x8c, 0xd8, /* mov %ds,%eax */ + 0x50, /* push %rax */ + 0x8c, 0xe0, /* mov %fs,%eax */ + 0x50, /* push %rax */ + 0x8c, 0xe8, /* mov %gs,%eax */ + 0x50, /* push %rax */ + 0x31, 0xc0, /* xor %eax,%eax */ + 0x8e, 0xc0, /* mov %eax,%es */ + 0x8e, 0xd8, /* mov %eax,%ds */ + 0x8e, 0xe0, /* mov %eax,%fs */ + 0x8e, 0xe8, /* mov %eax,%gs */ + 0xfa, /* cli */ + 0x58, /* pop %rax */ + 0x8e, 0xe8, /* mov %eax,%gs */ + 0x58, /* pop %rax */ + 0x8e, 0xe0, /* mov %eax,%fs */ + 0x58, /* pop %rax */ + 0x8e, 0xd8, /* mov %eax,%ds */ + 0x58, /* pop %rax */ + 0x8e, 0xc0, /* mov %eax,%es */ + 0xc3, /* retq */ + }, 22, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 }, + { { 0xf1, 0x90, 0xc3 }, /* icebp; nop; ret */ 1, 1, STATUS_SINGLE_STEP, 0 }, { { 0xcd, 0x2c, 0xc3 }, @@ -2992,6 +3020,16 @@ static DWORD WINAPI handler( EXCEPTION_RECORD *rec, ULONG64 frame, "%u: Unexpected exception address %p/%p\n", entry, rec->ExceptionAddress, (char*)context->Rip ); + todo_wine ok( context->SegDs == context->SegSs, + "%u: ds %#x does not match ss %#x\n", entry, context->SegDs, context->SegSs ); + todo_wine ok( context->SegEs == context->SegSs, + "%u: es %#x does not match ss %#x\n", entry, context->SegEs, context->SegSs ); + todo_wine ok( context->SegGs == context->SegSs, + "%u: ds %#x does not match ss %#x\n", entry, context->SegGs, context->SegSs ); + + todo_wine ok( context->SegFs && context->SegFs != context->SegSs, + "%u: got fs %#x\n", entry, context->SegFs ); + if (except->status == STATUS_BREAKPOINT && is_wow64) parameter_count = 1; else if (except->alt_status == 0 || rec->ExceptionCode != except->alt_status) -- 2.30.2

4 6

[PATCH v2 1/4] ntoskrnl: Remove the device from the root device list in IRP_MN_REMOVE_DEVICE.
by Zebediah Figura 01 May '21

01 May '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- v2: No changes. dlls/ntoskrnl.exe/pnp.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/dlls/ntoskrnl.exe/pnp.c b/dlls/ntoskrnl.exe/pnp.c index 0d9d816e3c0..095344b1073 100644 --- a/dlls/ntoskrnl.exe/pnp.c +++ b/dlls/ntoskrnl.exe/pnp.c @@ -955,10 +955,13 @@ static NTSTATUS WINAPI pnp_manager_device_pnp( DEVICE_OBJECT *device, IRP *irp ) break; case IRP_MN_START_DEVICE: case IRP_MN_SURPRISE_REMOVAL: - case IRP_MN_REMOVE_DEVICE: /* Nothing to do. */ irp->IoStatus.u.Status = STATUS_SUCCESS; break; + case IRP_MN_REMOVE_DEVICE: + list_remove( &root_device->entry ); + irp->IoStatus.u.Status = STATUS_SUCCESS; + break; case IRP_MN_QUERY_CAPABILITIES: irp->IoStatus.u.Status = STATUS_SUCCESS; break; -- 2.30.2

3 5

[PATCH v3] mountmgr.sys: Implement StorageDeviceSeekPenaltyProperty
by David Koolhoven 01 May '21

01 May '21

Allows programs to query if disk has a seek penalty. Signed-off-by: David Koolhoven <david(a)koolhoven-home.net> --- v3: Linux side/sysfs logic is contained file. --- dlls/mountmgr.sys/Makefile.in | 1 + dlls/mountmgr.sys/device.c | 24 +++ dlls/mountmgr.sys/unix/device_seek_penalty.c | 145 +++++++++++++++++++ include/ntddstor.h | 9 +- 4 files changed, 178 insertions(+), 1 deletion(-) create mode 100644 dlls/mountmgr.sys/unix/device_seek_penalty.c diff --git a/dlls/mountmgr.sys/Makefile.in b/dlls/mountmgr.sys/Makefile.in index 83204e66504..61b462ddd7b 100644 --- a/dlls/mountmgr.sys/Makefile.in +++ b/dlls/mountmgr.sys/Makefile.in @@ -7,6 +7,7 @@ EXTRALIBS = $(DISKARBITRATION_LIBS) $(SYSTEMCONFIGURATION_LIBS) $(CORESERVICES_L C_SRCS = \ dbus.c \ + unix/device_seek_penalty.c \ device.c \ diskarb.c \ mountmgr.c diff --git a/dlls/mountmgr.sys/device.c b/dlls/mountmgr.sys/device.c index 04e8fe3c0f5..90c73b13139 100644 --- a/dlls/mountmgr.sys/device.c +++ b/dlls/mountmgr.sys/device.c @@ -1894,6 +1894,30 @@ static NTSTATUS query_property( struct disk_device *device, IRP *irp ) break; } + case StorageDeviceSeekPenaltyProperty: + { + DEVICE_SEEK_PENALTY_DESCRIPTOR *descriptor; + int ret; + + memset( irp->AssociatedIrp.SystemBuffer, 0, irpsp->Parameters.DeviceIoControl.OutputBufferLength ); + descriptor = irp->AssociatedIrp.SystemBuffer; + descriptor->Version = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + descriptor->Size = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + irp->IoStatus.Information = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + + ret = device_seek_penalty(device->unix_mount); + if (ret < 0) { + FIXME( "Unsupported property StorageDeviceSeekPenalty\n" ); + status = STATUS_NOT_SUPPORTED; + } else if (ret == 0) { + descriptor->IncursSeekPenalty = FALSE; + status = STATUS_SUCCESS; + } else if (ret == 1) { + descriptor->IncursSeekPenalty = TRUE; + status = STATUS_SUCCESS; + } + break; + } default: FIXME( "Unsupported property %#x\n", query->PropertyId ); status = STATUS_NOT_SUPPORTED; diff --git a/dlls/mountmgr.sys/unix/device_seek_penalty.c b/dlls/mountmgr.sys/unix/device_seek_penalty.c new file mode 100644 index 00000000000..eefb4d67e65 --- /dev/null +++ b/dlls/mountmgr.sys/unix/device_seek_penalty.c @@ -0,0 +1,145 @@ +/* + * System information APIs + * + * Copyright 1996-1998 Marcus Meissner + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "config.h" +#include "wine/port.h" + +#ifdef linux +#include <assert.h> +#include <errno.h> +#include <stdarg.h> +#include <stdio.h> +#include <sys/stat.h> +#include <sys/sysmacros.h> + +#define NONAMELESSUNION +#include "ntstatus.h" +#include "mountmgr.h" +#define WIN32_NO_STATUS +#include "windef.h" +#include "winternl.h" +#endif +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(mountmgr); + +int device_seek_penalty (char *unix_mount) +{ +#ifdef linux + FILE *fp; + char isrotapathstr[260]; + char evpath[260]; + char ueventbufstr[260]; + char isrotastrbuf[2]; + char *fgetsret = NULL; + int ret = 0; + char *rptr = NULL; + char *sptr = NULL; + char *devstr_edited = NULL; + char mountpath[260]; + char *part_dev = NULL; + int c = 0; + struct stat statbuf; + int seekpen; + + const char *home = getenv( "HOME" ); + const char *prefix = getenv( "WINEPREFIX" ); + size_t len = (prefix ? strlen(prefix) : strlen(home) + strlen("/.wine")) + sizeof("/dosdevices/com256"); + char *path = HeapAlloc( GetProcessHeap(), 0, len ); + + if (path) + { + if (prefix) strcpy( path, prefix ); + else + { + strcpy( path, home ); + strcat( path, "/.wine" ); + } + strcat( path, "/dosdevices/" ); + } + + if (!unix_mount) { + return -1; + } + + snprintf (mountpath, 260, "%s%s", path, unix_mount); + ret = stat (mountpath, &statbuf); + if (ret == -1) { + return -1; + } + HeapFree( GetProcessHeap(), 0, path ); + sprintf (evpath, "/sys/dev/block/%d:%d/uevent", major(statbuf.st_dev), minor(statbuf.st_dev)); + fp = fopen(evpath, "r"); + if (!fp) { + return -1; + } + while ((rptr = fgets (ueventbufstr, 260, fp))) { + sptr = strstr (rptr, "DEVNAME="); + if (sptr) { + sptr += strlen ("DEVNAME="); + break; + } + } + fclose (fp); + devstr_edited = sptr; + if (!devstr_edited) { + return -1; + } + /* Find first character after forwardslash '/' */ + part_dev = strrchr (devstr_edited, '/'); + if (!part_dev || (part_dev == devstr_edited)) part_dev = devstr_edited; + else part_dev++; + /* Trim off trailing digits and whitespace */ + c = strlen (devstr_edited); + c--; + while ((devstr_edited[c] >= '0' && devstr_edited[c] <= '9') + || (devstr_edited[c] == '\n' || devstr_edited[c] == '\r')) + devstr_edited[c--] = '\0'; + + ret = snprintf (isrotapathstr, 260, "/sys/block/%s/queue/rotational", part_dev); + if (ret < 1 || ret == 260) { + return -1; + } + + fp = fopen(isrotapathstr, "r"); + if (!fp) { + return -1; + } + + fgetsret = fgets(isrotastrbuf, 2, fp); + if (!fgetsret) { + return -1; + } + + fclose (fp); + + if (isrotastrbuf[0] == '1') { + seekpen = 1; + } else if (isrotastrbuf[0] == '0') { + seekpen = 0; + } else { + return -1; + } + + return seekpen; +#else + return -1; +#endif +} diff --git a/include/ntddstor.h b/include/ntddstor.h index b8c4bb73b0d..836def413fe 100644 --- a/include/ntddstor.h +++ b/include/ntddstor.h @@ -214,7 +214,8 @@ typedef enum _STORAGE_QUERY_TYPE { typedef enum _STORAGE_PROPERTY_ID { StorageDeviceProperty = 0, - StorageAdapterProperty + StorageAdapterProperty = 1, + StorageDeviceSeekPenaltyProperty = 7, } STORAGE_PROPERTY_ID, *PSTORAGE_PROPERTY_ID; typedef struct _STORAGE_PROPERTY_QUERY { @@ -272,6 +273,12 @@ typedef struct _STORAGE_ADAPTER_DESCRIPTOR { USHORT BusMinorVersion; } STORAGE_ADAPTER_DESCRIPTOR, *PSTORAGE_ADAPTER_DESCRIPTOR; +typedef struct _DEVICE_SEEK_PENALTY_DESCRIPTOR { + ULONG Version; + ULONG Size; + BOOLEAN IncursSeekPenalty; +} DEVICE_SEEK_PENALTY_DESCRIPTOR, *PDEVICE_SEEK_PENALTY_DESCRIPTOR; + #ifdef __cplusplus } #endif -- 2.19.1

2 3

[PATCH 03/12] msvcrt: Implement lrint using rint function.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 9 ++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 8 insertions(+), 16 deletions(-)

3 2

[PATCH 5/5] msvcrt: Fix _unDName crash when demangling class function pointer.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/tests/cpp.c | 2 ++ dlls/msvcrt/undname.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-)

1 0

[PATCH 4/5] msvcrt/tests: Cleanup datatype demangle tests.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/tests/cpp.c | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-)

1 0

[PATCH 3/5] msvcrt/tests: Remove strcmp_space helper.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/tests/cpp.c | 27 ++++----------------------- 1 file changed, 4 insertions(+), 23 deletions(-)

1 0

[PATCH 2/5] msvcrt/tests: Remove old versions workarounds from RTTI tests.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/tests/cpp.c | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-)

1 0

[PATCH 1/5] msvcrt/tests: Link to malloc/free functions in cpp tests.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/tests/cpp.c | 35 ++++++++++------------------------- 1 file changed, 10 insertions(+), 25 deletions(-)

1 0

[PATCH v3 1/5] ws2_32/tests: Add some tests for bind().
by Zebediah Figura 30 Apr '21

30 Apr '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ws2_32/tests/sock.c | 66 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/dlls/ws2_32/tests/sock.c b/dlls/ws2_32/tests/sock.c index 5bd18586e51..9cf271d0fea 100644 --- a/dlls/ws2_32/tests/sock.c +++ b/dlls/ws2_32/tests/sock.c @@ -8373,6 +8373,71 @@ static void test_wsaioctl(void) closesocket(s); } +static void test_bind(void) +{ + const struct sockaddr_in invalid_addr = {.sin_family = AF_INET, .sin_addr.s_addr = inet_addr("192.0.2.0")}; + const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)}; + struct sockaddr addr; + SOCKET s, s2; + int ret, len; + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + + WSASetLastError(0xdeadbeef); + ret = bind(s, NULL, 0); + ok(ret == -1, "expected failure\n"); + todo_wine ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError()); + + addr.sa_family = 0xdead; + WSASetLastError(0xdeadbeef); + ret = bind(s, &addr, sizeof(addr)); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr) - 1); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr)); + ok(ret == -1, "expected failure\n"); + todo_wine ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(!ret, "expected success\n"); + ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError()); + + len = sizeof(addr); + ret = getsockname(s, &addr, &len); + ok(!ret, "got error %u\n", WSAGetLastError()); + + s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + + WSASetLastError(0xdeadbeef); + ret = bind(s2, &addr, sizeof(addr)); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEADDRINUSE, "got error %u\n", WSAGetLastError()); + + closesocket(s2); + closesocket(s); + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(!ret, "expected success\n"); + ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError()); + + closesocket(s); +} + START_TEST( sock ) { int i; @@ -8427,6 +8492,7 @@ START_TEST( sock ) test_completion_port(); test_address_list_query(); + test_bind(); /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */ test_send(); -- 2.30.2

3 6

[PATCH] kernel32/tests: Fix test_GlobalMemoryStatus() for Win up to 8.1 and RAM size above 4GB.
by Paul Gofman 30 Apr '21

30 Apr '21

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- See https://www.winehq.org/pipermail/wine-devel/2021-April/185972.html. dlls/kernel32/tests/heap.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/dlls/kernel32/tests/heap.c b/dlls/kernel32/tests/heap.c index 0a4e3367f60..8558bd7f1b3 100644 --- a/dlls/kernel32/tests/heap.c +++ b/dlls/kernel32/tests/heap.c @@ -1223,9 +1223,9 @@ static BOOL compare_ulong64(ULONG64 v1, ULONG64 v2, ULONG64 max_diff) static void test_GlobalMemoryStatus(void) { static const ULONG64 max_diff = 0x200000; + SIZE_T size, size_broken; MEMORYSTATUSEX memex; MEMORYSTATUS mem; - SIZE_T size; mem.dwLength = sizeof(mem); GlobalMemoryStatus(&mem); @@ -1236,10 +1236,16 @@ static void test_GlobalMemoryStatus(void) * GlobalMemoryStatus() and GlobalMemoryStatusEx() calls. */ size = min(memex.ullTotalPhys, ~(SIZE_T)0 >> 1); - ok(compare_ulong64(mem.dwTotalPhys, size, max_diff), "Got unexpected dwTotalPhys %s, size %s.\n", + size_broken = min(memex.ullTotalPhys, ~(SIZE_T)0); + ok(compare_ulong64(mem.dwTotalPhys, size, max_diff) + || broken(compare_ulong64(mem.dwTotalPhys, size_broken, max_diff)) /* Win <= 8.1 with RAM size > 4GB */, + "Got unexpected dwTotalPhys %s, size %s.\n", wine_dbgstr_longlong(mem.dwTotalPhys), wine_dbgstr_longlong(size)); size = min(memex.ullAvailPhys, ~(SIZE_T)0 >> 1); - ok(compare_ulong64(mem.dwAvailPhys, size, max_diff), "Got unexpected dwAvailPhys %s, size %s.\n", + size_broken = min(memex.ullAvailPhys, ~(SIZE_T)0); + ok(compare_ulong64(mem.dwAvailPhys, size, max_diff) + || broken(compare_ulong64(mem.dwAvailPhys, size_broken, max_diff)) /* Win <= 8.1 with RAM size > 4GB */, + "Got unexpected dwAvailPhys %s, size %s.\n", wine_dbgstr_longlong(mem.dwAvailPhys), wine_dbgstr_longlong(size)); size = min(memex.ullTotalPageFile, ~(SIZE_T)0); -- 2.31.1

1 0

[PATCH v2] kernel32: Do not impose 32 bit limits on Win64 in GlobalMemoryStatus().
by Paul Gofman 30 Apr '21

30 Apr '21

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- v2: - fix random test failures which are due to exact available memory sizes changing between GlobalMemoryStatus() and GlobalMemoryStatusEx() calls (by performing approximate comparison). Fixes computer configuration detection in Forza Horizon 4 (avoids the complain about the system falling below minimum requirements). dlls/kernel32/heap.c | 7 +++--- dlls/kernel32/tests/heap.c | 46 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+), 3 deletions(-) diff --git a/dlls/kernel32/heap.c b/dlls/kernel32/heap.c index b7bd6f5f91d..c8ae9f5a943 100644 --- a/dlls/kernel32/heap.c +++ b/dlls/kernel32/heap.c @@ -44,6 +44,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(globalmem); static HANDLE systemHeap; /* globally shared heap */ +static BOOL is_win64 = sizeof(void *) == 8; /*********************************************************************** * HEAP_CreateSystemHeap @@ -561,7 +562,7 @@ VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer ) osver.dwOSVersionInfoSize = sizeof(osver); GetVersionExW(&osver); - if ( osver.dwMajorVersion >= 5 || osver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS ) + if ( !is_win64 && (osver.dwMajorVersion >= 5 || osver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) ) { lpBuffer->dwTotalPhys = min( memstatus.ullTotalPhys, MAXDWORD ); lpBuffer->dwAvailPhys = min( memstatus.ullAvailPhys, MAXDWORD ); @@ -572,7 +573,7 @@ VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer ) lpBuffer->dwAvailVirtual = min( memstatus.ullAvailVirtual, MAXDWORD ); } - else /* duplicate NT bug */ + else /* 64 bit case, or duplicate NT bug */ { lpBuffer->dwTotalPhys = memstatus.ullTotalPhys; lpBuffer->dwAvailPhys = memstatus.ullAvailPhys; @@ -593,7 +594,7 @@ VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer ) } /* work around for broken photoshop 4 installer */ - if ( lpBuffer->dwAvailPhys + lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024) + if ( !is_win64 && lpBuffer->dwAvailPhys + lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024 ) lpBuffer->dwAvailPageFile = 2U*1024*1024*1024 - lpBuffer->dwAvailPhys - 1; /* limit page file size for really old binaries */ diff --git a/dlls/kernel32/tests/heap.c b/dlls/kernel32/tests/heap.c index fa372b14e21..0a4e3367f60 100644 --- a/dlls/kernel32/tests/heap.c +++ b/dlls/kernel32/tests/heap.c @@ -1213,6 +1213,51 @@ static void test_GetPhysicallyInstalledSystemMemory(void) "expected total_memory >= memstatus.ullTotalPhys / 1024\n"); } +static BOOL compare_ulong64(ULONG64 v1, ULONG64 v2, ULONG64 max_diff) +{ + ULONG64 diff = v1 > v2 ? v1 - v2 : v2 - v1; + + return diff <= max_diff; +} + +static void test_GlobalMemoryStatus(void) +{ + static const ULONG64 max_diff = 0x200000; + MEMORYSTATUSEX memex; + MEMORYSTATUS mem; + SIZE_T size; + + mem.dwLength = sizeof(mem); + GlobalMemoryStatus(&mem); + memex.dwLength = sizeof(memex); + GlobalMemoryStatusEx(&memex); + + /* Compare values approximately as the available memory may change between + * GlobalMemoryStatus() and GlobalMemoryStatusEx() calls. */ + + size = min(memex.ullTotalPhys, ~(SIZE_T)0 >> 1); + ok(compare_ulong64(mem.dwTotalPhys, size, max_diff), "Got unexpected dwTotalPhys %s, size %s.\n", + wine_dbgstr_longlong(mem.dwTotalPhys), wine_dbgstr_longlong(size)); + size = min(memex.ullAvailPhys, ~(SIZE_T)0 >> 1); + ok(compare_ulong64(mem.dwAvailPhys, size, max_diff), "Got unexpected dwAvailPhys %s, size %s.\n", + wine_dbgstr_longlong(mem.dwAvailPhys), wine_dbgstr_longlong(size)); + + size = min(memex.ullTotalPageFile, ~(SIZE_T)0); + ok(compare_ulong64(mem.dwTotalPageFile, size, max_diff), + "Got unexpected dwTotalPageFile %s, size %s.\n", + wine_dbgstr_longlong(mem.dwTotalPageFile), wine_dbgstr_longlong(size)); + size = min(memex.ullAvailPageFile, ~(SIZE_T)0); + ok(compare_ulong64(mem.dwAvailPageFile, size, max_diff), "Got unexpected dwAvailPageFile %s, size %s.\n", + wine_dbgstr_longlong(mem.dwAvailPageFile), wine_dbgstr_longlong(size)); + + ok(compare_ulong64(mem.dwTotalVirtual, memex.ullTotalVirtual, max_diff), + "Got unexpected dwTotalVirtual %s, ullTotalVirtual %s.\n", + wine_dbgstr_longlong(mem.dwTotalVirtual), wine_dbgstr_longlong(memex.ullTotalVirtual)); + ok(compare_ulong64(mem.dwAvailVirtual, memex.ullAvailVirtual, max_diff), + "Got unexpected dwAvailVirtual %s, ullAvailVirtual %s.\n", + wine_dbgstr_longlong(mem.dwAvailVirtual), wine_dbgstr_longlong(memex.ullAvailVirtual)); +} + START_TEST(heap) { int argc; @@ -1246,6 +1291,7 @@ START_TEST(heap) test_HeapQueryInformation(); test_GetPhysicallyInstalledSystemMemory(); + test_GlobalMemoryStatus(); if (pRtlGetNtGlobalFlags) { -- 2.30.2

3 2

[PATCH] msvcirt: No longer prefer native.
by Gijs Vermeulen 30 Apr '21

30 Apr '21

Signed-off-by: Gijs Vermeulen <gijsvrm(a)gmail.com> --- dlls/msvcirt/Makefile.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/msvcirt/Makefile.in b/dlls/msvcirt/Makefile.in index 1dee2b24c02..619a3dd66dd 100644 --- a/dlls/msvcirt/Makefile.in +++ b/dlls/msvcirt/Makefile.in @@ -3,7 +3,7 @@ EXTRADEFS = -D_MSVCIRT PARENTSRC = ../msvcp90 IMPORTS = msvcrt -EXTRADLLFLAGS = -mno-cygwin -Wb,--prefer-native +EXTRADLLFLAGS = -mno-cygwin C_SRCS = \ exception.c \ -- 2.31.1

2 1

[PATCH v2 1/5] ws2_32/tests: Add some tests for bind().
by Zebediah Figura 30 Apr '21

30 Apr '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ws2_32/tests/sock.c | 66 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/dlls/ws2_32/tests/sock.c b/dlls/ws2_32/tests/sock.c index 5bd18586e51..9cf271d0fea 100644 --- a/dlls/ws2_32/tests/sock.c +++ b/dlls/ws2_32/tests/sock.c @@ -8373,6 +8373,71 @@ static void test_wsaioctl(void) closesocket(s); } +static void test_bind(void) +{ + const struct sockaddr_in invalid_addr = {.sin_family = AF_INET, .sin_addr.s_addr = inet_addr("192.0.2.0")}; + const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)}; + struct sockaddr addr; + SOCKET s, s2; + int ret, len; + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + + WSASetLastError(0xdeadbeef); + ret = bind(s, NULL, 0); + ok(ret == -1, "expected failure\n"); + todo_wine ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError()); + + addr.sa_family = 0xdead; + WSASetLastError(0xdeadbeef); + ret = bind(s, &addr, sizeof(addr)); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr) - 1); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr)); + ok(ret == -1, "expected failure\n"); + todo_wine ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(!ret, "expected success\n"); + ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError()); + + len = sizeof(addr); + ret = getsockname(s, &addr, &len); + ok(!ret, "got error %u\n", WSAGetLastError()); + + s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + + WSASetLastError(0xdeadbeef); + ret = bind(s2, &addr, sizeof(addr)); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEADDRINUSE, "got error %u\n", WSAGetLastError()); + + closesocket(s2); + closesocket(s); + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(!ret, "expected success\n"); + ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError()); + + closesocket(s); +} + START_TEST( sock ) { int i; @@ -8427,6 +8492,7 @@ START_TEST( sock ) test_completion_port(); test_address_list_query(); + test_bind(); /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */ test_send(); -- 2.30.2

2 7

[PATCH 2/2] secur32: Get rid of builtin NTLM support.
by Hans Leidekker 30 Apr '21

30 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/secur32/Makefile.in | 7 +- dlls/secur32/base64_codec.c | 192 ---- dlls/secur32/dispatcher.c | 335 ------ dlls/secur32/hmac_md5.c | 77 -- dlls/secur32/hmac_md5.h | 48 - dlls/secur32/negotiate.c | 13 +- dlls/secur32/ntlm.c | 2029 ----------------------------------- dlls/secur32/secur32_priv.h | 108 -- dlls/secur32/util.c | 187 ---- 9 files changed, 13 insertions(+), 2983 deletions(-) delete mode 100644 dlls/secur32/base64_codec.c delete mode 100644 dlls/secur32/dispatcher.c delete mode 100644 dlls/secur32/hmac_md5.c delete mode 100644 dlls/secur32/hmac_md5.h delete mode 100644 dlls/secur32/ntlm.c delete mode 100644 dlls/secur32/util.c diff --git a/dlls/secur32/Makefile.in b/dlls/secur32/Makefile.in index c9acdee4572..89a7c8bd078 100644 --- a/dlls/secur32/Makefile.in +++ b/dlls/secur32/Makefile.in @@ -1,21 +1,16 @@ MODULE = secur32.dll IMPORTLIB = secur32 -IMPORTS = netapi32 advapi32 +IMPORTS = advapi32 DELAYIMPORTS = crypt32 EXTRAINCL = $(GNUTLS_CFLAGS) EXTRALIBS = $(SECURITY_LIBS) C_SRCS = \ - base64_codec.c \ - dispatcher.c \ - hmac_md5.c \ lsa.c \ negotiate.c \ - ntlm.c \ schannel.c \ schannel_gnutls.c \ schannel_macosx.c \ secur32.c \ thunks.c \ - util.c \ wrapper.c diff --git a/dlls/secur32/base64_codec.c b/dlls/secur32/base64_codec.c deleted file mode 100644 index 9f5eaecc3d4..00000000000 --- a/dlls/secur32/base64_codec.c +++ /dev/null @@ -1,192 +0,0 @@ -/* - * base64 encoder/decoder - * - * Copyright 2005 by Kai Blin - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - */ - -#include "windef.h" -#include "winerror.h" -#include "sspi.h" -#include "wine/debug.h" - -WINE_DEFAULT_DEBUG_CHANNEL(ntlm); - -static const char b64[] = -"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - -SECURITY_STATUS encodeBase64(PBYTE in_buf, int in_len, char* out_buf, - int max_len, int *out_len) -{ - int div, i; - PBYTE d = in_buf; - int bytes = (in_len*8 + 5)/6, pad_bytes = (bytes % 4) ? 4 - (bytes % 4) : 0; - - TRACE("bytes is %d, pad bytes is %d\n", bytes, pad_bytes); - *out_len = bytes + pad_bytes; - - if(bytes + pad_bytes + 1 > max_len) - return SEC_E_BUFFER_TOO_SMALL; - - /* Three bytes of input give 4 chars of output */ - div = in_len / 3; - - i = 0; - while(div > 0) - { - /* first char is the first 6 bits of the first byte*/ - out_buf[i + 0] = b64[ ( d[0] >> 2) & 0x3f ]; - /* second char is the last 2 bits of the first byte and the first 4 - * bits of the second byte */ - out_buf[i + 1] = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)]; - /* third char is the last 4 bits of the second byte and the first 2 - * bits of the third byte */ - out_buf[i + 2] = b64[ ((d[1] << 2) & 0x3c) | (d[2] >> 6 & 0x03)]; - /* fourth char is the remaining 6 bits of the third byte */ - out_buf[i + 3] = b64[ d[2] & 0x3f]; - i += 4; - d += 3; - div--; - } - - switch(pad_bytes) - { - case 1: - /* first char is the first 6 bits of the first byte*/ - out_buf[i + 0] = b64[ ( d[0] >> 2) & 0x3f ]; - /* second char is the last 2 bits of the first byte and the first 4 - * bits of the second byte */ - out_buf[i + 1] = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)]; - /* third char is the last 4 bits of the second byte padded with - * two zeroes */ - out_buf[i + 2] = b64[ ((d[1] << 2) & 0x3c) ]; - /* fourth char is a = to indicate one byte of padding */ - out_buf[i + 3] = '='; - out_buf[i + 4] = 0; - break; - case 2: - /* first char is the first 6 bits of the first byte*/ - out_buf[i + 0] = b64[ ( d[0] >> 2) & 0x3f ]; - /* second char is the last 2 bits of the first byte padded with - * four zeroes*/ - out_buf[i + 1] = b64[ ((d[0] << 4) & 0x30)]; - /* third char is = to indicate padding */ - out_buf[i + 2] = '='; - /* fourth char is = to indicate padding */ - out_buf[i + 3] = '='; - out_buf[i + 4] = 0; - break; - default: - out_buf[i] = 0; - } - - return SEC_E_OK; -} - -static inline BYTE decode(char c) -{ - if( c >= 'A' && c <= 'Z') - return c - 'A'; - if( c >= 'a' && c <= 'z') - return c - 'a' + 26; - if( c >= '0' && c <= '9') - return c - '0' + 52; - if( c == '+') - return 62; - if( c == '/') - return 63; - else - return 64; -} - -SECURITY_STATUS decodeBase64(char *in_buf, int in_len, PBYTE out_buf, - int max_len, int *out_len) -{ - int len = in_len, i; - char *d = in_buf; - int ip0, ip1, ip2, ip3; - - TRACE("in_len: %d\n", in_len); - - if((in_len % 4) != 0) - return SEC_E_INVALID_TOKEN; - - if(in_len > max_len) - return SEC_E_BUFFER_TOO_SMALL; - - i = 0; - while(len > 4) - { - if((ip0 = decode(d[0])) > 63) - return SEC_E_INVALID_TOKEN; - if((ip1 = decode(d[1])) > 63) - return SEC_E_INVALID_TOKEN; - if((ip2 = decode(d[2])) > 63) - return SEC_E_INVALID_TOKEN; - if((ip3 = decode(d[3])) > 63) - return SEC_E_INVALID_TOKEN; - - out_buf[i + 0] = (ip0 << 2) | (ip1 >> 4); - out_buf[i + 1] = (ip1 << 4) | (ip2 >> 2); - out_buf[i + 2] = (ip2 << 6) | ip3; - len -= 4; - i += 3; - d += 4; - } - - if(d[2] == '=') - { - if((ip0 = decode(d[0])) > 63) - return SEC_E_INVALID_TOKEN; - if((ip1 = decode(d[1])) > 63) - return SEC_E_INVALID_TOKEN; - - out_buf[i] = (ip0 << 2) | (ip1 >> 4); - i++; - } - else if(d[3] == '=') - { - if((ip0 = decode(d[0])) > 63) - return SEC_E_INVALID_TOKEN; - if((ip1 = decode(d[1])) > 63) - return SEC_E_INVALID_TOKEN; - if((ip2 = decode(d[2])) > 63) - return SEC_E_INVALID_TOKEN; - - out_buf[i + 0] = (ip0 << 2) | (ip1 >> 4); - out_buf[i + 1] = (ip1 << 4) | (ip2 >> 2); - i += 2; - } - else - { - if((ip0 = decode(d[0])) > 63) - return SEC_E_INVALID_TOKEN; - if((ip1 = decode(d[1])) > 63) - return SEC_E_INVALID_TOKEN; - if((ip2 = decode(d[2])) > 63) - return SEC_E_INVALID_TOKEN; - if((ip3 = decode(d[3])) > 63) - return SEC_E_INVALID_TOKEN; - - - out_buf[i + 0] = (ip0 << 2) | (ip1 >> 4); - out_buf[i + 1] = (ip1 << 4) | (ip2 >> 2); - out_buf[i + 2] = (ip2 << 6) | ip3; - i += 3; - } - *out_len = i; - return SEC_E_OK; -} diff --git a/dlls/secur32/dispatcher.c b/dlls/secur32/dispatcher.c deleted file mode 100644 index 0871576848e..00000000000 --- a/dlls/secur32/dispatcher.c +++ /dev/null @@ -1,335 +0,0 @@ -/* - * Copyright 2005, 2006 Kai Blin - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - * - * A dispatcher to run ntlm_auth for wine's sspi module. - */ - -#include "config.h" -#include "wine/port.h" -#include <stdarg.h> -#include <stdio.h> -#ifdef HAVE_UNISTD_H -#include <unistd.h> -#endif -#include <sys/types.h> -#ifdef HAVE_SYS_WAIT_H -#include <sys/wait.h> -#endif -#include <errno.h> -#include <stdlib.h> -#include <fcntl.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" -#include "sspi.h" -#include "secur32_priv.h" -#include "wine/debug.h" - -#define INITIAL_BUFFER_SIZE 200 - -WINE_DEFAULT_DEBUG_CHANNEL(ntlm); - -SECURITY_STATUS fork_helper(PNegoHelper *new_helper, const char *prog, - char* const argv[]) -{ -#ifdef HAVE_FORK - int pipe_in[2]; - int pipe_out[2]; - int i; - PNegoHelper helper; - - TRACE("%s ", debugstr_a(prog)); - for(i = 0; argv[i] != NULL; ++i) - { - TRACE("%s ", debugstr_a(argv[i])); - } - TRACE("\n"); - -#ifdef HAVE_PIPE2 - if (pipe2( pipe_in, O_CLOEXEC ) < 0 ) -#endif - { - if( pipe(pipe_in) < 0 ) return SEC_E_INTERNAL_ERROR; - fcntl( pipe_in[0], F_SETFD, FD_CLOEXEC ); - fcntl( pipe_in[1], F_SETFD, FD_CLOEXEC ); - } -#ifdef HAVE_PIPE2 - if (pipe2( pipe_out, O_CLOEXEC ) < 0 ) -#endif - { - if( pipe(pipe_out) < 0 ) - { - close(pipe_in[0]); - close(pipe_in[1]); - return SEC_E_INTERNAL_ERROR; - } - fcntl( pipe_out[0], F_SETFD, FD_CLOEXEC ); - fcntl( pipe_out[1], F_SETFD, FD_CLOEXEC ); - } - - if (!(helper = heap_alloc( sizeof(NegoHelper) ))) - { - close(pipe_in[0]); - close(pipe_in[1]); - close(pipe_out[0]); - close(pipe_out[1]); - return SEC_E_INSUFFICIENT_MEMORY; - } - - helper->helper_pid = fork(); - - if(helper->helper_pid == -1) - { - close(pipe_in[0]); - close(pipe_in[1]); - close(pipe_out[0]); - close(pipe_out[1]); - heap_free( helper ); - return SEC_E_INTERNAL_ERROR; - } - - if(helper->helper_pid == 0) - { - /* We're in the child now */ - dup2(pipe_out[0], 0); - close(pipe_out[0]); - close(pipe_out[1]); - - dup2(pipe_in[1], 1); - close(pipe_in[0]); - close(pipe_in[1]); - - execvp(prog, argv); - - /* Whoops, we shouldn't get here. Big badaboom.*/ - write(STDOUT_FILENO, "BH\n", 3); - _exit(1); - } - else - { - *new_helper = helper; - helper->major = helper->minor = helper->micro = -1; - helper->com_buf = NULL; - helper->com_buf_size = 0; - helper->com_buf_offset = 0; - helper->session_key = NULL; - helper->neg_flags = 0; - helper->crypt.ntlm.a4i = NULL; - helper->crypt.ntlm2.send_a4i = NULL; - helper->crypt.ntlm2.recv_a4i = NULL; - helper->crypt.ntlm2.send_sign_key = NULL; - helper->crypt.ntlm2.send_seal_key = NULL; - helper->crypt.ntlm2.recv_sign_key = NULL; - helper->crypt.ntlm2.recv_seal_key = NULL; - helper->pipe_in = pipe_in[0]; - close(pipe_in[1]); - helper->pipe_out = pipe_out[1]; - close(pipe_out[0]); - } - - return SEC_E_OK; -#else - ERR( "no fork support on this platform\n" ); - return SEC_E_INTERNAL_ERROR; -#endif -} - -static SECURITY_STATUS read_line(PNegoHelper helper, int *offset_len) -{ - char *newline; - int read_size; - - if(helper->com_buf == NULL) - { - TRACE("Creating a new buffer for the helper\n"); - if (!(helper->com_buf = heap_alloc(INITIAL_BUFFER_SIZE))) - return SEC_E_INSUFFICIENT_MEMORY; - - /* Created a new buffer, size is INITIAL_BUFFER_SIZE, offset is 0 */ - helper->com_buf_size = INITIAL_BUFFER_SIZE; - helper->com_buf_offset = 0; - } - - do - { - TRACE("offset = %d, size = %d\n", helper->com_buf_offset, helper->com_buf_size); - if(helper->com_buf_offset + INITIAL_BUFFER_SIZE > helper->com_buf_size) - { - /* increment buffer size in INITIAL_BUFFER_SIZE steps */ - char *buf = heap_realloc(helper->com_buf, helper->com_buf_size + INITIAL_BUFFER_SIZE); - TRACE("Resizing buffer!\n"); - if (!buf) return SEC_E_INSUFFICIENT_MEMORY; - helper->com_buf_size += INITIAL_BUFFER_SIZE; - helper->com_buf = buf; - } - if((read_size = read(helper->pipe_in, helper->com_buf + helper->com_buf_offset, - helper->com_buf_size - helper->com_buf_offset)) <= 0) - { - return SEC_E_INTERNAL_ERROR; - } - - TRACE("read_size = %d, read: %s\n", read_size, - debugstr_a(helper->com_buf + helper->com_buf_offset)); - helper->com_buf_offset += read_size; - newline = memchr(helper->com_buf, '\n', helper->com_buf_offset); - }while(newline == NULL); - - /* Now, if there's a newline character, and we read more than that newline, - * we have to store the offset so we can preserve the additional data.*/ - if( newline != helper->com_buf + helper->com_buf_offset) - { - TRACE("offset_len is calculated from %p - %p\n", - (helper->com_buf + helper->com_buf_offset), newline+1); - /* the length of the offset is the number of chars after the newline */ - *offset_len = (helper->com_buf + helper->com_buf_offset) - (newline + 1); - } - else - { - *offset_len = 0; - } - - *newline = '\0'; - - return SEC_E_OK; -} - -static SECURITY_STATUS preserve_unused(PNegoHelper helper, int offset_len) -{ - TRACE("offset_len = %d\n", offset_len); - - if(offset_len > 0) - { - memmove(helper->com_buf, helper->com_buf + helper->com_buf_offset, - offset_len); - helper->com_buf_offset = offset_len; - } - else - { - helper->com_buf_offset = 0; - } - - TRACE("helper->com_buf_offset was set to: %d\n", helper->com_buf_offset); - return SEC_E_OK; -} - -SECURITY_STATUS run_helper(PNegoHelper helper, char *buffer, - unsigned int max_buflen, int *buflen) -{ - int offset_len; - SECURITY_STATUS sec_status = SEC_E_OK; - - TRACE("In helper: sending %s\n", debugstr_a(buffer)); - - /* buffer + '\n' */ - write(helper->pipe_out, buffer, lstrlenA(buffer)); - write(helper->pipe_out, "\n", 1); - - if((sec_status = read_line(helper, &offset_len)) != SEC_E_OK) - { - return sec_status; - } - - TRACE("In helper: received %s\n", debugstr_a(helper->com_buf)); - *buflen = lstrlenA(helper->com_buf); - - if( *buflen > max_buflen) - { - ERR("Buffer size too small(%d given, %d required) dropping data!\n", - max_buflen, *buflen); - return SEC_E_BUFFER_TOO_SMALL; - } - - if( *buflen < 2 ) - { - return SEC_E_ILLEGAL_MESSAGE; - } - - /* We only get ERR if the input size is too big. On a GENSEC error, - * ntlm_auth will return BH */ - if(strncmp(helper->com_buf, "ERR", 3) == 0) - { - return SEC_E_INVALID_TOKEN; - } - - memcpy(buffer, helper->com_buf, *buflen+1); - - sec_status = preserve_unused(helper, offset_len); - - return sec_status; -} - -void cleanup_helper(PNegoHelper helper) -{ - - TRACE("Killing helper %p\n", helper); - if(helper == NULL) - return; - - heap_free(helper->com_buf); - heap_free(helper->session_key); - - /* closing stdin will terminate ntlm_auth */ - close(helper->pipe_out); - close(helper->pipe_in); - -#ifdef HAVE_FORK - if (helper->helper_pid > 0) /* reap child */ - { - pid_t wret; - do { - wret = waitpid(helper->helper_pid, NULL, 0); - } while (wret < 0 && errno == EINTR); - } -#endif - - heap_free(helper); -} - -void check_version(PNegoHelper helper) -{ - char temp[80]; - char *newline; - int major = 0, minor = 0, micro = 0, ret; - - TRACE("Checking version of helper\n"); - if(helper != NULL) - { - int len = read(helper->pipe_in, temp, sizeof(temp)-1); - if (len > 8) - { - if((newline = memchr(temp, '\n', len)) != NULL) - *newline = '\0'; - else - temp[len] = 0; - - TRACE("Exact version is %s\n", debugstr_a(temp)); - ret = sscanf(temp, "Version %d.%d.%d", &major, &minor, &micro); - if(ret != 3) - { - ERR("Failed to get the helper version.\n"); - helper->major = helper->minor = helper->micro = -1; - } - else - { - TRACE("Version recognized: %d.%d.%d\n", major, minor, micro); - helper->major = major; - helper->minor = minor; - helper->micro = micro; - } - } - } -} diff --git a/dlls/secur32/hmac_md5.c b/dlls/secur32/hmac_md5.c deleted file mode 100644 index 3479178132d..00000000000 --- a/dlls/secur32/hmac_md5.c +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright 2006 Kai Blin - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - * - * This file implements RFC 2104 (HMAC) for the MD5 provider. - * It is needed for NTLM2 signing and sealing. - */ - -#include "hmac_md5.h" - -void HMACMD5Init(HMAC_MD5_CTX *ctx, const unsigned char *key, unsigned int key_len) -{ - int i; - unsigned char inner_padding[64]; - unsigned char temp_key[16]; - - if(key_len > 64) - { - MD5_CTX temp_ctx; - - MD5Init(&temp_ctx); - MD5Update(&temp_ctx, key, key_len); - MD5Final(&temp_ctx); - memcpy(temp_key, temp_ctx.digest, 16); - - key = temp_key; - key_len = 16; - } - - memset(inner_padding, 0, 64); - memset(ctx->outer_padding, 0, 64); - memcpy(inner_padding, key, key_len); - memcpy(ctx->outer_padding, key, key_len); - - for(i = 0; i < 64; ++i) - { - inner_padding[i] ^= 0x36; - ctx->outer_padding[i] ^= 0x5c; - } - - MD5Init(&(ctx->ctx)); - MD5Update(&(ctx->ctx), inner_padding, 64); -} - -void HMACMD5Update(HMAC_MD5_CTX *ctx, const unsigned char *data, unsigned int data_len) -{ - MD5Update(&(ctx->ctx), data, data_len); -} - -void HMACMD5Final(HMAC_MD5_CTX *ctx, unsigned char *digest) -{ - MD5_CTX outer_ctx; - unsigned char inner_digest[16]; - - MD5Final(&(ctx->ctx)); - memcpy(inner_digest, ctx->ctx.digest, 16); - - MD5Init(&outer_ctx); - MD5Update(&outer_ctx, ctx->outer_padding, 64); - MD5Update(&outer_ctx, inner_digest, 16); - MD5Final(&outer_ctx); - - memcpy(digest, outer_ctx.digest, 16); -} diff --git a/dlls/secur32/hmac_md5.h b/dlls/secur32/hmac_md5.h deleted file mode 100644 index 2bb46dc55ad..00000000000 --- a/dlls/secur32/hmac_md5.h +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright 2006 Kai Blin - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - * - * This file holds the declarations needed for HMAC-MD5. - */ - -#ifndef _HMAC_MD5_H_ -#define _HMAC_MD5_H_ - -#include <string.h> -#include "windef.h" - -typedef struct -{ - unsigned int i[2]; - unsigned int buf[4]; - unsigned char in[64]; - unsigned char digest[16]; -} MD5_CTX; - -typedef struct -{ - MD5_CTX ctx; - unsigned char outer_padding[64]; -} HMAC_MD5_CTX; - -void WINAPI MD5Init( MD5_CTX *ctx ); -void WINAPI MD5Update( MD5_CTX *ctx, const unsigned char *buf, unsigned int len ); -void WINAPI MD5Final( MD5_CTX *ctx ); - -void HMACMD5Init(HMAC_MD5_CTX *ctx, const unsigned char *key, unsigned int key_len) DECLSPEC_HIDDEN; -void HMACMD5Update(HMAC_MD5_CTX *ctx, const unsigned char *data, unsigned int data_len) DECLSPEC_HIDDEN; -void HMACMD5Final(HMAC_MD5_CTX *ctx, unsigned char *digest) DECLSPEC_HIDDEN; -#endif /*_HMAC_MD5_H_*/ diff --git a/dlls/secur32/negotiate.c b/dlls/secur32/negotiate.c index 0df950093e4..6767790d09f 100644 --- a/dlls/secur32/negotiate.c +++ b/dlls/secur32/negotiate.c @@ -58,6 +58,17 @@ struct sec_handle SecHandle handle_ntlm; }; +/* matches layout from msv1_0 */ +struct ntlm_cred +{ + int mode; + char *username_arg; + char *domain_arg; + char *password; + int password_len; + int no_cached_credentials; /* don't try to use cached Samba credentials */ +}; + /*********************************************************************** * AcquireCredentialsHandleW */ @@ -92,7 +103,7 @@ static SECURITY_STATUS SEC_ENTRY nego_AcquireCredentialsHandleW( fCredentialUse, pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument, &cred->handle_ntlm, ptsExpiry ); if (ret == SEC_E_OK) { - NtlmCredentials *ntlm_cred = (NtlmCredentials *)cred->handle_ntlm.dwLower; + struct ntlm_cred *ntlm_cred = (struct ntlm_cred *)cred->handle_ntlm.dwLower; ntlm_cred->no_cached_credentials = (pAuthData == NULL); cred->ntlm = package->provider; } diff --git a/dlls/secur32/ntlm.c b/dlls/secur32/ntlm.c deleted file mode 100644 index 4e3fda3ea98..00000000000 --- a/dlls/secur32/ntlm.c +++ /dev/null @@ -1,2029 +0,0 @@ -/* - * Copyright 2005, 2006 Kai Blin - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - * - * This file implements the NTLM security provider. - */ - -#include <assert.h> -#include <stdarg.h> -#include <stdio.h> -#include "windef.h" -#include "winbase.h" -#include "winnls.h" -#include "wincred.h" -#include "winternl.h" -#include "rpc.h" -#include "sspi.h" -#include "lm.h" -#include "secur32_priv.h" -#include "hmac_md5.h" -#include "wine/unicode.h" -#include "wine/debug.h" - -WINE_DEFAULT_DEBUG_CHANNEL(ntlm); -WINE_DECLARE_DEBUG_CHANNEL(winediag); - -#define NTLM_MAX_BUF 1904 -#define MIN_NTLM_AUTH_MAJOR_VERSION 3 -#define MIN_NTLM_AUTH_MINOR_VERSION 0 -#define MIN_NTLM_AUTH_MICRO_VERSION 25 - -static CHAR ntlm_auth[] = "ntlm_auth"; - -/*********************************************************************** - * QueryCredentialsAttributesA - */ -static SECURITY_STATUS SEC_ENTRY ntlm_QueryCredentialsAttributesA( - PCredHandle phCredential, ULONG ulAttribute, PVOID pBuffer) -{ - SECURITY_STATUS ret; - - TRACE("(%p, %d, %p)\n", phCredential, ulAttribute, pBuffer); - - if(ulAttribute == SECPKG_ATTR_NAMES) - { - FIXME("SECPKG_CRED_ATTR_NAMES: stub\n"); - ret = SEC_E_UNSUPPORTED_FUNCTION; - } - else - ret = SEC_E_UNSUPPORTED_FUNCTION; - - return ret; -} - -/*********************************************************************** - * QueryCredentialsAttributesW - */ -static SECURITY_STATUS SEC_ENTRY ntlm_QueryCredentialsAttributesW( - PCredHandle phCredential, ULONG ulAttribute, PVOID pBuffer) -{ - SECURITY_STATUS ret; - - TRACE("(%p, %d, %p)\n", phCredential, ulAttribute, pBuffer); - - if(ulAttribute == SECPKG_ATTR_NAMES) - { - FIXME("SECPKG_CRED_ATTR_NAMES: stub\n"); - ret = SEC_E_UNSUPPORTED_FUNCTION; - } - else - ret = SEC_E_UNSUPPORTED_FUNCTION; - - return ret; -} - -static char *ntlm_GetUsernameArg(LPCWSTR userW, INT userW_length) -{ - static const char username_arg[] = "--username="; - char *user; - int unixcp_size; - - unixcp_size = WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, - userW, userW_length, NULL, 0, NULL, NULL) + sizeof(username_arg); - if (!(user = heap_alloc(unixcp_size))) return NULL; - memcpy(user, username_arg, sizeof(username_arg) - 1); - WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, userW, userW_length, - user + sizeof(username_arg) - 1, - unixcp_size - sizeof(username_arg) + 1, NULL, NULL); - user[unixcp_size - 1] = '\0'; - return user; -} - -static char *ntlm_GetDomainArg(LPCWSTR domainW, INT domainW_length) -{ - static const char domain_arg[] = "--domain="; - char *domain; - int unixcp_size; - - unixcp_size = WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, - domainW, domainW_length, NULL, 0, NULL, NULL) + sizeof(domain_arg); - if (!(domain = heap_alloc(unixcp_size))) return NULL; - memcpy(domain, domain_arg, sizeof(domain_arg) - 1); - WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, domainW, - domainW_length, domain + sizeof(domain_arg) - 1, - unixcp_size - sizeof(domain) + 1, NULL, NULL); - domain[unixcp_size - 1] = '\0'; - return domain; -} - -/*********************************************************************** - * AcquireCredentialsHandleW - */ -static SECURITY_STATUS SEC_ENTRY ntlm_AcquireCredentialsHandleW( - SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialUse, - PLUID pLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, - PVOID pGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry) -{ - SECURITY_STATUS ret = SEC_E_INSUFFICIENT_MEMORY; - PNtlmCredentials ntlm_cred = NULL; - LPWSTR domain = NULL, user = NULL, password = NULL; - PSEC_WINNT_AUTH_IDENTITY_W auth_data = NULL; - - TRACE("(%s, %s, 0x%08x, %p, %p, %p, %p, %p, %p)\n", - debugstr_w(pszPrincipal), debugstr_w(pszPackage), fCredentialUse, - pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument, phCredential, ptsExpiry); - - switch (fCredentialUse) - { - case SECPKG_CRED_INBOUND: - if (!(ntlm_cred = heap_alloc(sizeof(*ntlm_cred)))) return SEC_E_INSUFFICIENT_MEMORY; - ntlm_cred->mode = NTLM_SERVER; - ntlm_cred->username_arg = NULL; - ntlm_cred->domain_arg = NULL; - ntlm_cred->password = NULL; - ntlm_cred->pwlen = 0; - ntlm_cred->no_cached_credentials = 0; - - phCredential->dwUpper = fCredentialUse; - phCredential->dwLower = (ULONG_PTR)ntlm_cred; - ret = SEC_E_OK; - break; - - case SECPKG_CRED_OUTBOUND: - auth_data = pAuthData; - if (!(ntlm_cred = heap_alloc(sizeof(*ntlm_cred)))) return SEC_E_INSUFFICIENT_MEMORY; - - ntlm_cred->mode = NTLM_CLIENT; - ntlm_cred->username_arg = NULL; - ntlm_cred->domain_arg = NULL; - ntlm_cred->password = NULL; - ntlm_cred->pwlen = 0; - ntlm_cred->no_cached_credentials = 0; - - if (pAuthData) - { - int domain_len = 0, user_len = 0, password_len = 0; - - if (auth_data->Flags & SEC_WINNT_AUTH_IDENTITY_ANSI) - { - if (auth_data->DomainLength) - { - domain_len = MultiByteToWideChar(CP_ACP, 0, (char *)auth_data->Domain, - auth_data->DomainLength, NULL, 0); - if (!(domain = heap_alloc(sizeof(WCHAR) * domain_len))) goto done; - MultiByteToWideChar(CP_ACP, 0, (char *)auth_data->Domain, auth_data->DomainLength, - domain, domain_len); - } - if (auth_data->UserLength) - { - user_len = MultiByteToWideChar(CP_ACP, 0, (char *)auth_data->User, - auth_data->UserLength, NULL, 0); - if (!(user = heap_alloc(sizeof(WCHAR) * user_len))) goto done; - MultiByteToWideChar(CP_ACP, 0, (char *)auth_data->User, auth_data->UserLength, - user, user_len); - } - if (auth_data->PasswordLength) - { - password_len = MultiByteToWideChar(CP_ACP, 0,(char *)auth_data->Password, - auth_data->PasswordLength, NULL, 0); - if (!(password = heap_alloc(sizeof(WCHAR) * password_len))) goto done; - MultiByteToWideChar(CP_ACP, 0, (char *)auth_data->Password, auth_data->PasswordLength, - password, password_len); - } - } - else - { - domain = auth_data->Domain; - domain_len = auth_data->DomainLength; - - user = auth_data->User; - user_len = auth_data->UserLength; - - password = auth_data->Password; - password_len = auth_data->PasswordLength; - } - - TRACE("Username is %s\n", debugstr_wn(user, user_len)); - TRACE("Domain name is %s\n", debugstr_wn(domain, domain_len)); - - ntlm_cred->username_arg = ntlm_GetUsernameArg(user, user_len); - ntlm_cred->domain_arg = ntlm_GetDomainArg(domain, domain_len); - - if (password_len) - { - ntlm_cred->pwlen = WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, password, - password_len, NULL, 0, NULL, NULL); - if (!(ntlm_cred->password = heap_alloc(ntlm_cred->pwlen))) goto done; - WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, password, password_len, - ntlm_cred->password, ntlm_cred->pwlen, NULL, NULL); - } - } - - phCredential->dwUpper = fCredentialUse; - phCredential->dwLower = (ULONG_PTR)ntlm_cred; - TRACE("ACH phCredential->dwUpper: 0x%08lx, dwLower: 0x%08lx\n", phCredential->dwUpper, - phCredential->dwLower); - ret = SEC_E_OK; - break; - - case SECPKG_CRED_BOTH: - FIXME("AcquireCredentialsHandle: SECPKG_CRED_BOTH stub\n"); - ret = SEC_E_UNSUPPORTED_FUNCTION; - break; - - default: - ret = SEC_E_UNKNOWN_CREDENTIALS; - } - -done: - if (auth_data && (auth_data->Flags & SEC_WINNT_AUTH_IDENTITY_ANSI)) - { - heap_free(domain); - heap_free(user); - heap_free(password); - } - if (ret != SEC_E_OK) heap_free( ntlm_cred ); - - return ret; -} - -/*********************************************************************** - * AcquireCredentialsHandleA - */ -static SECURITY_STATUS SEC_ENTRY ntlm_AcquireCredentialsHandleA( - SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialUse, - PLUID pLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, - PVOID pGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry) -{ - SECURITY_STATUS ret = SEC_E_INSUFFICIENT_MEMORY; - int user_sizeW, domain_sizeW, passwd_sizeW; - SEC_WCHAR *user = NULL, *domain = NULL, *passwd = NULL, *package = NULL; - PSEC_WINNT_AUTH_IDENTITY_W pAuthDataW = NULL; - PSEC_WINNT_AUTH_IDENTITY_A id = NULL; - - TRACE("(%s, %s, 0x%08x, %p, %p, %p, %p, %p, %p)\n", - debugstr_a(pszPrincipal), debugstr_a(pszPackage), fCredentialUse, - pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument, phCredential, ptsExpiry); - - if (pszPackage) - { - int package_sizeW = MultiByteToWideChar(CP_ACP, 0, pszPackage, -1, NULL, 0); - if (!(package = heap_alloc(package_sizeW * sizeof(SEC_WCHAR)))) return SEC_E_INSUFFICIENT_MEMORY; - MultiByteToWideChar(CP_ACP, 0, pszPackage, -1, package, package_sizeW); - } - - if (pAuthData) - { - id = pAuthData; - if (id->Flags == SEC_WINNT_AUTH_IDENTITY_ANSI) - { - if (!(pAuthDataW = heap_alloc(sizeof(SEC_WINNT_AUTH_IDENTITY_W)))) goto done; - - if (!id->UserLength) user_sizeW = 0; - else - { - user_sizeW = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)id->User, id->UserLength, NULL, 0); - if (!(user = heap_alloc(user_sizeW * sizeof(SEC_WCHAR)))) goto done; - MultiByteToWideChar(CP_ACP, 0, (LPCSTR)id->User, id->UserLength, user, user_sizeW); - } - - if (!id->DomainLength) domain_sizeW = 0; - else - { - domain_sizeW = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)id->Domain, id->DomainLength, NULL, 0); - if (!(domain = heap_alloc(domain_sizeW * sizeof(SEC_WCHAR)))) goto done; - MultiByteToWideChar(CP_ACP, 0, (LPCSTR)id->Domain, id->DomainLength, domain, domain_sizeW); - } - - if (!id->PasswordLength) passwd_sizeW = 0; - else - { - passwd_sizeW = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)id->Password, id->PasswordLength, NULL, 0); - if (!(passwd = heap_alloc(passwd_sizeW * sizeof(SEC_WCHAR)))) goto done; - MultiByteToWideChar(CP_ACP, 0, (LPCSTR)id->Password, id->PasswordLength, passwd, passwd_sizeW); - } - - pAuthDataW->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE; - pAuthDataW->User = user; - pAuthDataW->UserLength = user_sizeW; - pAuthDataW->Domain = domain; - pAuthDataW->DomainLength = domain_sizeW; - pAuthDataW->Password = passwd; - pAuthDataW->PasswordLength = passwd_sizeW; - } - else pAuthDataW = (PSEC_WINNT_AUTH_IDENTITY_W)id; - } - - ret = ntlm_AcquireCredentialsHandleW(NULL, package, fCredentialUse, - pLogonID, pAuthDataW, pGetKeyFn, pGetKeyArgument, phCredential, - ptsExpiry); - -done: - heap_free(package); - heap_free(user); - heap_free(domain); - heap_free(passwd); - if (pAuthDataW != (PSEC_WINNT_AUTH_IDENTITY_W)id) heap_free(pAuthDataW); - - return ret; -} - -/************************************************************************* - * ntlm_GetTokenBufferIndex - * Calculates the index of the secbuffer with BufferType == SECBUFFER_TOKEN - * Returns index if found or -1 if not found. - */ -static int ntlm_GetTokenBufferIndex(PSecBufferDesc pMessage) -{ - UINT i; - - TRACE("%p\n", pMessage); - - for( i = 0; i < pMessage->cBuffers; ++i ) - { - if(pMessage->pBuffers[i].BufferType == SECBUFFER_TOKEN) - return i; - } - - return -1; -} - -/************************************************************************* - * ntlm_GetDataBufferIndex - * Calculates the index of the first secbuffer with BufferType == SECBUFFER_DATA - * Returns index if found or -1 if not found. - */ -static int ntlm_GetDataBufferIndex(PSecBufferDesc pMessage) -{ - UINT i; - - TRACE("%p\n", pMessage); - - for( i = 0; i < pMessage->cBuffers; ++i ) - { - if(pMessage->pBuffers[i].BufferType == SECBUFFER_DATA) - return i; - } - - return -1; -} - -static BOOL ntlm_GetCachedCredential(const SEC_WCHAR *pszTargetName, PCREDENTIALW *cred) -{ - LPCWSTR p; - LPCWSTR pszHost; - LPWSTR pszHostOnly; - BOOL ret; - - if (!pszTargetName) - return FALSE; - - /* try to get the start of the hostname from service principal name (SPN) */ - pszHost = strchrW(pszTargetName, '/'); - if (pszHost) - { - /* skip slash character */ - pszHost++; - - /* find end of host by detecting start of instance port or start of referrer */ - p = strchrW(pszHost, ':'); - if (!p) - p = strchrW(pszHost, '/'); - if (!p) - p = pszHost + strlenW(pszHost); - } - else /* otherwise not an SPN, just a host */ - { - pszHost = pszTargetName; - p = pszHost + strlenW(pszHost); - } - - if (!(pszHostOnly = heap_alloc((p - pszHost + 1) * sizeof(WCHAR)))) return FALSE; - memcpy(pszHostOnly, pszHost, (p - pszHost) * sizeof(WCHAR)); - pszHostOnly[p - pszHost] = '\0'; - - ret = CredReadW(pszHostOnly, CRED_TYPE_DOMAIN_PASSWORD, 0, cred); - - heap_free(pszHostOnly); - return ret; -} - -/*********************************************************************** - * InitializeSecurityContextW - */ -static SECURITY_STATUS SEC_ENTRY ntlm_InitializeSecurityContextW( - PCredHandle phCredential, PCtxtHandle phContext, SEC_WCHAR *pszTargetName, - ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep, - PSecBufferDesc pInput, ULONG Reserved2, PCtxtHandle phNewContext, - PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry) -{ - SECURITY_STATUS ret; - PNtlmCredentials ntlm_cred; - PNegoHelper helper = NULL; - ULONG ctxt_attr = 0; - char* buffer, *want_flags = NULL; - PBYTE bin; - int buffer_len, bin_len, max_len = NTLM_MAX_BUF; - int token_idx; - SEC_CHAR *username = NULL; - SEC_CHAR *domain = NULL; - SEC_CHAR *password = NULL; - - TRACE("%p %p %s 0x%08x %d %d %p %d %p %p %p %p\n", phCredential, phContext, - debugstr_w(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput, - Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry); - - /**************************************** - * When communicating with the client, there can be the - * following reply packets: - * YR <base64 blob> should be sent to the server - * PW should be sent back to helper with - * base64 encoded password - * AF <base64 blob> client is done, blob should be - * sent to server with KK prefixed - * GF <string list> A string list of negotiated flags - * GK <base64 blob> base64 encoded session key - * BH <char reason> something broke - */ - /* The squid cache size is 2010 chars, and that's what ntlm_auth uses */ - - if(TargetDataRep == SECURITY_NETWORK_DREP){ - TRACE("Setting SECURITY_NETWORK_DREP\n"); - } - - buffer = heap_alloc(sizeof(char) * NTLM_MAX_BUF); - bin = heap_alloc(sizeof(BYTE) * NTLM_MAX_BUF); - - if((phContext == NULL) && (pInput == NULL)) - { - static char helper_protocol[] = "--helper-protocol=ntlmssp-client-1"; - static CHAR credentials_argv[] = "--use-cached-creds"; - SEC_CHAR *client_argv[5]; - int pwlen = 0; - - TRACE("First time in ISC()\n"); - - if(!phCredential) - { - ret = SEC_E_INVALID_HANDLE; - goto isc_end; - } - - /* As the server side of sspi never calls this, make sure that - * the handler is a client handler. - */ - ntlm_cred = (PNtlmCredentials)phCredential->dwLower; - if(ntlm_cred->mode != NTLM_CLIENT) - { - TRACE("Cred mode = %d\n", ntlm_cred->mode); - ret = SEC_E_INVALID_HANDLE; - goto isc_end; - } - - client_argv[0] = ntlm_auth; - client_argv[1] = helper_protocol; - if (!ntlm_cred->username_arg && !ntlm_cred->domain_arg) - { - LPWKSTA_USER_INFO_1 ui = NULL; - NET_API_STATUS status; - PCREDENTIALW cred; - - if (ntlm_GetCachedCredential(pszTargetName, &cred)) - { - LPWSTR p; - p = strchrW(cred->UserName, '\\'); - if (p) - { - domain = ntlm_GetDomainArg(cred->UserName, p - cred->UserName); - p++; - } - else - { - domain = ntlm_GetDomainArg(NULL, 0); - p = cred->UserName; - } - - username = ntlm_GetUsernameArg(p, -1); - - if(cred->CredentialBlobSize != 0) - { - pwlen = WideCharToMultiByte(CP_UNIXCP, - WC_NO_BEST_FIT_CHARS, (LPWSTR)cred->CredentialBlob, - cred->CredentialBlobSize / sizeof(WCHAR), NULL, 0, - NULL, NULL); - - password = heap_alloc(pwlen); - WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, - (LPWSTR)cred->CredentialBlob, - cred->CredentialBlobSize / sizeof(WCHAR), - password, pwlen, NULL, NULL); - } - - CredFree(cred); - - client_argv[2] = username; - client_argv[3] = domain; - client_argv[4] = NULL; - } - else - { - status = NetWkstaUserGetInfo(NULL, 1, (LPBYTE *)&ui); - if (status != NERR_Success || ui == NULL || ntlm_cred->no_cached_credentials) - { - ret = SEC_E_NO_CREDENTIALS; - goto isc_end; - } - username = ntlm_GetUsernameArg(ui->wkui1_username, -1); - NetApiBufferFree(ui); - - TRACE("using cached credentials\n"); - - client_argv[2] = username; - client_argv[3] = credentials_argv; - client_argv[4] = NULL; - } - } - else - { - client_argv[2] = ntlm_cred->username_arg; - client_argv[3] = ntlm_cred->domain_arg; - client_argv[4] = NULL; - } - - if((ret = fork_helper(&helper, ntlm_auth, client_argv)) != SEC_E_OK) - goto isc_end; - - helper->mode = NTLM_CLIENT; - helper->session_key = heap_alloc(16); - if (!helper->session_key) - { - cleanup_helper(helper); - ret = SEC_E_INSUFFICIENT_MEMORY; - goto isc_end; - } - - /* Generate the dummy session key = MD4(MD4(password))*/ - if(password || ntlm_cred->password) - { - SEC_WCHAR *unicode_password; - int passwd_lenW; - - TRACE("Converting password to unicode.\n"); - passwd_lenW = MultiByteToWideChar(CP_ACP, 0, - password ? password : ntlm_cred->password, - password ? pwlen : ntlm_cred->pwlen, - NULL, 0); - unicode_password = heap_alloc(passwd_lenW * sizeof(SEC_WCHAR)); - MultiByteToWideChar(CP_ACP, 0, password ? password : ntlm_cred->password, - password ? pwlen : ntlm_cred->pwlen, unicode_password, passwd_lenW); - - SECUR32_CreateNTLM1SessionKey((PBYTE)unicode_password, - passwd_lenW * sizeof(SEC_WCHAR), helper->session_key); - heap_free(unicode_password); - } - else - memset(helper->session_key, 0, 16); - - /* Allocate space for a maximal string of - * "SF NTLMSSP_FEATURE_SIGN NTLMSSP_FEATURE_SEAL - * NTLMSSP_FEATURE_SESSION_KEY" - */ - if (!(want_flags = heap_alloc(73))) - { - cleanup_helper(helper); - ret = SEC_E_INSUFFICIENT_MEMORY; - goto isc_end; - } - lstrcpyA(want_flags, "SF"); - if(fContextReq & ISC_REQ_CONFIDENTIALITY) - { - if(strstr(want_flags, "NTLMSSP_FEATURE_SEAL") == NULL) - lstrcatA(want_flags, " NTLMSSP_FEATURE_SEAL"); - } - if(fContextReq & ISC_REQ_CONNECTION) - ctxt_attr |= ISC_RET_CONNECTION; - if(fContextReq & ISC_REQ_EXTENDED_ERROR) - ctxt_attr |= ISC_RET_EXTENDED_ERROR; - if(fContextReq & ISC_REQ_INTEGRITY) - { - if(strstr(want_flags, "NTLMSSP_FEATURE_SIGN") == NULL) - lstrcatA(want_flags, " NTLMSSP_FEATURE_SIGN"); - } - if(fContextReq & ISC_REQ_MUTUAL_AUTH) - ctxt_attr |= ISC_RET_MUTUAL_AUTH; - if(fContextReq & ISC_REQ_REPLAY_DETECT) - { - if(strstr(want_flags, "NTLMSSP_FEATURE_SIGN") == NULL) - lstrcatA(want_flags, " NTLMSSP_FEATURE_SIGN"); - } - if(fContextReq & ISC_REQ_SEQUENCE_DETECT) - { - if(strstr(want_flags, "NTLMSSP_FEATURE_SIGN") == NULL) - lstrcatA(want_flags, " NTLMSSP_FEATURE_SIGN"); - } - if(fContextReq & ISC_REQ_STREAM) - FIXME("ISC_REQ_STREAM\n"); - if(fContextReq & ISC_REQ_USE_DCE_STYLE) - ctxt_attr |= ISC_RET_USED_DCE_STYLE; - if(fContextReq & ISC_REQ_DELEGATE) - ctxt_attr |= ISC_RET_DELEGATE; - - /* If no password is given, try to use cached credentials. Fall back to an empty - * password if this failed. */ - if(!password && !ntlm_cred->password) - { - lstrcpynA(buffer, "OK", max_len-1); - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK) - { - cleanup_helper(helper); - goto isc_end; - } - /* If the helper replied with "PW", using cached credentials failed */ - if(!strncmp(buffer, "PW", 2)) - { - TRACE("Using cached credentials failed.\n"); - lstrcpynA(buffer, "PW AA==", max_len-1); - } - else /* Just do a noop on the next run */ - lstrcpynA(buffer, "OK", max_len-1); - } - else - { - lstrcpynA(buffer, "PW ", max_len-1); - if((ret = encodeBase64(password ? (unsigned char *)password : (unsigned char *)ntlm_cred->password, - password ? pwlen : ntlm_cred->pwlen, buffer+3, - max_len-3, &buffer_len)) != SEC_E_OK) - { - cleanup_helper(helper); - goto isc_end; - } - - } - - TRACE("Sending to helper: %s\n", debugstr_a(buffer)); - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK) - { - cleanup_helper(helper); - goto isc_end; - } - - TRACE("Helper returned %s\n", debugstr_a(buffer)); - - if(lstrlenA(want_flags) > 2) - { - TRACE("Want flags are %s\n", debugstr_a(want_flags)); - lstrcpynA(buffer, want_flags, max_len-1); - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) - != SEC_E_OK) - { - cleanup_helper(helper); - goto isc_end; - } - if(!strncmp(buffer, "BH", 2)) - ERR("Helper doesn't understand new command set. Expect more things to fail.\n"); - } - - lstrcpynA(buffer, "YR", max_len-1); - - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK) - { - cleanup_helper(helper); - goto isc_end; - } - - TRACE("%s\n", buffer); - - if(strncmp(buffer, "YR ", 3) != 0) - { - /* Something borked */ - TRACE("Helper returned %c%c\n", buffer[0], buffer[1]); - ret = SEC_E_INTERNAL_ERROR; - cleanup_helper(helper); - goto isc_end; - } - if((ret = decodeBase64(buffer+3, buffer_len-3, bin, - max_len-1, &bin_len)) != SEC_E_OK) - { - cleanup_helper(helper); - goto isc_end; - } - - /* put the decoded client blob into the out buffer */ - - phNewContext->dwUpper = ctxt_attr; - phNewContext->dwLower = (ULONG_PTR)helper; - - ret = SEC_I_CONTINUE_NEEDED; - } - else - { - int input_token_idx; - - /* handle second call here */ - /* encode server data to base64 */ - if (!pInput || ((input_token_idx = ntlm_GetTokenBufferIndex(pInput)) == -1)) - { - ret = SEC_E_INVALID_TOKEN; - goto isc_end; - } - - if(!phContext) - { - ret = SEC_E_INVALID_HANDLE; - goto isc_end; - } - - /* As the server side of sspi never calls this, make sure that - * the handler is a client handler. - */ - helper = (PNegoHelper)phContext->dwLower; - if(helper->mode != NTLM_CLIENT) - { - TRACE("Helper mode = %d\n", helper->mode); - ret = SEC_E_INVALID_HANDLE; - goto isc_end; - } - - if (!pInput->pBuffers[input_token_idx].pvBuffer) - { - ret = SEC_E_INTERNAL_ERROR; - goto isc_end; - } - - if(pInput->pBuffers[input_token_idx].cbBuffer > max_len) - { - TRACE("pInput->pBuffers[%d].cbBuffer is: %d\n", - input_token_idx, - pInput->pBuffers[input_token_idx].cbBuffer); - ret = SEC_E_INVALID_TOKEN; - goto isc_end; - } - else - bin_len = pInput->pBuffers[input_token_idx].cbBuffer; - - memcpy(bin, pInput->pBuffers[input_token_idx].pvBuffer, bin_len); - - lstrcpynA(buffer, "TT ", max_len-1); - - if((ret = encodeBase64(bin, bin_len, buffer+3, - max_len-3, &buffer_len)) != SEC_E_OK) - goto isc_end; - - TRACE("Server sent: %s\n", debugstr_a(buffer)); - - /* send TT base64 blob to ntlm_auth */ - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK) - goto isc_end; - - TRACE("Helper replied: %s\n", debugstr_a(buffer)); - - if( (strncmp(buffer, "KK ", 3) != 0) && - (strncmp(buffer, "AF ", 3) !=0)) - { - TRACE("Helper returned %c%c\n", buffer[0], buffer[1]); - ret = SEC_E_INVALID_TOKEN; - goto isc_end; - } - - /* decode the blob and send it to server */ - if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len, - &bin_len)) != SEC_E_OK) - { - goto isc_end; - } - - phNewContext->dwUpper = ctxt_attr; - phNewContext->dwLower = (ULONG_PTR)helper; - - ret = SEC_E_OK; - } - - /* put the decoded client blob into the out buffer */ - - if (!pOutput || ((token_idx = ntlm_GetTokenBufferIndex(pOutput)) == -1)) - { - TRACE("no SECBUFFER_TOKEN buffer could be found\n"); - ret = SEC_E_BUFFER_TOO_SMALL; - if ((phContext == NULL) && (pInput == NULL)) - { - cleanup_helper(helper); - phNewContext->dwUpper = 0; - phNewContext->dwLower = 0; - } - goto isc_end; - } - - if (fContextReq & ISC_REQ_ALLOCATE_MEMORY) - { - pOutput->pBuffers[token_idx].pvBuffer = heap_alloc(bin_len); - pOutput->pBuffers[token_idx].cbBuffer = bin_len; - } - else if (pOutput->pBuffers[token_idx].cbBuffer < bin_len) - { - TRACE("out buffer is NULL or has not enough space\n"); - ret = SEC_E_BUFFER_TOO_SMALL; - if ((phContext == NULL) && (pInput == NULL)) - { - cleanup_helper(helper); - phNewContext->dwUpper = 0; - phNewContext->dwLower = 0; - } - goto isc_end; - } - - if (!pOutput->pBuffers[token_idx].pvBuffer) - { - TRACE("out buffer is NULL\n"); - ret = SEC_E_INTERNAL_ERROR; - if ((phContext == NULL) && (pInput == NULL)) - { - cleanup_helper(helper); - phNewContext->dwUpper = 0; - phNewContext->dwLower = 0; - } - goto isc_end; - } - - pOutput->pBuffers[token_idx].cbBuffer = bin_len; - memcpy(pOutput->pBuffers[token_idx].pvBuffer, bin, bin_len); - - if(ret == SEC_E_OK) - { - TRACE("Getting negotiated flags\n"); - lstrcpynA(buffer, "GF", max_len - 1); - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK) - goto isc_end; - - if(buffer_len < 3) - { - TRACE("No flags negotiated.\n"); - helper->neg_flags = 0l; - } - else - { - TRACE("Negotiated %s\n", debugstr_a(buffer)); - sscanf(buffer + 3, "%x", &(helper->neg_flags)); - TRACE("Stored 0x%08x as flags\n", helper->neg_flags); - } - - TRACE("Getting session key\n"); - lstrcpynA(buffer, "GK", max_len - 1); - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK) - goto isc_end; - - if(strncmp(buffer, "BH", 2) == 0) - TRACE("No key negotiated.\n"); - else if(strncmp(buffer, "GK ", 3) == 0) - { - if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len, - &bin_len)) != SEC_E_OK) - { - TRACE("Failed to decode session key\n"); - } - TRACE("Session key is %s\n", debugstr_a(buffer+3)); - heap_free(helper->session_key); - if (!(helper->session_key = heap_alloc(bin_len))) - { - ret = SEC_E_INSUFFICIENT_MEMORY; - goto isc_end; - } - memcpy(helper->session_key, bin, bin_len); - } - - helper->crypt.ntlm.a4i = SECUR32_arc4Alloc(); - SECUR32_arc4Init(helper->crypt.ntlm.a4i, helper->session_key, 16); - helper->crypt.ntlm.seq_num = 0l; - SECUR32_CreateNTLM2SubKeys(helper); - helper->crypt.ntlm2.send_a4i = SECUR32_arc4Alloc(); - helper->crypt.ntlm2.recv_a4i = SECUR32_arc4Alloc(); - SECUR32_arc4Init(helper->crypt.ntlm2.send_a4i, - helper->crypt.ntlm2.send_seal_key, 16); - SECUR32_arc4Init(helper->crypt.ntlm2.recv_a4i, - helper->crypt.ntlm2.recv_seal_key, 16); - helper->crypt.ntlm2.send_seq_no = 0l; - helper->crypt.ntlm2.recv_seq_no = 0l; - } - -isc_end: - heap_free(username); - heap_free(domain); - heap_free(password); - heap_free(want_flags); - heap_free(buffer); - heap_free(bin); - return ret; -} - -/*********************************************************************** - * InitializeSecurityContextA - */ -static SECURITY_STATUS SEC_ENTRY ntlm_InitializeSecurityContextA( - PCredHandle phCredential, PCtxtHandle phContext, SEC_CHAR *pszTargetName, - ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep, - PSecBufferDesc pInput,ULONG Reserved2, PCtxtHandle phNewContext, - PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry) -{ - SECURITY_STATUS ret; - SEC_WCHAR *target = NULL; - - TRACE("%p %p %s %d %d %d %p %d %p %p %p %p\n", phCredential, phContext, - debugstr_a(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput, - Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry); - - if (pszTargetName) - { - int target_size = MultiByteToWideChar(CP_ACP, 0, pszTargetName, -1, NULL, 0); - if (!(target = heap_alloc(target_size * sizeof(SEC_WCHAR)))) return SEC_E_INSUFFICIENT_MEMORY; - MultiByteToWideChar(CP_ACP, 0, pszTargetName, -1, target, target_size); - } - - ret = ntlm_InitializeSecurityContextW(phCredential, phContext, target, - fContextReq, Reserved1, TargetDataRep, pInput, Reserved2, - phNewContext, pOutput, pfContextAttr, ptsExpiry); - - heap_free(target); - return ret; -} - -/*********************************************************************** - * AcceptSecurityContext - */ -static SECURITY_STATUS SEC_ENTRY ntlm_AcceptSecurityContext( - PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput, - ULONG fContextReq, ULONG TargetDataRep, PCtxtHandle phNewContext, - PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry) -{ - SECURITY_STATUS ret; - char *buffer, *want_flags = NULL; - PBYTE bin; - int buffer_len, bin_len, max_len = NTLM_MAX_BUF; - ULONG ctxt_attr = 0; - PNegoHelper helper; - PNtlmCredentials ntlm_cred; - - TRACE("%p %p %p %d %d %p %p %p %p\n", phCredential, phContext, pInput, - fContextReq, TargetDataRep, phNewContext, pOutput, pfContextAttr, - ptsExpiry); - - buffer = heap_alloc(sizeof(char) * NTLM_MAX_BUF); - bin = heap_alloc(sizeof(BYTE) * NTLM_MAX_BUF); - - if(TargetDataRep == SECURITY_NETWORK_DREP){ - TRACE("Using SECURITY_NETWORK_DREP\n"); - } - - if(phContext == NULL) - { - static CHAR server_helper_protocol[] = "--helper-protocol=squid-2.5-ntlmssp"; - SEC_CHAR *server_argv[] = { ntlm_auth, - server_helper_protocol, - NULL }; - - if (!phCredential) - { - ret = SEC_E_INVALID_HANDLE; - goto asc_end; - } - - ntlm_cred = (PNtlmCredentials)phCredential->dwLower; - - if(ntlm_cred->mode != NTLM_SERVER) - { - ret = SEC_E_INVALID_HANDLE; - goto asc_end; - } - - /* This is the first call to AcceptSecurityHandle */ - if(pInput == NULL) - { - ret = SEC_E_INCOMPLETE_MESSAGE; - goto asc_end; - } - - if(pInput->cBuffers < 1) - { - ret = SEC_E_INCOMPLETE_MESSAGE; - goto asc_end; - } - - if(pInput->pBuffers[0].cbBuffer > max_len) - { - ret = SEC_E_INVALID_TOKEN; - goto asc_end; - } - else - bin_len = pInput->pBuffers[0].cbBuffer; - - if( (ret = fork_helper(&helper, ntlm_auth, server_argv)) != - SEC_E_OK) - { - ret = SEC_E_INTERNAL_ERROR; - goto asc_end; - } - helper->mode = NTLM_SERVER; - - /* Handle all the flags */ - if (!(want_flags = heap_alloc(73))) - { - TRACE("Failed to allocate memory for the want_flags!\n"); - ret = SEC_E_INSUFFICIENT_MEMORY; - cleanup_helper(helper); - goto asc_end; - } - lstrcpyA(want_flags, "SF"); - if(fContextReq & ASC_REQ_ALLOCATE_MEMORY) - { - FIXME("ASC_REQ_ALLOCATE_MEMORY stub\n"); - } - if(fContextReq & ASC_REQ_CONFIDENTIALITY) - { - lstrcatA(want_flags, " NTLMSSP_FEATURE_SEAL"); - } - if(fContextReq & ASC_REQ_CONNECTION) - { - /* This is default, so we'll enable it */ - lstrcatA(want_flags, " NTLMSSP_FEATURE_SESSION_KEY"); - ctxt_attr |= ASC_RET_CONNECTION; - } - if(fContextReq & ASC_REQ_EXTENDED_ERROR) - { - FIXME("ASC_REQ_EXTENDED_ERROR stub\n"); - } - if(fContextReq & ASC_REQ_INTEGRITY) - { - lstrcatA(want_flags, " NTLMSSP_FEATURE_SIGN"); - } - if(fContextReq & ASC_REQ_MUTUAL_AUTH) - { - FIXME("ASC_REQ_MUTUAL_AUTH stub\n"); - } - if(fContextReq & ASC_REQ_REPLAY_DETECT) - { - FIXME("ASC_REQ_REPLAY_DETECT stub\n"); - } - if(fContextReq & ISC_REQ_SEQUENCE_DETECT) - { - FIXME("ASC_REQ_SEQUENCE_DETECT stub\n"); - } - if(fContextReq & ISC_REQ_STREAM) - { - FIXME("ASC_REQ_STREAM stub\n"); - } - /* Done with the flags */ - - if(lstrlenA(want_flags) > 3) - { - TRACE("Server set want_flags: %s\n", debugstr_a(want_flags)); - lstrcpynA(buffer, want_flags, max_len - 1); - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != - SEC_E_OK) - { - cleanup_helper(helper); - goto asc_end; - } - if(!strncmp(buffer, "BH", 2)) - TRACE("Helper doesn't understand new command set\n"); - } - - /* This is the YR request from the client, encode to base64 */ - - memcpy(bin, pInput->pBuffers[0].pvBuffer, bin_len); - - lstrcpynA(buffer, "YR ", max_len-1); - - if((ret = encodeBase64(bin, bin_len, buffer+3, max_len-3, - &buffer_len)) != SEC_E_OK) - { - cleanup_helper(helper); - goto asc_end; - } - - TRACE("Client sent: %s\n", debugstr_a(buffer)); - - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != - SEC_E_OK) - { - cleanup_helper(helper); - goto asc_end; - } - - TRACE("Reply from ntlm_auth: %s\n", debugstr_a(buffer)); - /* The expected answer is TT <base64 blob> */ - - if(strncmp(buffer, "TT ", 3) != 0) - { - ret = SEC_E_INTERNAL_ERROR; - cleanup_helper(helper); - goto asc_end; - } - - if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len, - &bin_len)) != SEC_E_OK) - { - cleanup_helper(helper); - goto asc_end; - } - - /* send this to the client */ - if(pOutput == NULL) - { - ret = SEC_E_INSUFFICIENT_MEMORY; - cleanup_helper(helper); - goto asc_end; - } - - if(pOutput->cBuffers < 1) - { - ret = SEC_E_INSUFFICIENT_MEMORY; - cleanup_helper(helper); - goto asc_end; - } - - pOutput->pBuffers[0].cbBuffer = bin_len; - pOutput->pBuffers[0].BufferType = SECBUFFER_DATA; - memcpy(pOutput->pBuffers[0].pvBuffer, bin, bin_len); - ret = SEC_I_CONTINUE_NEEDED; - - } - else - { - /* we expect a KK request from client */ - if(pInput == NULL) - { - ret = SEC_E_INCOMPLETE_MESSAGE; - goto asc_end; - } - - if(pInput->cBuffers < 1) - { - ret = SEC_E_INCOMPLETE_MESSAGE; - goto asc_end; - } - - helper = (PNegoHelper)phContext->dwLower; - - if(helper->mode != NTLM_SERVER) - { - ret = SEC_E_INVALID_HANDLE; - goto asc_end; - } - - if(pInput->pBuffers[0].cbBuffer > max_len) - { - ret = SEC_E_INVALID_TOKEN; - goto asc_end; - } - else - bin_len = pInput->pBuffers[0].cbBuffer; - - memcpy(bin, pInput->pBuffers[0].pvBuffer, bin_len); - - lstrcpynA(buffer, "KK ", max_len-1); - - if((ret = encodeBase64(bin, bin_len, buffer+3, max_len-3, - &buffer_len)) != SEC_E_OK) - { - goto asc_end; - } - - TRACE("Client sent: %s\n", debugstr_a(buffer)); - - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != - SEC_E_OK) - { - goto asc_end; - } - - TRACE("Reply from ntlm_auth: %s\n", debugstr_a(buffer)); - - /* At this point, we get a NA if the user didn't authenticate, but a BH - * if ntlm_auth could not connect to winbindd. Apart from running Wine - * as root, there is no way to fix this for now, so just handle this as - * a failed login. */ - if(strncmp(buffer, "AF ", 3) != 0) - { - if(strncmp(buffer, "NA ", 3) == 0) - { - ret = SEC_E_LOGON_DENIED; - goto asc_end; - } - else - { - size_t ntlm_pipe_err_v3_len = strlen("BH NT_STATUS_ACCESS_DENIED"); - size_t ntlm_pipe_err_v4_len = strlen("BH NT_STATUS_UNSUCCESSFUL"); - - if( (buffer_len >= ntlm_pipe_err_v3_len && - strncmp(buffer, "BH NT_STATUS_ACCESS_DENIED", ntlm_pipe_err_v3_len) == 0) || - (buffer_len >= ntlm_pipe_err_v4_len && - strncmp(buffer, "BH NT_STATUS_UNSUCCESSFUL", ntlm_pipe_err_v4_len) == 0) ) - { - TRACE("Connection to winbindd failed\n"); - ret = SEC_E_LOGON_DENIED; - } - else - ret = SEC_E_INTERNAL_ERROR; - - goto asc_end; - } - } - pOutput->pBuffers[0].cbBuffer = 0; - - TRACE("Getting negotiated flags\n"); - lstrcpynA(buffer, "GF", max_len - 1); - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK) - goto asc_end; - - if(buffer_len < 3) - { - TRACE("No flags negotiated, or helper does not support GF command\n"); - } - else - { - TRACE("Negotiated %s\n", debugstr_a(buffer)); - sscanf(buffer + 3, "%x", &(helper->neg_flags)); - TRACE("Stored 0x%08x as flags\n", helper->neg_flags); - } - - TRACE("Getting session key\n"); - lstrcpynA(buffer, "GK", max_len - 1); - if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK) - goto asc_end; - - if(buffer_len < 3) - TRACE("Helper does not support GK command\n"); - else - { - if(strncmp(buffer, "BH ", 3) == 0) - { - TRACE("Helper sent %s\n", debugstr_a(buffer+3)); - heap_free(helper->session_key); - if (!(helper->session_key = heap_alloc(16))) - { - ret = SEC_E_INSUFFICIENT_MEMORY; - goto asc_end; - } - /*FIXME: Generate the dummy session key = MD4(MD4(password))*/ - memset(helper->session_key, 0 , 16); - } - else if(strncmp(buffer, "GK ", 3) == 0) - { - if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len, - &bin_len)) != SEC_E_OK) - { - TRACE("Failed to decode session key\n"); - } - TRACE("Session key is %s\n", debugstr_a(buffer+3)); - heap_free(helper->session_key); - if (!(helper->session_key = heap_alloc(16))) - { - ret = SEC_E_INSUFFICIENT_MEMORY; - goto asc_end; - } - memcpy(helper->session_key, bin, 16); - } - } - helper->crypt.ntlm.a4i = SECUR32_arc4Alloc(); - SECUR32_arc4Init(helper->crypt.ntlm.a4i, helper->session_key, 16); - helper->crypt.ntlm.seq_num = 0l; - } - - phNewContext->dwUpper = ctxt_attr; - phNewContext->dwLower = (ULONG_PTR)helper; - -asc_end: - heap_free(want_flags); - heap_free(buffer); - heap_free(bin); - return ret; -} - -/*********************************************************************** - * CompleteAuthToken - */ -static SECURITY_STATUS SEC_ENTRY ntlm_CompleteAuthToken(PCtxtHandle phContext, - PSecBufferDesc pToken) -{ - /* We never need to call CompleteAuthToken anyway */ - TRACE("%p %p\n", phContext, pToken); - if (!phContext) - return SEC_E_INVALID_HANDLE; - - return SEC_E_OK; -} - -/*********************************************************************** - * DeleteSecurityContext - */ -static SECURITY_STATUS SEC_ENTRY ntlm_DeleteSecurityContext(PCtxtHandle phContext) -{ - PNegoHelper helper; - - TRACE("%p\n", phContext); - if (!phContext) - return SEC_E_INVALID_HANDLE; - - helper = (PNegoHelper)phContext->dwLower; - - phContext->dwUpper = 0; - phContext->dwLower = 0; - - SECUR32_arc4Cleanup(helper->crypt.ntlm.a4i); - SECUR32_arc4Cleanup(helper->crypt.ntlm2.send_a4i); - SECUR32_arc4Cleanup(helper->crypt.ntlm2.recv_a4i); - heap_free(helper->crypt.ntlm2.send_sign_key); - heap_free(helper->crypt.ntlm2.send_seal_key); - heap_free(helper->crypt.ntlm2.recv_sign_key); - heap_free(helper->crypt.ntlm2.recv_seal_key); - - cleanup_helper(helper); - - return SEC_E_OK; -} - -#define NTLM_COMMENT \ - { 'N', 'T', 'L', 'M', ' ', \ - 'S', 'e', 'c', 'u', 'r', 'i', 't', 'y', ' ', \ - 'P', 'a', 'c', 'k', 'a', 'g', 'e', 0} - -static CHAR ntlm_comment_A[] = NTLM_COMMENT; -static WCHAR ntlm_comment_W[] = NTLM_COMMENT; - -#define NTLM_NAME {'N', 'T', 'L', 'M', 0} - -static char ntlm_name_A[] = NTLM_NAME; -static WCHAR ntlm_name_W[] = NTLM_NAME; - -#define NTLM_CAPS ( \ - SECPKG_FLAG_INTEGRITY | \ - SECPKG_FLAG_PRIVACY | \ - SECPKG_FLAG_TOKEN_ONLY | \ - SECPKG_FLAG_CONNECTION | \ - SECPKG_FLAG_MULTI_REQUIRED | \ - SECPKG_FLAG_IMPERSONATION | \ - SECPKG_FLAG_ACCEPT_WIN32_NAME | \ - SECPKG_FLAG_NEGOTIABLE | \ - SECPKG_FLAG_LOGON | \ - SECPKG_FLAG_RESTRICTED_TOKENS ) - -static const SecPkgInfoW infoW = { - NTLM_CAPS, - 1, - RPC_C_AUTHN_WINNT, - NTLM_MAX_BUF, - ntlm_name_W, - ntlm_comment_W -}; - -static const SecPkgInfoA infoA = { - NTLM_CAPS, - 1, - RPC_C_AUTHN_WINNT, - NTLM_MAX_BUF, - ntlm_name_A, - ntlm_comment_A -}; - -static SecPkgInfoA *ntlm_package_infoA = (SecPkgInfoA *)&infoA; -static SecPkgInfoW *ntlm_package_infoW = (SecPkgInfoW *)&infoW; - -static SecPkgInfoW *build_package_infoW( const SecPkgInfoW *info ) -{ - SecPkgInfoW *ret; - DWORD size_name = (strlenW(info->Name) + 1) * sizeof(WCHAR); - DWORD size_comment = (strlenW(info->Comment) + 1) * sizeof(WCHAR); - - if (!(ret = heap_alloc( sizeof(*ret) + size_name + size_comment ))) return NULL; - ret->fCapabilities = info->fCapabilities; - ret->wVersion = info->wVersion; - ret->wRPCID = info->wRPCID; - ret->cbMaxToken = info->cbMaxToken; - ret->Name = (SEC_WCHAR *)(ret + 1); - memcpy( ret->Name, info->Name, size_name ); - ret->Comment = (SEC_WCHAR *)((char *)ret->Name + size_name); - memcpy( ret->Comment, info->Comment, size_comment ); - return ret; -} - -static SecPkgInfoA *build_package_infoA( const SecPkgInfoA *info ) -{ - SecPkgInfoA *ret; - DWORD size_name = strlen(info->Name) + 1, size_comment = strlen(info->Comment) + 1; - - if (!(ret = heap_alloc( sizeof(*ret) + size_name + size_comment ))) return NULL; - ret->fCapabilities = info->fCapabilities; - ret->wVersion = info->wVersion; - ret->wRPCID = info->wRPCID; - ret->cbMaxToken = info->cbMaxToken; - ret->Name = (SEC_CHAR *)(ret + 1); - memcpy( ret->Name, info->Name, size_name ); - ret->Comment = ret->Name + size_name; - memcpy( ret->Comment, info->Comment, size_comment ); - return ret; -} - -/*********************************************************************** - * QueryContextAttributesW - */ -static SECURITY_STATUS SEC_ENTRY ntlm_QueryContextAttributesW(PCtxtHandle phContext, - ULONG ulAttribute, void *pBuffer) -{ - TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer); - if (!phContext) - return SEC_E_INVALID_HANDLE; - - switch(ulAttribute) - { -#define _x(x) case (x) : FIXME(#x" stub\n"); break - _x(SECPKG_ATTR_ACCESS_TOKEN); - _x(SECPKG_ATTR_AUTHORITY); - _x(SECPKG_ATTR_DCE_INFO); - case SECPKG_ATTR_FLAGS: - { - PSecPkgContext_Flags spcf = (PSecPkgContext_Flags)pBuffer; - PNegoHelper helper = (PNegoHelper)phContext->dwLower; - - spcf->Flags = 0; - if(helper->neg_flags & NTLMSSP_NEGOTIATE_SIGN) - spcf->Flags |= ISC_RET_INTEGRITY; - if(helper->neg_flags & NTLMSSP_NEGOTIATE_SEAL) - spcf->Flags |= ISC_RET_CONFIDENTIALITY; - return SEC_E_OK; - } - _x(SECPKG_ATTR_KEY_INFO); - _x(SECPKG_ATTR_LIFESPAN); - _x(SECPKG_ATTR_NAMES); - _x(SECPKG_ATTR_NATIVE_NAMES); - case SECPKG_ATTR_NEGOTIATION_INFO: - { - SecPkgContext_NegotiationInfoW *info = (SecPkgContext_NegotiationInfoW *)pBuffer; - if (!(info->PackageInfo = build_package_infoW( &infoW ))) return SEC_E_INSUFFICIENT_MEMORY; - info->NegotiationState = SECPKG_NEGOTIATION_COMPLETE; - return SEC_E_OK; - } - _x(SECPKG_ATTR_PACKAGE_INFO); - _x(SECPKG_ATTR_PASSWORD_EXPIRY); - _x(SECPKG_ATTR_SESSION_KEY); - case SECPKG_ATTR_SIZES: - { - PSecPkgContext_Sizes spcs = (PSecPkgContext_Sizes)pBuffer; - spcs->cbMaxToken = NTLM_MAX_BUF; - spcs->cbMaxSignature = 16; - spcs->cbBlockSize = 0; - spcs->cbSecurityTrailer = 16; - return SEC_E_OK; - } - _x(SECPKG_ATTR_STREAM_SIZES); - _x(SECPKG_ATTR_TARGET_INFORMATION); -#undef _x - default: - TRACE("Unknown value %d passed for ulAttribute\n", ulAttribute); - } - - return SEC_E_UNSUPPORTED_FUNCTION; -} - -/*********************************************************************** - * QueryContextAttributesA - */ -static SECURITY_STATUS SEC_ENTRY ntlm_QueryContextAttributesA(PCtxtHandle phContext, - ULONG ulAttribute, void *pBuffer) -{ - switch(ulAttribute) - { - case SECPKG_ATTR_NEGOTIATION_INFO: - { - SecPkgContext_NegotiationInfoA *info = (SecPkgContext_NegotiationInfoA *)pBuffer; - if (!(info->PackageInfo = build_package_infoA( &infoA ))) return SEC_E_INSUFFICIENT_MEMORY; - info->NegotiationState = SECPKG_NEGOTIATION_COMPLETE; - return SEC_E_OK; - } - default: - return ntlm_QueryContextAttributesW( phContext, ulAttribute, pBuffer ); - } -} - -/*********************************************************************** - * ImpersonateSecurityContext - */ -static SECURITY_STATUS SEC_ENTRY ntlm_ImpersonateSecurityContext(PCtxtHandle phContext) -{ - SECURITY_STATUS ret; - - TRACE("%p\n", phContext); - if (phContext) - { - ret = SEC_E_UNSUPPORTED_FUNCTION; - } - else - { - ret = SEC_E_INVALID_HANDLE; - } - return ret; -} - -/*********************************************************************** - * RevertSecurityContext - */ -static SECURITY_STATUS SEC_ENTRY ntlm_RevertSecurityContext(PCtxtHandle phContext) -{ - SECURITY_STATUS ret; - - TRACE("%p\n", phContext); - if (phContext) - { - ret = SEC_E_UNSUPPORTED_FUNCTION; - } - else - { - ret = SEC_E_INVALID_HANDLE; - } - return ret; -} - -/*********************************************************************** - * ntlm_CreateSignature - * As both MakeSignature and VerifySignature need this, but different keys - * are needed for NTLM2, the logic goes into a helper function. - * To ensure maximal reusability, we can specify the direction as NTLM_SEND for - * signing/encrypting and NTLM_RECV for verifying/decrypting. When encrypting, - * the signature is encrypted after the message was encrypted, so - * CreateSignature shouldn't do it. In this case, encrypt_sig can be set to - * false. - */ -static SECURITY_STATUS ntlm_CreateSignature(PNegoHelper helper, PSecBufferDesc pMessage, - int token_idx, SignDirection direction, BOOL encrypt_sig) -{ - ULONG sign_version = 1; - UINT i; - PBYTE sig; - TRACE("%p, %p, %d, %d, %d\n", helper, pMessage, token_idx, direction, - encrypt_sig); - - sig = pMessage->pBuffers[token_idx].pvBuffer; - - if(helper->neg_flags & NTLMSSP_NEGOTIATE_NTLM2 && - helper->neg_flags & NTLMSSP_NEGOTIATE_SIGN) - { - BYTE digest[16]; - BYTE seq_no[4]; - HMAC_MD5_CTX hmac_md5_ctx; - - TRACE("Signing NTLM2 style\n"); - - if(direction == NTLM_SEND) - { - seq_no[0] = (helper->crypt.ntlm2.send_seq_no >> 0) & 0xff; - seq_no[1] = (helper->crypt.ntlm2.send_seq_no >> 8) & 0xff; - seq_no[2] = (helper->crypt.ntlm2.send_seq_no >> 16) & 0xff; - seq_no[3] = (helper->crypt.ntlm2.send_seq_no >> 24) & 0xff; - - ++(helper->crypt.ntlm2.send_seq_no); - - HMACMD5Init(&hmac_md5_ctx, helper->crypt.ntlm2.send_sign_key, 16); - } - else - { - seq_no[0] = (helper->crypt.ntlm2.recv_seq_no >> 0) & 0xff; - seq_no[1] = (helper->crypt.ntlm2.recv_seq_no >> 8) & 0xff; - seq_no[2] = (helper->crypt.ntlm2.recv_seq_no >> 16) & 0xff; - seq_no[3] = (helper->crypt.ntlm2.recv_seq_no >> 24) & 0xff; - - ++(helper->crypt.ntlm2.recv_seq_no); - - HMACMD5Init(&hmac_md5_ctx, helper->crypt.ntlm2.recv_sign_key, 16); - } - - HMACMD5Update(&hmac_md5_ctx, seq_no, 4); - for( i = 0; i < pMessage->cBuffers; ++i ) - { - if(pMessage->pBuffers[i].BufferType & SECBUFFER_DATA) - HMACMD5Update(&hmac_md5_ctx, pMessage->pBuffers[i].pvBuffer, - pMessage->pBuffers[i].cbBuffer); - } - - HMACMD5Final(&hmac_md5_ctx, digest); - - if(encrypt_sig && helper->neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCHANGE) - { - if(direction == NTLM_SEND) - SECUR32_arc4Process(helper->crypt.ntlm2.send_a4i, digest, 8); - else - SECUR32_arc4Process(helper->crypt.ntlm2.recv_a4i, digest, 8); - } - - /* The NTLM2 signature is the sign version */ - sig[ 0] = (sign_version >> 0) & 0xff; - sig[ 1] = (sign_version >> 8) & 0xff; - sig[ 2] = (sign_version >> 16) & 0xff; - sig[ 3] = (sign_version >> 24) & 0xff; - /* The first 8 bytes of the digest */ - memcpy(sig+4, digest, 8); - /* And the sequence number */ - memcpy(sig+12, seq_no, 4); - - pMessage->pBuffers[token_idx].cbBuffer = 16; - - return SEC_E_OK; - } - if(helper->neg_flags & NTLMSSP_NEGOTIATE_SIGN) - { - ULONG crc = 0U; - TRACE("Signing NTLM1 style\n"); - - for(i=0; i < pMessage->cBuffers; ++i) - { - if(pMessage->pBuffers[i].BufferType & SECBUFFER_DATA) - crc = RtlComputeCrc32(crc, pMessage->pBuffers[i].pvBuffer, pMessage->pBuffers[i].cbBuffer); - } - - sig[ 0] = (sign_version >> 0) & 0xff; - sig[ 1] = (sign_version >> 8) & 0xff; - sig[ 2] = (sign_version >> 16) & 0xff; - sig[ 3] = (sign_version >> 24) & 0xff; - memset(sig+4, 0, 4); - sig[ 8] = (crc >> 0) & 0xff; - sig[ 9] = (crc >> 8) & 0xff; - sig[10] = (crc >> 16) & 0xff; - sig[11] = (crc >> 24) & 0xff; - sig[12] = (helper->crypt.ntlm.seq_num >> 0) & 0xff; - sig[13] = (helper->crypt.ntlm.seq_num >> 8) & 0xff; - sig[14] = (helper->crypt.ntlm.seq_num >> 16) & 0xff; - sig[15] = (helper->crypt.ntlm.seq_num >> 24) & 0xff; - - ++(helper->crypt.ntlm.seq_num); - - if(encrypt_sig) - SECUR32_arc4Process(helper->crypt.ntlm.a4i, sig+4, 12); - return SEC_E_OK; - } - - if(helper->neg_flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN || helper->neg_flags == 0) - { - TRACE("Creating a dummy signature.\n"); - /* A dummy signature is 0x01 followed by 15 bytes of 0x00 */ - memset(pMessage->pBuffers[token_idx].pvBuffer, 0, 16); - memset(pMessage->pBuffers[token_idx].pvBuffer, 0x01, 1); - pMessage->pBuffers[token_idx].cbBuffer = 16; - return SEC_E_OK; - } - - return SEC_E_UNSUPPORTED_FUNCTION; -} - -/*********************************************************************** - * MakeSignature - */ -static SECURITY_STATUS SEC_ENTRY ntlm_MakeSignature(PCtxtHandle phContext, - ULONG fQOP, PSecBufferDesc pMessage, ULONG MessageSeqNo) -{ - PNegoHelper helper; - int token_idx; - - TRACE("%p %d %p %d\n", phContext, fQOP, pMessage, MessageSeqNo); - if (!phContext) - return SEC_E_INVALID_HANDLE; - - if(fQOP) - FIXME("Ignoring fQOP 0x%08x\n", fQOP); - - if(MessageSeqNo) - FIXME("Ignoring MessageSeqNo\n"); - - if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2) - return SEC_E_INVALID_TOKEN; - - /* If we didn't find a SECBUFFER_TOKEN type buffer */ - if((token_idx = ntlm_GetTokenBufferIndex(pMessage)) == -1) - return SEC_E_INVALID_TOKEN; - - if(pMessage->pBuffers[token_idx].cbBuffer < 16) - return SEC_E_BUFFER_TOO_SMALL; - - helper = (PNegoHelper)phContext->dwLower; - TRACE("Negotiated flags are: 0x%08x\n", helper->neg_flags); - - return ntlm_CreateSignature(helper, pMessage, token_idx, NTLM_SEND, TRUE); -} - -/*********************************************************************** - * VerifySignature - */ -static SECURITY_STATUS SEC_ENTRY ntlm_VerifySignature(PCtxtHandle phContext, - PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP) -{ - PNegoHelper helper; - UINT i; - int token_idx; - SECURITY_STATUS ret; - SecBufferDesc local_desc; - PSecBuffer local_buff; - BYTE local_sig[16]; - - TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, pfQOP); - if(!phContext) - return SEC_E_INVALID_HANDLE; - - if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2) - return SEC_E_INVALID_TOKEN; - - if((token_idx = ntlm_GetTokenBufferIndex(pMessage)) == -1) - return SEC_E_INVALID_TOKEN; - - if(pMessage->pBuffers[token_idx].cbBuffer < 16) - return SEC_E_BUFFER_TOO_SMALL; - - if(MessageSeqNo) - FIXME("Ignoring MessageSeqNo\n"); - - helper = (PNegoHelper)phContext->dwLower; - TRACE("Negotiated flags: 0x%08x\n", helper->neg_flags); - - local_buff = heap_alloc(pMessage->cBuffers * sizeof(SecBuffer)); - - local_desc.ulVersion = SECBUFFER_VERSION; - local_desc.cBuffers = pMessage->cBuffers; - local_desc.pBuffers = local_buff; - - for(i=0; i < pMessage->cBuffers; ++i) - { - if(pMessage->pBuffers[i].BufferType == SECBUFFER_TOKEN) - { - local_buff[i].BufferType = SECBUFFER_TOKEN; - local_buff[i].cbBuffer = 16; - local_buff[i].pvBuffer = local_sig; - } - else - { - local_buff[i].BufferType = pMessage->pBuffers[i].BufferType; - local_buff[i].cbBuffer = pMessage->pBuffers[i].cbBuffer; - local_buff[i].pvBuffer = pMessage->pBuffers[i].pvBuffer; - } - } - - if((ret = ntlm_CreateSignature(helper, &local_desc, token_idx, NTLM_RECV, TRUE)) != SEC_E_OK) - return ret; - - if(memcmp(((PBYTE)local_buff[token_idx].pvBuffer) + 8, - ((PBYTE)pMessage->pBuffers[token_idx].pvBuffer) + 8, 8)) - ret = SEC_E_MESSAGE_ALTERED; - else - ret = SEC_E_OK; - - heap_free(local_buff); - return ret; - -} - -/*********************************************************************** - * FreeCredentialsHandle - */ -static SECURITY_STATUS SEC_ENTRY ntlm_FreeCredentialsHandle(PCredHandle phCredential) -{ - if (phCredential) - { - PNtlmCredentials ntlm_cred = (PNtlmCredentials) phCredential->dwLower; - phCredential->dwUpper = 0; - phCredential->dwLower = 0; - if (ntlm_cred->password) memset(ntlm_cred->password, 0, ntlm_cred->pwlen); - heap_free(ntlm_cred->password); - heap_free(ntlm_cred->username_arg); - heap_free(ntlm_cred->domain_arg); - heap_free(ntlm_cred); - } - - return SEC_E_OK; -} - -/*********************************************************************** - * EncryptMessage - */ -static SECURITY_STATUS SEC_ENTRY ntlm_EncryptMessage(PCtxtHandle phContext, - ULONG fQOP, PSecBufferDesc pMessage, ULONG MessageSeqNo) -{ - PNegoHelper helper; - int token_idx, data_idx; - - TRACE("(%p %d %p %d)\n", phContext, fQOP, pMessage, MessageSeqNo); - - if(!phContext) - return SEC_E_INVALID_HANDLE; - - if(fQOP) - FIXME("Ignoring fQOP\n"); - - if(MessageSeqNo) - FIXME("Ignoring MessageSeqNo\n"); - - if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2) - return SEC_E_INVALID_TOKEN; - - if((token_idx = ntlm_GetTokenBufferIndex(pMessage)) == -1) - return SEC_E_INVALID_TOKEN; - - if((data_idx = ntlm_GetDataBufferIndex(pMessage)) ==-1 ) - return SEC_E_INVALID_TOKEN; - - if(pMessage->pBuffers[token_idx].cbBuffer < 16) - return SEC_E_BUFFER_TOO_SMALL; - - helper = (PNegoHelper) phContext->dwLower; - - if(helper->neg_flags & NTLMSSP_NEGOTIATE_NTLM2 && - helper->neg_flags & NTLMSSP_NEGOTIATE_SEAL) - { - ntlm_CreateSignature(helper, pMessage, token_idx, NTLM_SEND, FALSE); - SECUR32_arc4Process(helper->crypt.ntlm2.send_a4i, - pMessage->pBuffers[data_idx].pvBuffer, - pMessage->pBuffers[data_idx].cbBuffer); - - if(helper->neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCHANGE) - SECUR32_arc4Process(helper->crypt.ntlm2.send_a4i, - ((BYTE *)pMessage->pBuffers[token_idx].pvBuffer)+4, 8); - } - else - { - PBYTE sig; - ULONG save_flags; - - /* EncryptMessage always produces real signatures, so make sure - * NTLMSSP_NEGOTIATE_SIGN is set*/ - save_flags = helper->neg_flags; - helper->neg_flags |= NTLMSSP_NEGOTIATE_SIGN; - ntlm_CreateSignature(helper, pMessage, token_idx, NTLM_SEND, FALSE); - helper->neg_flags = save_flags; - - sig = pMessage->pBuffers[token_idx].pvBuffer; - - SECUR32_arc4Process(helper->crypt.ntlm.a4i, - pMessage->pBuffers[data_idx].pvBuffer, - pMessage->pBuffers[data_idx].cbBuffer); - SECUR32_arc4Process(helper->crypt.ntlm.a4i, sig+4, 12); - - if(helper->neg_flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN || helper->neg_flags == 0) - memset(sig+4, 0, 4); - } - return SEC_E_OK; -} - -/*********************************************************************** - * DecryptMessage - */ -static SECURITY_STATUS SEC_ENTRY ntlm_DecryptMessage(PCtxtHandle phContext, - PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP) -{ - SECURITY_STATUS ret; - ULONG ntlmssp_flags_save; - PNegoHelper helper; - int token_idx, data_idx; - TRACE("(%p %p %d %p)\n", phContext, pMessage, MessageSeqNo, pfQOP); - - if(!phContext) - return SEC_E_INVALID_HANDLE; - - if(MessageSeqNo) - FIXME("Ignoring MessageSeqNo\n"); - - if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2) - return SEC_E_INVALID_TOKEN; - - if((token_idx = ntlm_GetTokenBufferIndex(pMessage)) == -1) - return SEC_E_INVALID_TOKEN; - - if((data_idx = ntlm_GetDataBufferIndex(pMessage)) ==-1) - return SEC_E_INVALID_TOKEN; - - if(pMessage->pBuffers[token_idx].cbBuffer < 16) - return SEC_E_BUFFER_TOO_SMALL; - - helper = (PNegoHelper) phContext->dwLower; - - if(helper->neg_flags & NTLMSSP_NEGOTIATE_NTLM2 && helper->neg_flags & NTLMSSP_NEGOTIATE_SEAL) - { - SECUR32_arc4Process(helper->crypt.ntlm2.recv_a4i, - pMessage->pBuffers[data_idx].pvBuffer, - pMessage->pBuffers[data_idx].cbBuffer); - } - else - { - SECUR32_arc4Process(helper->crypt.ntlm.a4i, - pMessage->pBuffers[data_idx].pvBuffer, - pMessage->pBuffers[data_idx].cbBuffer); - } - - /* Make sure we use a session key for the signature check, EncryptMessage - * always does that, even in the dummy case */ - ntlmssp_flags_save = helper->neg_flags; - - helper->neg_flags |= NTLMSSP_NEGOTIATE_SIGN; - ret = ntlm_VerifySignature(phContext, pMessage, MessageSeqNo, pfQOP); - - helper->neg_flags = ntlmssp_flags_save; - - return ret; -} - -static const SecurityFunctionTableA ntlmTableA = { - 1, - NULL, /* EnumerateSecurityPackagesA */ - ntlm_QueryCredentialsAttributesA, /* QueryCredentialsAttributesA */ - ntlm_AcquireCredentialsHandleA, /* AcquireCredentialsHandleA */ - ntlm_FreeCredentialsHandle, /* FreeCredentialsHandle */ - NULL, /* Reserved2 */ - ntlm_InitializeSecurityContextA, /* InitializeSecurityContextA */ - ntlm_AcceptSecurityContext, /* AcceptSecurityContext */ - ntlm_CompleteAuthToken, /* CompleteAuthToken */ - ntlm_DeleteSecurityContext, /* DeleteSecurityContext */ - NULL, /* ApplyControlToken */ - ntlm_QueryContextAttributesA, /* QueryContextAttributesA */ - ntlm_ImpersonateSecurityContext, /* ImpersonateSecurityContext */ - ntlm_RevertSecurityContext, /* RevertSecurityContext */ - ntlm_MakeSignature, /* MakeSignature */ - ntlm_VerifySignature, /* VerifySignature */ - FreeContextBuffer, /* FreeContextBuffer */ - NULL, /* QuerySecurityPackageInfoA */ - NULL, /* Reserved3 */ - NULL, /* Reserved4 */ - NULL, /* ExportSecurityContext */ - NULL, /* ImportSecurityContextA */ - NULL, /* AddCredentialsA */ - NULL, /* Reserved8 */ - NULL, /* QuerySecurityContextToken */ - ntlm_EncryptMessage, /* EncryptMessage */ - ntlm_DecryptMessage, /* DecryptMessage */ - NULL, /* SetContextAttributesA */ -}; - -static const SecurityFunctionTableW ntlmTableW = { - 1, - NULL, /* EnumerateSecurityPackagesW */ - ntlm_QueryCredentialsAttributesW, /* QueryCredentialsAttributesW */ - ntlm_AcquireCredentialsHandleW, /* AcquireCredentialsHandleW */ - ntlm_FreeCredentialsHandle, /* FreeCredentialsHandle */ - NULL, /* Reserved2 */ - ntlm_InitializeSecurityContextW, /* InitializeSecurityContextW */ - ntlm_AcceptSecurityContext, /* AcceptSecurityContext */ - ntlm_CompleteAuthToken, /* CompleteAuthToken */ - ntlm_DeleteSecurityContext, /* DeleteSecurityContext */ - NULL, /* ApplyControlToken */ - ntlm_QueryContextAttributesW, /* QueryContextAttributesW */ - ntlm_ImpersonateSecurityContext, /* ImpersonateSecurityContext */ - ntlm_RevertSecurityContext, /* RevertSecurityContext */ - ntlm_MakeSignature, /* MakeSignature */ - ntlm_VerifySignature, /* VerifySignature */ - FreeContextBuffer, /* FreeContextBuffer */ - NULL, /* QuerySecurityPackageInfoW */ - NULL, /* Reserved3 */ - NULL, /* Reserved4 */ - NULL, /* ExportSecurityContext */ - NULL, /* ImportSecurityContextW */ - NULL, /* AddCredentialsW */ - NULL, /* Reserved8 */ - NULL, /* QuerySecurityContextToken */ - ntlm_EncryptMessage, /* EncryptMessage */ - ntlm_DecryptMessage, /* DecryptMessage */ - NULL, /* SetContextAttributesW */ -}; - -void SECUR32_initNTLMSP(void) -{ - PNegoHelper helper; - static CHAR version[] = "--version"; - - SEC_CHAR *args[] = { - ntlm_auth, - version, - NULL }; - - if(fork_helper(&helper, ntlm_auth, args) != SEC_E_OK) - helper = NULL; - else - check_version(helper); - - if( helper && - ((helper->major > MIN_NTLM_AUTH_MAJOR_VERSION) || - (helper->major == MIN_NTLM_AUTH_MAJOR_VERSION && - helper->minor > MIN_NTLM_AUTH_MINOR_VERSION) || - (helper->major == MIN_NTLM_AUTH_MAJOR_VERSION && - helper->minor == MIN_NTLM_AUTH_MINOR_VERSION && - helper->micro >= MIN_NTLM_AUTH_MICRO_VERSION)) ) - { - SecureProvider *provider = SECUR32_addProvider(&ntlmTableA, &ntlmTableW, NULL); - SECUR32_addPackages(provider, 1L, ntlm_package_infoA, ntlm_package_infoW); - } - else - { - ERR_(winediag)("%s was not found or is outdated. " - "Make sure that ntlm_auth >= %d.%d.%d is in your path. " - "Usually, you can find it in the winbind package of your distribution.\n", - ntlm_auth, - MIN_NTLM_AUTH_MAJOR_VERSION, - MIN_NTLM_AUTH_MINOR_VERSION, - MIN_NTLM_AUTH_MICRO_VERSION); - - } - cleanup_helper(helper); -} diff --git a/dlls/secur32/secur32_priv.h b/dlls/secur32/secur32_priv.h index ca0062056d6..5571ac290e1 100644 --- a/dlls/secur32/secur32_priv.h +++ b/dlls/secur32/secur32_priv.h @@ -44,65 +44,6 @@ typedef struct _SecurePackage SecureProvider *provider; } SecurePackage; -typedef enum _helper_mode { - NTLM_SERVER, - NTLM_CLIENT, - NUM_HELPER_MODES -} HelperMode; - -typedef struct tag_arc4_info { - unsigned char x, y; - unsigned char state[256]; -} arc4_info; - -typedef struct _NegoHelper { - pid_t helper_pid; - HelperMode mode; - int pipe_in; - int pipe_out; - int major; - int minor; - int micro; - char *com_buf; - int com_buf_size; - int com_buf_offset; - BYTE *session_key; - ULONG neg_flags; - struct { - struct { - ULONG seq_num; - arc4_info *a4i; - } ntlm; - struct { - BYTE *send_sign_key; - BYTE *send_seal_key; - BYTE *recv_sign_key; - BYTE *recv_seal_key; - ULONG send_seq_no; - ULONG recv_seq_no; - arc4_info *send_a4i; - arc4_info *recv_a4i; - } ntlm2; - } crypt; -} NegoHelper, *PNegoHelper; - -typedef struct _NtlmCredentials -{ - HelperMode mode; - - /* these are all in the Unix codepage */ - char *username_arg; - char *domain_arg; - char *password; /* not nul-terminated */ - int pwlen; - int no_cached_credentials; /* don't try to use cached Samba credentials */ -} NtlmCredentials, *PNtlmCredentials; - -typedef enum _sign_direction { - NTLM_SEND, - NTLM_RECV -} SignDirection; - /* Allocates space for and initializes a new provider. If fnTableA or fnTableW * is non-NULL, assumes the provider is built-in, and if moduleName is non-NULL, * means must load the LSA/user mode functions tables from external SSP/AP module. @@ -136,60 +77,11 @@ PSTR SECUR32_AllocMultiByteFromWide(PCWSTR str) DECLSPEC_HIDDEN; /* Initialization functions for built-in providers */ void SECUR32_initSchannelSP(void) DECLSPEC_HIDDEN; void SECUR32_initNegotiateSP(void) DECLSPEC_HIDDEN; -void SECUR32_initNTLMSP(void) DECLSPEC_HIDDEN; void load_auth_packages(void) DECLSPEC_HIDDEN; /* Cleanup functions for built-in providers */ void SECUR32_deinitSchannelSP(void) DECLSPEC_HIDDEN; -/* Functions from dispatcher.c used elsewhere in the code */ -SECURITY_STATUS fork_helper(PNegoHelper *new_helper, const char *prog, - char * const argv[]) DECLSPEC_HIDDEN; - -SECURITY_STATUS run_helper(PNegoHelper helper, char *buffer, - unsigned int max_buflen, int *buflen) DECLSPEC_HIDDEN; - -void cleanup_helper(PNegoHelper helper) DECLSPEC_HIDDEN; - -void check_version(PNegoHelper helper) DECLSPEC_HIDDEN; - -/* Functions from base64_codec.c used elsewhere */ -SECURITY_STATUS encodeBase64(PBYTE in_buf, int in_len, char* out_buf, - int max_len, int *out_len) DECLSPEC_HIDDEN; - -SECURITY_STATUS decodeBase64(char *in_buf, int in_len, BYTE *out_buf, - int max_len, int *out_len) DECLSPEC_HIDDEN; - -/* Functions from util.c */ -SECURITY_STATUS SECUR32_CreateNTLM1SessionKey(PBYTE password, int len, PBYTE session_key) DECLSPEC_HIDDEN; -SECURITY_STATUS SECUR32_CreateNTLM2SubKeys(PNegoHelper helper) DECLSPEC_HIDDEN; -arc4_info *SECUR32_arc4Alloc(void) DECLSPEC_HIDDEN; -void SECUR32_arc4Init(arc4_info *a4i, const BYTE *key, unsigned int keyLen) DECLSPEC_HIDDEN; -void SECUR32_arc4Process(arc4_info *a4i, BYTE *inoutString, unsigned int length) DECLSPEC_HIDDEN; -void SECUR32_arc4Cleanup(arc4_info *a4i) DECLSPEC_HIDDEN; - -/* NTLMSSP flags indicating the negotiated features */ -#define NTLMSSP_NEGOTIATE_UNICODE 0x00000001 -#define NTLMSSP_NEGOTIATE_OEM 0x00000002 -#define NTLMSSP_REQUEST_TARGET 0x00000004 -#define NTLMSSP_NEGOTIATE_SIGN 0x00000010 -#define NTLMSSP_NEGOTIATE_SEAL 0x00000020 -#define NTLMSSP_NEGOTIATE_DATAGRAM_STYLE 0x00000040 -#define NTLMSSP_NEGOTIATE_LM_SESSION_KEY 0x00000080 -#define NTLMSSP_NEGOTIATE_NTLM 0x00000200 -#define NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED 0x00001000 -#define NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED 0x00002000 -#define NTLMSSP_NEGOTIATE_LOCAL_CALL 0x00004000 -#define NTLMSSP_NEGOTIATE_ALWAYS_SIGN 0x00008000 -#define NTLMSSP_NEGOTIATE_TARGET_TYPE_DOMAIN 0x00010000 -#define NTLMSSP_NEGOTIATE_TARGET_TYPE_SERVER 0x00020000 -#define NTLMSSP_NEGOTIATE_NTLM2 0x00080000 -#define NTLMSSP_NEGOTIATE_TARGET_INFO 0x00800000 -#define NTLMSSP_NEGOTIATE_128 0x20000000 -#define NTLMSSP_NEGOTIATE_KEY_EXCHANGE 0x40000000 -#define NTLMSSP_NEGOTIATE_56 0x80000000 - - /* schannel internal interface */ typedef struct schan_imp_session_opaque *schan_imp_session; diff --git a/dlls/secur32/util.c b/dlls/secur32/util.c deleted file mode 100644 index b5cac5b6c06..00000000000 --- a/dlls/secur32/util.c +++ /dev/null @@ -1,187 +0,0 @@ -/* - * Copyright 2006 Kai Blin - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - * - * This file contains various helper functions needed for NTLM and maybe others - */ -#include <stdarg.h> -#include <stdio.h> -#include "windef.h" -#include "winbase.h" -#include "rpc.h" -#include "sspi.h" -#include "secur32_priv.h" -#include "wine/debug.h" - -WINE_DEFAULT_DEBUG_CHANNEL(ntlm); - -static const char client_to_server_sign_constant[] = "session key to client-to-server signing key magic constant"; -static const char client_to_server_seal_constant[] = "session key to client-to-server sealing key magic constant"; -static const char server_to_client_sign_constant[] = "session key to server-to-client signing key magic constant"; -static const char server_to_client_seal_constant[] = "session key to server-to-client sealing key magic constant"; - -typedef struct -{ - unsigned int buf[4]; - unsigned int i[2]; - unsigned char in[64]; - unsigned char digest[16]; -} MD4_CTX; - -/* And now the same with a different memory layout. */ -typedef struct -{ - unsigned int i[2]; - unsigned int buf[4]; - unsigned char in[64]; - unsigned char digest[16]; -} MD5_CTX; - -VOID WINAPI MD4Init( MD4_CTX *ctx ); -VOID WINAPI MD4Update( MD4_CTX *ctx, const unsigned char *buf, unsigned int len ); -VOID WINAPI MD4Final( MD4_CTX *ctx ); -VOID WINAPI MD5Init( MD5_CTX *ctx ); -VOID WINAPI MD5Update( MD5_CTX *ctx, const unsigned char *buf, unsigned int len ); -VOID WINAPI MD5Final( MD5_CTX *ctx ); - -SECURITY_STATUS SECUR32_CreateNTLM1SessionKey(PBYTE password, int len, PBYTE session_key) -{ - MD4_CTX ctx; - BYTE ntlm_hash[16]; - - TRACE("(%p, %p)\n", password, session_key); - - MD4Init(&ctx); - MD4Update(&ctx, password, len); - MD4Final(&ctx); - - memcpy(ntlm_hash, ctx.digest, 0x10); - - MD4Init(&ctx); - MD4Update(&ctx, ntlm_hash, 0x10u); - MD4Final(&ctx); - - memcpy(session_key, ctx.digest, 0x10); - - return SEC_E_OK; -} - -static void SECUR32_CalcNTLM2Subkey(const BYTE *session_key, const char *magic, PBYTE subkey) -{ - MD5_CTX ctx; - - MD5Init(&ctx); - MD5Update(&ctx, session_key, 16); - MD5Update(&ctx, (const unsigned char*)magic, lstrlenA(magic)+1); - MD5Final(&ctx); - memcpy(subkey, ctx.digest, 16); -} - -/* This assumes we do have a valid NTLM2 user session key */ -SECURITY_STATUS SECUR32_CreateNTLM2SubKeys(PNegoHelper helper) -{ - helper->crypt.ntlm2.send_sign_key = heap_alloc(16); - helper->crypt.ntlm2.send_seal_key = heap_alloc(16); - helper->crypt.ntlm2.recv_sign_key = heap_alloc(16); - helper->crypt.ntlm2.recv_seal_key = heap_alloc(16); - - if(helper->mode == NTLM_CLIENT) - { - SECUR32_CalcNTLM2Subkey(helper->session_key, client_to_server_sign_constant, - helper->crypt.ntlm2.send_sign_key); - SECUR32_CalcNTLM2Subkey(helper->session_key, client_to_server_seal_constant, - helper->crypt.ntlm2.send_seal_key); - SECUR32_CalcNTLM2Subkey(helper->session_key, server_to_client_sign_constant, - helper->crypt.ntlm2.recv_sign_key); - SECUR32_CalcNTLM2Subkey(helper->session_key, server_to_client_seal_constant, - helper->crypt.ntlm2.recv_seal_key); - } - else - { - SECUR32_CalcNTLM2Subkey(helper->session_key, server_to_client_sign_constant, - helper->crypt.ntlm2.send_sign_key); - SECUR32_CalcNTLM2Subkey(helper->session_key, server_to_client_seal_constant, - helper->crypt.ntlm2.send_seal_key); - SECUR32_CalcNTLM2Subkey(helper->session_key, client_to_server_sign_constant, - helper->crypt.ntlm2.recv_sign_key); - SECUR32_CalcNTLM2Subkey(helper->session_key, client_to_server_seal_constant, - helper->crypt.ntlm2.recv_seal_key); - } - - return SEC_E_OK; -} - -arc4_info *SECUR32_arc4Alloc(void) -{ - arc4_info *a4i = heap_alloc(sizeof(arc4_info)); - return a4i; -} - -/* - * The arc4 code is based on dlls/advapi32/crypt_arc4.c by Mike McCormack, - * which in turn is based on public domain code by Wei Dai - */ -void SECUR32_arc4Init(arc4_info *a4i, const BYTE *key, unsigned int keyLen) -{ - unsigned int keyIndex = 0, stateIndex = 0; - unsigned int i, a; - - TRACE("(%p, %p, %d)\n", a4i, key, keyLen); - - a4i->x = a4i->y = 0; - - for (i=0; i<256; i++) - a4i->state[i] = i; - - for (i=0; i<256; i++) - { - a = a4i->state[i]; - stateIndex += key[keyIndex] + a; - stateIndex &= 0xff; - a4i->state[i] = a4i->state[stateIndex]; - a4i->state[stateIndex] = a; - if (++keyIndex >= keyLen) - keyIndex = 0; - } - -} - -void SECUR32_arc4Process(arc4_info *a4i, BYTE *inoutString, unsigned int length) -{ - BYTE *const s=a4i->state; - unsigned int x = a4i->x; - unsigned int y = a4i->y; - unsigned int a, b; - - while(length--) - { - x = (x+1) & 0xff; - a = s[x]; - y = (y+a) & 0xff; - b = s[y]; - s[x] = b; - s[y] = a; - *inoutString++ ^= s[(a+b) & 0xff]; - } - - a4i->x = x; - a4i->y = y; -} - -void SECUR32_arc4Cleanup(arc4_info *a4i) -{ - heap_free(a4i); -} -- 2.30.2

2 1

[PATCH 1/2] secur32: Load the MSV1_0 provider instead of using builtin support for NTLM.
by Hans Leidekker 30 Apr '21

30 Apr '21

To apply after the last msv1_0 series. Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/secur32/secur32.c | 1 - loader/wine.inf.in | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/secur32/secur32.c b/dlls/secur32/secur32.c index 8288286c615..4382ec55174 100644 --- a/dlls/secur32/secur32.c +++ b/dlls/secur32/secur32.c @@ -563,7 +563,6 @@ static void SECUR32_initializeProviders(void) TRACE("\n"); /* First load built-in providers */ SECUR32_initSchannelSP(); - SECUR32_initNTLMSP(); /* Load SSP/AP packages (Kerberos and others) */ load_auth_packages(); /* Load the Negotiate provider last so apps stumble over the working NTLM diff --git a/loader/wine.inf.in b/loader/wine.inf.in index 6ae4e96e37f..a20efbcce3e 100644 --- a/loader/wine.inf.in +++ b/loader/wine.inf.in @@ -750,6 +750,7 @@ HKLM,Software\Registered Applications,,16 HKLM,System\CurrentControlSet\Control\hivelist,,16 HKLM,System\CurrentControlSet\Control\Lsa,"Security Packages",0x10002,kerberos,schannel HKLM,System\CurrentControlSet\Control\Lsa\Kerberos,,16 +HKLM,System\CurrentControlSet\Control\Lsa\MSV1_0,,16 HKLM,System\CurrentControlSet\Control\SecurityProviders\Schannel\Protocols\SSL 2.0\Client,"DisabledByDefault",0x10003,1 HKLM,System\CurrentControlSet\Control\ServiceGroupOrder,"List",0x00010000,"TDI" HKLM,System\CurrentControlSet\Control\TimeZoneInformation,"StandardName",2,"" -- 2.30.2

2 1

[PATCH] winex11.drv: Handle Vulkan surface creation with NULL hwnd.
by Paul Gofman 30 Apr '21

30 Apr '21

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- For Red Dead Redemption 2. dlls/vulkan-1/tests/vulkan.c | 112 ++++++++++++++++++++++++++++++++++- dlls/winex11.drv/vulkan.c | 38 +++++++++--- dlls/winex11.drv/window.c | 20 +++++++ dlls/winex11.drv/x11drv.h | 1 + 4 files changed, 160 insertions(+), 11 deletions(-) diff --git a/dlls/vulkan-1/tests/vulkan.c b/dlls/vulkan-1/tests/vulkan.c index 9061b2b6db8..e516d0d61c8 100644 --- a/dlls/vulkan-1/tests/vulkan.c +++ b/dlls/vulkan-1/tests/vulkan.c @@ -437,7 +437,102 @@ static void test_private_data(VkPhysicalDevice vk_physical_device) vkDestroyDevice(vk_device, NULL); } -static void for_each_device(void (*test_func)(VkPhysicalDevice)) +static const char *test_null_hwnd_extensions[] = +{ + "VK_KHR_surface", + "VK_KHR_win32_surface", +}; + +static void test_null_hwnd(VkInstance vk_instance, VkPhysicalDevice vk_physical_device) +{ + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR pvkGetPhysicalDeviceSurfacePresentModesKHR; + VkDeviceGroupPresentModeFlagsKHR present_mode_flags; + VkWin32SurfaceCreateInfoKHR surface_create_info; + VkSurfaceCapabilitiesKHR surf_caps; + VkSurfaceFormatKHR *formats; + uint32_t queue_family_index; + VkPresentModeKHR *modes; + VkSurfaceKHR surface; + VkDevice vk_device; + uint32_t count; + VkRect2D rect; + VkBool32 bval; + VkResult vr; + + pvkGetPhysicalDeviceSurfacePresentModesKHR = (void *)vkGetInstanceProcAddr(vk_instance, + "vkGetPhysicalDeviceSurfacePresentModesKHR"); + surface_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; + surface_create_info.pNext = NULL; + surface_create_info.flags = 0; + surface_create_info.hinstance = NULL; + surface_create_info.hwnd = NULL; + + bval = find_queue_family(vk_physical_device, VK_QUEUE_GRAPHICS_BIT, &queue_family_index); + ok(bval, "Could not find presentation queue.\n"); + + surface = 0xdeadbeef; + vr = vkCreateWin32SurfaceKHR(vk_instance, &surface_create_info, NULL, &surface); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(surface != 0xdeadbeef, "Surface not created.\n"); + + count = 0; + vr = vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device, surface, &count, NULL); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(count, "Got zero count.\n"); + formats = heap_alloc(sizeof(*formats) * count); + vr = vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device, surface, &count, formats); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + heap_free(formats); + + vr = vkGetPhysicalDeviceSurfaceSupportKHR(vk_physical_device, queue_family_index, surface, &bval); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + + vr = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_physical_device, surface, &surf_caps); + ok(vr, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR succeeded.\n"); + + count = 0; + vr = pvkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device, surface, &count, NULL); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(count, "Got zero count.\n"); + modes = heap_alloc(sizeof(*modes) * count); + vr = pvkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device, surface, &count, modes); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + heap_free(modes); + + count = 0; + vr = vkGetPhysicalDevicePresentRectanglesKHR(vk_physical_device, surface, &count, NULL); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(count == 1, "Got unexpected count %u.\n", count); + memset(&rect, 0xcc, sizeof(rect)); + vr = vkGetPhysicalDevicePresentRectanglesKHR(vk_physical_device, surface, &count, &rect); + if (vr == VK_SUCCESS) /* Fails on AMD, succeeds on Nvidia. */ + { + ok(count == 1, "Got unexpected count %u.\n", count); + ok(!rect.offset.x && !rect.offset.y && !rect.extent.width && !rect.extent.height, + "Got unexpected rect %d, %d, %u, %u.\n", + rect.offset.x, rect.offset.y, rect.extent.width, rect.extent.height); + } + + if ((vr = create_device(vk_physical_device, 0, NULL, NULL, &vk_device)) < 0) + { + skip("Failed to create device, vr %d.\n", vr); + vkDestroySurfaceKHR(vk_instance, surface, NULL); + return; + } + + if (0) + { + /* Causes access violation on Windows. */ + vr = vkGetDeviceGroupSurfacePresentModesKHR(vk_device, surface, &present_mode_flags); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + } + + vkDestroyDevice(vk_device, NULL); + vkDestroySurfaceKHR(vk_instance, surface, NULL); +} + +static void for_each_device_instance(uint32_t extension_count, const char * const *enabled_extensions, + void (*test_func_instance)(VkInstance, VkPhysicalDevice), void (*test_func)(VkPhysicalDevice)) { VkPhysicalDevice *vk_physical_devices; VkInstance vk_instance; @@ -445,7 +540,7 @@ static void for_each_device(void (*test_func)(VkPhysicalDevice)) uint32_t count; VkResult vr; - if ((vr = create_instance_skip(0, NULL, &vk_instance)) < 0) + if ((vr = create_instance_skip(extension_count, enabled_extensions, &vk_instance)) < 0) return; ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); @@ -463,13 +558,23 @@ static void for_each_device(void (*test_func)(VkPhysicalDevice)) ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr); for (i = 0; i < count; ++i) - test_func(vk_physical_devices[i]); + { + if (test_func_instance) + test_func_instance(vk_instance, vk_physical_devices[i]); + else + test_func(vk_physical_devices[i]); + } heap_free(vk_physical_devices); vkDestroyInstance(vk_instance, NULL); } +static void for_each_device(void (*test_func)(VkPhysicalDevice)) +{ + for_each_device_instance(0, NULL, NULL, test_func); +} + START_TEST(vulkan) { test_instance_version(); @@ -481,4 +586,5 @@ START_TEST(vulkan) test_unsupported_instance_extensions(); for_each_device(test_unsupported_device_extensions); for_each_device(test_private_data); + for_each_device_instance(ARRAY_SIZE(test_null_hwnd_extensions), test_null_hwnd_extensions, test_null_hwnd, NULL); } diff --git a/dlls/winex11.drv/vulkan.c b/dlls/winex11.drv/vulkan.c index 139faf6b407..c8ba68c888f 100644 --- a/dlls/winex11.drv/vulkan.c +++ b/dlls/winex11.drv/vulkan.c @@ -62,6 +62,7 @@ struct wine_vk_surface LONG ref; Window window; VkSurfaceKHR surface; /* native surface */ + BOOL dummy_surface; }; typedef struct VkXlibSurfaceCreateInfoKHR @@ -255,14 +256,18 @@ static VkResult X11DRV_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *create_info, const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain) { + struct wine_vk_surface *x11_surface = surface_from_handle(create_info->surface); VkSwapchainCreateInfoKHR create_info_host; TRACE("%p %p %p %p\n", device, create_info, allocator, swapchain); if (allocator) FIXME("Support for allocation callbacks not implemented yet\n"); + if (x11_surface->dummy_surface) + return VK_ERROR_SURFACE_LOST_KHR; + create_info_host = *create_info; - create_info_host.surface = surface_from_handle(create_info->surface)->surface; + create_info_host.surface = x11_surface->surface; return pvkCreateSwapchainKHR(device, &create_info_host, NULL /* allocator */, swapchain); } @@ -281,7 +286,7 @@ static VkResult X11DRV_vkCreateWin32SurfaceKHR(VkInstance instance, FIXME("Support for allocation callbacks not implemented yet\n"); /* TODO: support child window rendering. */ - if (GetAncestor(create_info->hwnd, GA_PARENT) != GetDesktopWindow()) + if (create_info->hwnd && GetAncestor(create_info->hwnd, GA_PARENT) != GetDesktopWindow()) { FIXME("Application requires child window rendering, which is not implemented yet!\n"); return VK_ERROR_INCOMPATIBLE_DRIVER; @@ -292,8 +297,10 @@ static VkResult X11DRV_vkCreateWin32SurfaceKHR(VkInstance instance, return VK_ERROR_OUT_OF_HOST_MEMORY; x11_surface->ref = 1; + x11_surface->dummy_surface = !create_info->hwnd; + x11_surface->window = x11_surface->dummy_surface ? create_dummy_client_window() + : create_client_window(create_info->hwnd, &default_visual); - x11_surface->window = create_client_window(create_info->hwnd, &default_visual); if (!x11_surface->window) { ERR("Failed to allocate client window for hwnd=%p\n", create_info->hwnd); @@ -316,13 +323,16 @@ static VkResult X11DRV_vkCreateWin32SurfaceKHR(VkInstance instance, goto err; } - EnterCriticalSection(&context_section); - if (!XFindContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char **)&prev)) + if (!x11_surface->dummy_surface) { - wine_vk_surface_release(prev); + EnterCriticalSection(&context_section); + if (!XFindContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char **)&prev)) + { + wine_vk_surface_release(prev); + } + XSaveContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char *)wine_vk_surface_grab(x11_surface)); + LeaveCriticalSection(&context_section); } - XSaveContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char *)wine_vk_surface_grab(x11_surface)); - LeaveCriticalSection(&context_section); *surface = (uintptr_t)x11_surface; @@ -456,6 +466,15 @@ static VkResult X11DRV_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(surface), count, rects); + if (x11_surface->dummy_surface) + { + if (rects) + return VK_ERROR_SURFACE_LOST_KHR; + + *count = 1; + return VK_SUCCESS; + } + return pvkGetPhysicalDevicePresentRectanglesKHR(phys_dev, x11_surface->surface, count, rects); } @@ -485,6 +504,9 @@ static VkResult X11DRV_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevic TRACE("%p, 0x%s, %p\n", phys_dev, wine_dbgstr_longlong(surface), capabilities); + if (x11_surface->dummy_surface) + return VK_ERROR_SURFACE_LOST_KHR; + return pvkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev, x11_surface->surface, capabilities); } diff --git a/dlls/winex11.drv/window.c b/dlls/winex11.drv/window.c index baaa30d74e3..1f0d636a142 100644 --- a/dlls/winex11.drv/window.c +++ b/dlls/winex11.drv/window.c @@ -1466,6 +1466,26 @@ static Window get_dummy_parent(void) } +/********************************************************************** + * create_dummy_window + */ +Window create_dummy_client_window(void) +{ + XSetWindowAttributes attr; + + attr.colormap = default_colormap; + attr.bit_gravity = NorthWestGravity; + attr.win_gravity = NorthWestGravity; + attr.backing_store = NotUseful; + attr.border_pixel = 0; + + return XCreateWindow( gdi_display, + get_dummy_parent(), + 0, 0, 1, 1, 0, default_visual.depth, InputOutput, + default_visual.visual, CWBitGravity | CWWinGravity | + CWBackingStore | CWColormap | CWBorderPixel, &attr ); +} + /********************************************************************** * create_client_window */ diff --git a/dlls/winex11.drv/x11drv.h b/dlls/winex11.drv/x11drv.h index 45855976607..2362dfd9563 100644 --- a/dlls/winex11.drv/x11drv.h +++ b/dlls/winex11.drv/x11drv.h @@ -601,6 +601,7 @@ extern void update_user_time( Time time ) DECLSPEC_HIDDEN; extern void read_net_wm_states( Display *display, struct x11drv_win_data *data ) DECLSPEC_HIDDEN; extern void update_net_wm_states( struct x11drv_win_data *data ) DECLSPEC_HIDDEN; extern void make_window_embedded( struct x11drv_win_data *data ) DECLSPEC_HIDDEN; +extern Window create_dummy_client_window(void) DECLSPEC_HIDDEN; extern Window create_client_window( HWND hwnd, const XVisualInfo *visual ) DECLSPEC_HIDDEN; extern void set_window_visual( struct x11drv_win_data *data, const XVisualInfo *vis, BOOL use_alpha ) DECLSPEC_HIDDEN; extern void change_systray_owner( Display *display, Window systray_window ) DECLSPEC_HIDDEN; -- 2.31.1

2 3

[PATCH v2] msado15: Use Recordset_Open in Connection_Execute
by Alistair Leslie-Hughes 30 Apr '21

30 Apr '21

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/msado15/connection.c | 78 ++++++++-------------------------- dlls/msado15/msado15_private.h | 2 - dlls/msado15/recordset.c | 42 ++++++++++++++++++ 3 files changed, 59 insertions(+), 63 deletions(-) diff --git a/dlls/msado15/connection.c b/dlls/msado15/connection.c index a3c9a450be6..ce7750fef66 100644 --- a/dlls/msado15/connection.c +++ b/dlls/msado15/connection.c @@ -292,98 +292,54 @@ static HRESULT WINAPI connection_Close( _Connection *iface ) return S_OK; } -HRESULT create_command_text(IUnknown *session, BSTR command, ICommandText **cmd_text) -{ - HRESULT hr; - IOpenRowset *openrowset; - ICommandText *command_text; - ICommand *cmd; - IDBCreateCommand *create_command; - - hr = IUnknown_QueryInterface(session, &IID_IOpenRowset, (void**)&openrowset); - if (FAILED(hr)) - return hr; - - hr = IOpenRowset_QueryInterface(openrowset, &IID_IDBCreateCommand, (void**)&create_command); - IOpenRowset_Release(openrowset); - if (FAILED(hr)) - return hr; - - hr = IDBCreateCommand_CreateCommand(create_command, NULL, &IID_IUnknown, (IUnknown **)&cmd); - IDBCreateCommand_Release(create_command); - if (FAILED(hr)) - return hr; - - hr = ICommand_QueryInterface(cmd, &IID_ICommandText, (void**)&command_text); - ICommand_Release(cmd); - if (FAILED(hr)) - { - FIXME("Currently only ICommandText interface is support\n"); - return hr; - } - - hr = ICommandText_SetCommandText(command_text, &DBGUID_DEFAULT, command); - if (FAILED(hr)) - { - ICommandText_Release(command_text); - return hr; - } - - *cmd_text = command_text; - - return S_OK; -} - static HRESULT WINAPI connection_Execute( _Connection *iface, BSTR command, VARIANT *records_affected, LONG options, _Recordset **record_set ) { struct connection *connection = impl_from_Connection( iface ); HRESULT hr; - ICommandText *command_text; - DBROWCOUNT affected; - IUnknown *rowset; _Recordset *recordset; - ADORecordsetConstruction *construct; + VARIANT source, active; + IDispatch *dispatch; FIXME( "%p, %s, %p, 0x%08x, %p Semi-stub\n", iface, debugstr_w(command), records_affected, options, record_set ); if (connection->state == adStateClosed) return MAKE_ADO_HRESULT( adErrObjectClosed ); - hr = create_command_text(connection->session, command, &command_text); + hr = Recordset_create( (void**)&recordset); if (FAILED(hr)) + { return hr; + } - hr = ICommandText_Execute(command_text, NULL, &IID_IUnknown, NULL, &affected, &rowset); - ICommandText_Release(command_text); - if (FAILED(hr)) - return hr; + _Recordset_put_CursorLocation(recordset, connection->location); - hr = Recordset_create( (void**)&recordset); + V_VT(&source) = VT_BSTR; + V_BSTR(&source) = command; + + hr = _Connection_QueryInterface(&connection->Connection_iface, &IID_IDispatch, (void**)&dispatch); if (FAILED(hr)) { - IUnknown_Release(rowset); + _Recordset_Release(recordset); return hr; } - hr = _Recordset_QueryInterface(recordset, &IID_ADORecordsetConstruction, (void**)&construct); + V_VT(&active) = VT_DISPATCH; + V_DISPATCH(&active) = dispatch; + + hr = _Recordset_Open(recordset, source, active, adOpenDynamic, adLockPessimistic, 0); + VariantClear(&active); if (FAILED(hr)) { - IUnknown_Release(rowset); _Recordset_Release(recordset); return hr; } - ADORecordsetConstruction_put_Rowset(construct, rowset); - ADORecordsetConstruction_Release(construct); - IUnknown_Release(rowset); - if (records_affected) { V_VT(records_affected) = VT_I4; - V_I4(records_affected) = affected; + _Recordset_get_RecordCount(recordset, &V_I4(records_affected)); } - _Recordset_put_CursorLocation(recordset, connection->location); *record_set = recordset; return hr; diff --git a/dlls/msado15/msado15_private.h b/dlls/msado15/msado15_private.h index 600dcb90a97..bb55eaaa3aa 100644 --- a/dlls/msado15/msado15_private.h +++ b/dlls/msado15/msado15_private.h @@ -26,8 +26,6 @@ HRESULT Connection_create( void ** ) DECLSPEC_HIDDEN; HRESULT Recordset_create( void ** ) DECLSPEC_HIDDEN; HRESULT Stream_create( void ** ) DECLSPEC_HIDDEN; -HRESULT create_command_text(IUnknown *session, BSTR command, ICommandText **cmd_text) DECLSPEC_HIDDEN; - static inline void *heap_realloc_zero( void *mem, SIZE_T len ) { if (!mem) return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, len ); diff --git a/dlls/msado15/recordset.c b/dlls/msado15/recordset.c index d71904193c9..2b32dc6cf94 100644 --- a/dlls/msado15/recordset.c +++ b/dlls/msado15/recordset.c @@ -1417,6 +1417,48 @@ static HRESULT WINAPI recordset_MoveLast( _Recordset *iface ) return S_OK; } +static HRESULT create_command_text(IUnknown *session, BSTR command, ICommandText **cmd_text) +{ + HRESULT hr; + IOpenRowset *openrowset; + ICommandText *command_text; + ICommand *cmd; + IDBCreateCommand *create_command; + + hr = IUnknown_QueryInterface(session, &IID_IOpenRowset, (void**)&openrowset); + if (FAILED(hr)) + return hr; + + hr = IOpenRowset_QueryInterface(openrowset, &IID_IDBCreateCommand, (void**)&create_command); + IOpenRowset_Release(openrowset); + if (FAILED(hr)) + return hr; + + hr = IDBCreateCommand_CreateCommand(create_command, NULL, &IID_IUnknown, (IUnknown **)&cmd); + IDBCreateCommand_Release(create_command); + if (FAILED(hr)) + return hr; + + hr = ICommand_QueryInterface(cmd, &IID_ICommandText, (void**)&command_text); + ICommand_Release(cmd); + if (FAILED(hr)) + { + FIXME("Currently only ICommandText interface is support\n"); + return hr; + } + + hr = ICommandText_SetCommandText(command_text, &DBGUID_DEFAULT, command); + if (FAILED(hr)) + { + ICommandText_Release(command_text); + return hr; + } + + *cmd_text = command_text; + + return S_OK; +} + static HRESULT WINAPI recordset_Open( _Recordset *iface, VARIANT source, VARIANT active_connection, CursorTypeEnum cursor_type, LockTypeEnum lock_type, LONG options ) { -- 2.30.2

2 1

[PATCH v9 1/2] ntdll: Strip trailing slashes after looking up unix name.
by Gabriel Ivăncescu 30 Apr '21

30 Apr '21

As they are useless anyway, and have inconsistencies, plus not useful to new code that assumes there's not any on the unix side. See: https://www.winehq.org/pipermail/wine-devel/2021-April/185850.html Note that the root / is not stripped, which is still correct. Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- winepath still reports multiple slashes, but I checked the trace from this, it doesn't return trailing slash anymore (except for / root component), so that's an unrelated problem in winepath, I think. dlls/ntdll/unix/file.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/dlls/ntdll/unix/file.c b/dlls/ntdll/unix/file.c index 2f18325..ec0beaa 100644 --- a/dlls/ntdll/unix/file.c +++ b/dlls/ntdll/unix/file.c @@ -3155,6 +3155,8 @@ static NTSTATUS lookup_unix_name( const WCHAR *name, int name_len, char **buffer char *p; unix_name[pos + 1 + ret] = 0; for (p = unix_name + pos ; *p; p++) if (*p == '\\') *p = '/'; + while (p - 1 > unix_name && p[-1] == '/') p--; + *p = 0; if (!stat( unix_name, &st )) { if (disposition == FILE_CREATE) return STATUS_OBJECT_NAME_COLLISION; @@ -3221,6 +3223,12 @@ static NTSTATUS lookup_unix_name( const WCHAR *name, int name_len, char **buffer name = next; } + if (status == STATUS_SUCCESS || status == STATUS_NO_SUCH_FILE) + { + char *p = unix_name + strlen( unix_name ); + while (p - 1 > unix_name && p[-1] == '/') p--; + *p = 0; + } return status; } -- 2.30.0

2 4

[tools 1/2] winetest/build-patterns: Detect fixed failures at the report level.
by Francois Gouget 30 Apr '21

30 Apr '21

If a test configuration had a high failure rate and no longer has any failure, it is not necessary to wait for $patternbuilds builds to consider the failure fixed. Then if the failures are fixed in all test configurations, the test unit can be moved to the old/fixed failures list. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- winetest/build-patterns | 81 ++++++++++++++++++++++++++++++++++++++++- winetest/winetest.conf | 3 ++ 2 files changed, 82 insertions(+), 2 deletions(-) diff --git a/winetest/build-patterns b/winetest/build-patterns index 32bae6b31..6a14fc372 100755 --- a/winetest/build-patterns +++ b/winetest/build-patterns @@ -31,7 +31,7 @@ sub BEGIN } unshift @INC, $1 if ($0 =~ m=^(/.*)/[^/]+$=); } -use vars qw/$workdir $gitdir $patternbuilds/; +use vars qw/$workdir $gitdir $patternbuilds $fixed_threshold/; require "winetest.conf"; my $name0=$0; @@ -275,6 +275,20 @@ my %reports; # The @sortedbuilds index of the most recent build with a failure. # -1 if there is none. # +# - failures +# The number of builds that had a failure between the first and last failure +# builds. +# +# - failruns +# The number of test results between the first and last failure builds. +# Note that if there are builds for which WineTest was not run this will be +# different from last-first+1. +# +# - fixedruns +# The number of successful test results following last. Note that if +# WineTest was not run (yet?) for some builds this will be different from +# @sortedbuilds-last. +# # - status # A hashtable of test results indexed by the build name. my %tests; @@ -389,6 +403,34 @@ sub fail_type($) "random"; } +sub get_fix_probability($$$) +{ + my ($failures, $failruns, $fixedruns) = @_; + + # We want a lower bound on the failure rate so we get a lower bound on the + # probability that a failure is fixed. + # So ideally we would compute the lowest failure rate that has a + # probability greater than some arbitrary value of giving us $failures in + # $failruns runs. + # - For instance a failure rate of 100% would obviously give us 2 failures + # out of 2 runs. But there is also a 49% chance for a 70% failure rate to + # have the same result. So the lowest failure rate that has more than + # an arbitrary 50% chance of matching this result is ~71%. + # - But that's hard to compute in the general case. + # - So instead just convert one failure to success and compute the ratio. + # - This gives a 0% failure rate for the 1/1 case which is fine because + # this case really does not have not enough data to derive a failure rate. + # - For the 2/2 case this gives 50% instead of a more likely value like 71%. + # But that's still good enough for our purpose. + # - The results continue on the low side up to at least $failruns=10 and + # then the difference is pretty small anyway. + my $failrate = ($failures - 1) / $failruns; + + # Then compute the probability of getting $fixedruns successes in a row. + # The complement is the probability that the failure has been fixed. + return 1 - (1 - $failrate) ** $fixedruns; +} + foreach my $testname (keys %tests) { my $test = $tests{$testname}; @@ -404,6 +446,11 @@ foreach my $testname (keys %tests) $testreport->{last} = -1; # - Type of failure: random or not (missing dll, etc.) $testreport->{failtype} = ""; + # - Statistics to compute the failure rate + $testreport->{failures} = 0; + $testreport->{failruns} = 0; + # - And the number of successful runs after the last failure + $testreport->{fixedruns} = 0; for my $i (0..@sortedbuilds-1) { @@ -415,6 +462,7 @@ foreach my $testname (keys %tests) $build->{hastest}->{$testname}) { $testreport->{failtype} ||= 0; # success + $testreport->{fixedruns}++; } # else WineTest was not run for this build next; @@ -437,12 +485,39 @@ foreach my $testname (keys %tests) $testreport->{first} = $i; $testreport->{last} = $i; $testreport->{failtype} = $failtype; + $testreport->{failures} = 1; + # Assume the bug was introduced with the first failure and thus + # ignore successful runs that preceded it. + $testreport->{failruns} = 1; + $testreport->{fixedruns} = 0; } else { $testreport->{last} = $i; + $testreport->{failures}++; + $testreport->{failruns} += $testreport->{fixedruns} + 1; + $testreport->{fixedruns} = 0; } } + next if (!$testreport->{failed}); + next if (!$testreport->{fixedruns}); + + if ($testreport->{failtype} eq "random") + { + # - failruns counts the number of runs from the first to the last + # failure. + # - Both failruns and fixedruns account for the builds where the + # test was not run. + # - So for instance '...eeeF._F.._' gives failures=2 (not 5), + # failruns=3 (not 4, 9 or 10), and fixedruns=2 (not 3). + $testreport->{fixed} = get_fix_probability($testreport->{failures}, $testreport->{failruns}, $testreport->{fixedruns}); + } + else + { + # Since this failure is not random, even a single success means + # it is fixed. + $testreport->{fixed} = 1; + } } } @@ -710,11 +785,13 @@ EOF my $first = @sortedbuilds; my $last = -1; + my $fixed = 1; foreach my $reportdir (keys %$pagereports) { my $testreport = $test->{testreports}->{$reportdir}; next if (!$testreport->{failed}); + $fixed = 0 if (($testreport->{fixed} || 0) < $fixed_threshold); $first = $testreport->{first} if ($testreport->{first} < $first); # For non-random failures we only care about the transition to # the failure state, which is recorded in 'first'. @@ -732,7 +809,7 @@ EOF } next if ($last == -1); # no report had a pattern of interest - my $listid = ($last < @sortedbuilds - $patternbuilds) ? "old" : + my $listid = ($fixed or $last < @sortedbuilds - $patternbuilds) ? "old" : ($first > $patternbuilds) ? "recent" : "regular"; push @{$lists{$listid}->{testnames}}, $testname; diff --git a/winetest/winetest.conf b/winetest/winetest.conf index f193f8eed..1f587b3bc 100644 --- a/winetest/winetest.conf +++ b/winetest/winetest.conf @@ -27,4 +27,7 @@ $maxfilesize = 1.5 * 1024 * 1024; # The number of builds after which a failure is considered old / new $patternbuilds = 10; +# Probability above which a failure is considered to be fixed (0..1) +$fixed_threshold = 0.99; + 1; # keep require happy -- 2.20.1

1 1

[PATCH] kernel32/tests: Add a trailing linefeed to an ok() message.
by Francois Gouget 30 Apr '21

30 Apr '21

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/kernel32/tests/process.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/kernel32/tests/process.c b/dlls/kernel32/tests/process.c index b932a3c2a15..f960efb05a8 100644 --- a/dlls/kernel32/tests/process.c +++ b/dlls/kernel32/tests/process.c @@ -3857,7 +3857,7 @@ static void test_GetSystemCpuSetInformation(void) ok(ret && GetLastError() == 0xdeadbeef, "Got unexpected ret %#x, GetLastError() %u.\n", ret, GetLastError()); ok(size == expected_size, "Got unexpected size %u.\n", size); - ok(!memcmp(info, info_nt, expected_size), "Info does not match NtQuerySystemInformationEx()."); + ok(!memcmp(info, info_nt, expected_size), "Info does not match NtQuerySystemInformationEx().\n"); heap_free(info_nt); heap_free(info); -- 2.20.1

2 1

[PATCH 1/7] reg/tests: Add and amend tests adding a (Default) value
by Hugh McMaster 30 Apr '21

30 Apr '21

Signed-off-by: Hugh McMaster <hugh.mcmaster(a)outlook.com> --- programs/reg/tests/add.c | 71 ++++++++++++++++++++++++++++------------ 1 file changed, 50 insertions(+), 21 deletions(-) diff --git a/programs/reg/tests/add.c b/programs/reg/tests/add.c index fdd09c885bc..3ac4ca800dd 100644 --- a/programs/reg/tests/add.c +++ b/programs/reg/tests/add.c @@ -404,6 +404,16 @@ static void test_reg_none(void) add_key(HKEY_CURRENT_USER, KEY_BASE, &hkey); + run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_NONE /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r); + todo_wine verify_reg(hkey, NULL, REG_NONE, "\0", 2, 0); + + todo_wine delete_value(hkey, NULL); + + run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_NONE /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); + verify_reg(hkey, NULL, REG_NONE, "\0", 2, 0); + run_reg_exe("reg add HKCU\\" KEY_BASE " /v none0 /d deadbeef /t REG_NONE /f", &r); ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r); verify_reg(hkey, "none0", REG_NONE, "d\0e\0a\0d\0b\0e\0e\0f\0\0", 18, 0); @@ -412,10 +422,6 @@ static void test_reg_none(void) ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); verify_reg(hkey, "none1", REG_NONE, "\0", 2, 0); - run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_NONE /f", &r); - ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); - verify_reg(hkey, NULL, REG_NONE, "\0", 2, 0); - close_key(hkey); delete_key(HKEY_CURRENT_USER, KEY_BASE); } @@ -427,6 +433,10 @@ static void test_reg_sz(void) add_key(HKEY_CURRENT_USER, KEY_BASE, &hkey); + run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_SZ /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); + todo_wine verify_reg(hkey, NULL, REG_SZ, "", 1, 0); + run_reg_exe("reg add HKCU\\" KEY_BASE " /d WineTest /f", &r); ok(r == REG_EXIT_SUCCESS || broken(r == REG_EXIT_FAILURE /* WinXP */), "got exit code %d, expected 0\n", r); @@ -501,6 +511,16 @@ static void test_reg_expand_sz(void) add_key(HKEY_CURRENT_USER, KEY_BASE, &hkey); + run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_EXPAND_SZ /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); + todo_wine verify_reg(hkey, NULL, REG_EXPAND_SZ, "", 1, 0); + + todo_wine delete_value(hkey, NULL); + + run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_EXPAND_SZ /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); + verify_reg(hkey, NULL, REG_EXPAND_SZ, "", 1, 0); + run_reg_exe("reg add HKCU\\" KEY_BASE " /v expand0 /t REG_EXpand_sz /d \"dead%PATH%beef\" /f", &r); ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); verify_reg(hkey, "expand0", REG_EXPAND_SZ, "dead%PATH%beef", 15, 0); @@ -521,10 +541,6 @@ static void test_reg_expand_sz(void) ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); verify_reg(hkey, "expand3", REG_EXPAND_SZ, "", 1, 0); - run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_EXPAND_SZ /f", &r); - ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); - verify_reg(hkey, NULL, REG_EXPAND_SZ, "", 1, 0); - close_key(hkey); delete_key(HKEY_CURRENT_USER, KEY_BASE); } @@ -538,15 +554,25 @@ static void test_reg_binary(void) add_key(HKEY_CURRENT_USER, KEY_BASE, &hkey); - run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin0 /f", &r); + run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /f", &r); ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); - verify_reg(hkey, "bin0", REG_BINARY, buffer, 0, 0); + todo_wine verify_reg(hkey, NULL, REG_BINARY, buffer, 0, 0); + + todo_wine delete_value(hkey, NULL); + + run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_BINARY /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); + verify_reg(hkey, NULL, REG_BINARY, buffer, 0, 0); run_reg_exe("reg add HKEY_CURRENT_USER\\" KEY_BASE " /ve /t REG_BINARY /d deadbeef /f", &r); ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); dword = 0xefbeadde; verify_reg(hkey, "", REG_BINARY, &dword, sizeof(DWORD), 0); + run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin0 /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); + verify_reg(hkey, "bin0", REG_BINARY, buffer, 0, 0); + run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_BINARY /v bin1 /f /d 0xDeAdBeEf", &r); ok(r == REG_EXIT_FAILURE, "got exit code %u, expected 1\n", r); @@ -579,10 +605,6 @@ static void test_reg_binary(void) run_reg_exe("reg add HKCU\\" KEY_BASE " /v bin6 /t REG_BINARY /f /d", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_BINARY /f", &r); - ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); - verify_reg(hkey, NULL, REG_BINARY, buffer, 0, 0); - close_key(hkey); delete_key(HKEY_CURRENT_USER, KEY_BASE); } @@ -604,6 +626,9 @@ static void test_reg_dword(void) else win_skip("broken reg.exe detected\n"); + run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_DWORD /f", &r); + ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u, expected 1\n", r); + run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword0 /t REG_DWORD /f /d", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); @@ -667,9 +692,6 @@ static void test_reg_dword(void) run_reg_exe("reg add HKCU\\" KEY_BASE " /v dword15 /t REG_DWORD /d 4294967296 /f", &r); ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u, expected 1\n", r); - run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_DWORD /f", &r); - ok(r == REG_EXIT_FAILURE || broken(r == REG_EXIT_SUCCESS /* WinXP */), "got exit code %u, expected 1\n", r); - /* REG_DWORD_LITTLE_ENDIAN */ run_reg_exe("reg add HKCU\\" KEY_BASE " /v DWORD_LE /t REG_DWORD_LITTLE_ENDIAN /d 456 /f", &r); ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r); @@ -705,6 +727,17 @@ static void test_reg_multi_sz(void) add_key(HKEY_CURRENT_USER, KEY_BASE, &hkey); + run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_MULTI_SZ /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); + buffer[0] = 0; + todo_wine verify_reg(hkey, NULL, REG_MULTI_SZ, buffer, 1, 0); + + todo_wine delete_value(hkey, NULL); + + run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_MULTI_SZ /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); + verify_reg(hkey, NULL, REG_MULTI_SZ, buffer, 1, 0); + run_reg_exe("reg add HKCU\\" KEY_BASE " /v multi0 /t REG_MULTI_SZ /d \"three\\0little\\0strings\" /f", &r); ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); memcpy(buffer, "three\0little\0strings\0", 22); @@ -786,10 +819,6 @@ static void test_reg_multi_sz(void) ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); verify_reg(hkey, "multi21", REG_MULTI_SZ, "two\\0\\0strings\0", 16, 0); - run_reg_exe("reg add HKCU\\" KEY_BASE " /ve /t REG_MULTI_SZ /f", &r); - ok(r == REG_EXIT_SUCCESS, "got exit code %u, expected 0\n", r); - verify_reg(hkey, NULL, REG_MULTI_SZ, buffer, 1, 0); - close_key(hkey); delete_key(HKEY_CURRENT_USER, KEY_BASE); } -- 2.31.1

1 6

[PATCH] pdh/tests: Add test for PdhOpenLog
by Nipun Garg 30 Apr '21

30 Apr '21

Signed-off-by: Nipun Garg <nipung271(a)gmail.com> --- dlls/pdh/tests/pdh.c | 21 +++++++++++++++++++++ include/pdh.h | 19 +++++++++++++++++++ 2 files changed, 40 insertions(+) diff --git a/dlls/pdh/tests/pdh.c b/dlls/pdh/tests/pdh.c index 71603f8c6ba..74fc0a20d80 100644 --- a/dlls/pdh/tests/pdh.c +++ b/dlls/pdh/tests/pdh.c @@ -126,6 +126,27 @@ static void test_PdhOpenQueryW( void ) ok(ret == PDH_INVALID_HANDLE, "PdhCloseQuery failed 0x%08x\n", ret); } +static void test_PdhOpenLogA( void ) +{ + PDH_STATUS ret; + PDH_HLOG log; + + ret = PdhOpenLogA( NULL, PDH_LOG_READ_ACCESS, PDH_LOG_TYPE_CSV, NULL, 0, NULL, NULL ); + ok(ret == PDH_INVALID_HANDLE, "PdhOpenLogA failed 0x%08x\n", ret); + + ret = PdhOpenLogA( NULL, PDH_LOG_READ_ACCESS, PDH_LOG_TYPE_CSV, NULL, 0, NULL, log ); + ok(ret == ERROR_SUCCESS, "PdhOpenLogA failed 0x%08x\n", ret); + + ret = PdhCloseLog( NULL, 0 ); + ok(ret == PDH_INVALID_HANDLE, "PdhCloseLog failed 0x%08x\n", ret); + + ret = PdhCloseLog( log, 0 ); + ok(ret == ERROR_SUCCESS, "PdhCloseLog failed 0x%08x\n", ret); + + ret = PdhCloseLog( log, 0 ); + ok(ret == PDH_INVALID_HANDLE, "PdhCloseLog failed 0x%08x\n", ret); +} + static void test_PdhAddCounterA( void ) { PDH_STATUS ret; diff --git a/include/pdh.h b/include/pdh.h index 3d688bd8ded..f3ea6ec7c1b 100644 --- a/include/pdh.h +++ b/include/pdh.h @@ -57,6 +57,25 @@ typedef PDH_HLOG HLOG; #define DATA_SOURCE_LOGFILE 0x00000002 #define DATA_SOURCE_WBEM 0x00000004 +#define PDH_LOG_READ_ACCESS 0x00010000 +#define PDH_LOG_WRITE_ACCESS 0x00020000 +#define PDH_LOG_UPDATE_ACCESS 0x00040000 + +#define PDH_LOG_CREATE_NEW 0x00000001 +#define PDH_LOG_CREATE_ALWAYS 0x00000002 +#define PDH_LOG_OPEN_ALWAYS 0x00000003 +#define PDH_LOG_OPEN_EXISTING 0x00000004 +#define PDH_LOG_OPT_USER_STRING 0x01000000 +#define PDH_LOG_OPT_CIRCULAR 0x02000000 + +#define PDH_LOG_TYPE_UNDEFINED 0x00000000 +#define PDH_LOG_TYPE_CSV 0x00000001 +#define PDH_LOG_TYPE_TSV 0x00000002 +#define PDH_LOG_TYPE_SQL 0x00000007 +#define PDH_LOG_TYPE_BINARY 0x00000008 + +#define PDH_FLAG_CLOSE_QUERY 0x00000001 + #ifdef WINE_NO_UNICODE_MACROS # define DECL_PDH_TYPE_AW(name) /* nothing */ #else /* WINE_NO_UNICODE_MACROS */ -- 2.30.0

2 1

[PATCH 12/12] msvcrt: Import nexttowardf implementation from musl.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 41 ++++++++++++++++++++++++++++++++++++----- dlls/msvcrt/unixlib.c | 14 -------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 36 insertions(+), 21 deletions(-)

1 0

[PATCH 11/12] msvcrt: Call nextafter in nexttoward implementation.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 8 +------- dlls/msvcrt/unixlib.c | 14 -------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 1 insertion(+), 23 deletions(-)

1 0

[PATCH 10/12] msvcrt: Import nextafterf implementation from musl.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/math.c | 40 +++++++++++++++++++++++++++++++++++++--- dlls/msvcrt/unixlib.c | 9 --------- dlls/msvcrt/unixlib.h | 1 - 3 files changed, 37 insertions(+), 13 deletions(-)

1 0

[PATCH 09/12] msvcrt: Import nextafter implementation from musl.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/math.c | 43 ++++++++++++++++++++++++++++++++++++++----- dlls/msvcrt/unixlib.c | 9 --------- dlls/msvcrt/unixlib.h | 1 - 3 files changed, 38 insertions(+), 15 deletions(-)

1 0

[PATCH 08/12] msvcrt: Import neabyint implementation from musl.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 11 +++++++++-- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 9 insertions(+), 17 deletions(-)

1 0

[PATCH 07/12] msvcrt: Import nearbyintf implementation from musl.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 11 +++++++++-- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 9 insertions(+), 17 deletions(-)

1 0

[PATCH 06/12] msvcrt: Implement llrintf using rintf function.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 9 ++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 8 insertions(+), 16 deletions(-)

1 0

[PATCH 05/12] msvcrt: Implement llrint using rint function.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 9 ++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 8 insertions(+), 16 deletions(-)

1 0

[PATCH 04/12] msvcrt: Implement lrintf using rintf function.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 9 ++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 8 insertions(+), 16 deletions(-)

1 0

[PATCH 02/12] msvcrt: Import rintf implementation from musl.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 19 ++++++++++++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 18 insertions(+), 16 deletions(-)

1 0

[PATCH 01/12] msvcrt: Import rint implementation from musl.
by Piotr Caban 30 Apr '21

30 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 21 ++++++++++++++++++--- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 18 insertions(+), 18 deletions(-)

1 0

[PATCH 1/3] winegstreamer: Fix integer overflow in scale_uint64.
by Anton Baskanov 30 Apr '21

30 Apr '21

Signed-off-by: Anton Baskanov <baskanov(a)gmail.com> --- dlls/winegstreamer/quartz_parser.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/winegstreamer/quartz_parser.c b/dlls/winegstreamer/quartz_parser.c index 243dc9f80ba..fbc9fd32628 100644 --- a/dlls/winegstreamer/quartz_parser.c +++ b/dlls/winegstreamer/quartz_parser.c @@ -597,8 +597,8 @@ static uint64_t scale_uint64(uint64_t value, uint32_t numerator, uint32_t denomi return 0; i.QuadPart = value; - low.QuadPart = i.u.LowPart * numerator; - high.QuadPart = i.u.HighPart * numerator + low.u.HighPart; + low.QuadPart = (ULONGLONG)i.u.LowPart * numerator; + high.QuadPart = (ULONGLONG)i.u.HighPart * numerator + low.u.HighPart; low.u.HighPart = 0; if (high.u.HighPart >= denominator) -- 2.25.1

4 11

[PATCH] msado15: Use Recordset_Open in Connection_Execute
by Alistair Leslie-Hughes 30 Apr '21

30 Apr '21

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/msado15/connection.c | 36 +++++++++++++++++------------------- 1 file changed, 17 insertions(+), 19 deletions(-) diff --git a/dlls/msado15/connection.c b/dlls/msado15/connection.c index a3c9a450be6..2d43aff787f 100644 --- a/dlls/msado15/connection.c +++ b/dlls/msado15/connection.c @@ -339,51 +339,49 @@ static HRESULT WINAPI connection_Execute( _Connection *iface, BSTR command, VARI { struct connection *connection = impl_from_Connection( iface ); HRESULT hr; - ICommandText *command_text; - DBROWCOUNT affected; - IUnknown *rowset; _Recordset *recordset; - ADORecordsetConstruction *construct; + VARIANT source, active; + IDispatch *dispatch; FIXME( "%p, %s, %p, 0x%08x, %p Semi-stub\n", iface, debugstr_w(command), records_affected, options, record_set ); if (connection->state == adStateClosed) return MAKE_ADO_HRESULT( adErrObjectClosed ); - hr = create_command_text(connection->session, command, &command_text); + hr = Recordset_create( (void**)&recordset); if (FAILED(hr)) + { return hr; + } - hr = ICommandText_Execute(command_text, NULL, &IID_IUnknown, NULL, &affected, &rowset); - ICommandText_Release(command_text); - if (FAILED(hr)) - return hr; + _Recordset_put_CursorLocation(recordset, connection->location); - hr = Recordset_create( (void**)&recordset); + V_VT(&source) = VT_BSTR; + V_BSTR(&source) = command; + + hr = _Connection_QueryInterface(&connection->Connection_iface, &IID_IDispatch, (void**)&dispatch); if (FAILED(hr)) { - IUnknown_Release(rowset); + _Recordset_Release(recordset); return hr; } - hr = _Recordset_QueryInterface(recordset, &IID_ADORecordsetConstruction, (void**)&construct); + V_VT(&active) = VT_DISPATCH; + V_DISPATCH(&active) = dispatch; + + hr = _Recordset_Open(recordset, source, active, adOpenDynamic, adLockPessimistic, 0); + VariantClear(&active); if (FAILED(hr)) { - IUnknown_Release(rowset); _Recordset_Release(recordset); return hr; } - ADORecordsetConstruction_put_Rowset(construct, rowset); - ADORecordsetConstruction_Release(construct); - IUnknown_Release(rowset); - if (records_affected) { V_VT(records_affected) = VT_I4; - V_I4(records_affected) = affected; + _Recordset_get_RecordCount(recordset, &V_I4(records_affected)); } - _Recordset_put_CursorLocation(recordset, connection->location); *record_set = recordset; return hr; -- 2.30.2

3 2

[PATCH 1/5] user32: Add a default MapVirtualKeyEx implementation.
by Rémi Bernon 30 Apr '21

30 Apr '21

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/user32/driver.c | 2 +- dlls/user32/input.c | 154 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 152 insertions(+), 4 deletions(-) diff --git a/dlls/user32/driver.c b/dlls/user32/driver.c index e5855e1c51b..aedc0366615 100644 --- a/dlls/user32/driver.c +++ b/dlls/user32/driver.c @@ -275,7 +275,7 @@ static HKL CDECL nulldrv_LoadKeyboardLayout( LPCWSTR name, UINT flags ) static UINT CDECL nulldrv_MapVirtualKeyEx( UINT code, UINT type, HKL layout ) { - return 0; + return -1; /* use default implementation */ } static BOOL CDECL nulldrv_RegisterHotKey( HWND hwnd, UINT modifiers, UINT vk ) diff --git a/dlls/user32/input.c b/dlls/user32/input.c index b21ec73696d..4eaac54343e 100644 --- a/dlls/user32/input.c +++ b/dlls/user32/input.c @@ -777,14 +777,162 @@ UINT WINAPI MapVirtualKeyExA(UINT code, UINT maptype, HKL hkl) return ret; } + +/* English keyboard layout (0x0409) */ +static const UINT kbd_en_vsc2vk[] = +{ + 0x00, 0x1b, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30, 0xbd, 0xbb, 0x08, 0x09, + 0x51, 0x57, 0x45, 0x52, 0x54, 0x59, 0x55, 0x49, 0x4f, 0x50, 0xdb, 0xdd, 0x0d, 0xa2, 0x41, 0x53, + 0x44, 0x46, 0x47, 0x48, 0x4a, 0x4b, 0x4c, 0xba, 0xde, 0xc0, 0xa0, 0xdc, 0x5a, 0x58, 0x43, 0x56, + 0x42, 0x4e, 0x4d, 0xbc, 0xbe, 0xbf, 0xa1, 0x6a, 0xa4, 0x20, 0x14, 0x70, 0x71, 0x72, 0x73, 0x74, + 0x75, 0x76, 0x77, 0x78, 0x79, 0x90, 0x91, 0x24, 0x26, 0x21, 0x6d, 0x25, 0x0c, 0x27, 0x6b, 0x23, + 0x28, 0x22, 0x2d, 0x2e, 0x2c, 0x00, 0xe2, 0x7a, 0x7b, 0x0c, 0xee, 0xf1, 0xea, 0xf9, 0xf5, 0xf3, + 0x00, 0x00, 0xfb, 0x2f, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0xed, + 0x00, 0xe9, 0x00, 0xc1, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x00, 0xeb, 0x09, 0x00, 0xc2, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 0xe000 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xb1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x0d, 0xa3, 0x00, 0x00, + 0xad, 0xb7, 0xb3, 0x00, 0xb2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae, 0x00, + 0xaf, 0x00, 0xac, 0x00, 0x00, 0x6f, 0x00, 0x2c, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x24, 0x26, 0x21, 0x00, 0x25, 0x00, 0x27, 0x00, 0x23, + 0x28, 0x22, 0x2d, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x5c, 0x5d, 0x00, 0x5f, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, 0xab, 0xa8, 0xa9, 0xa7, 0xa6, 0xb6, 0xb4, 0xb5, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* 0xe100 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +static const UINT kbd_en_vk2char[] = +{ + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x08, 0x09, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00, + ' ', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', + 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 0x00, 0x00, 0x00, 0x00, 0x00, + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '+', 0x00, '-', '.', '/', + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ';', '=', ',', '-', '.', '/', + '`', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, '[', '\\', ']', '\'', 0x00, + 0x00, 0x00, '\\', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + + /****************************************************************************** * MapVirtualKeyExW (USER32.@) */ -UINT WINAPI MapVirtualKeyExW(UINT code, UINT maptype, HKL hkl) +UINT WINAPI MapVirtualKeyExW( UINT code, UINT type, HKL layout ) { - TRACE_(keyboard)("(%X, %d, %p)\n", code, maptype, hkl); + const UINT *vsc2vk, *vk2char; + UINT vsc2vk_size, vk2char_size; + UINT ret; + + TRACE_(keyboard)( "code %u, type %u, layout %p.\n", code, type, layout ); - return USER_Driver->pMapVirtualKeyEx(code, maptype, hkl); + if ((ret = USER_Driver->pMapVirtualKeyEx( code, type, layout )) != -1) return ret; + + /* FIXME: English keyboard layout specific */ + + vsc2vk = kbd_en_vsc2vk; + vsc2vk_size = ARRAYSIZE(kbd_en_vsc2vk); + vk2char = kbd_en_vk2char; + vk2char_size = ARRAYSIZE(kbd_en_vk2char); + + switch (type) + { + case MAPVK_VK_TO_VSC_EX: + case MAPVK_VK_TO_VSC: + switch (code) + { + case VK_SHIFT: code = VK_LSHIFT; break; + case VK_CONTROL: code = VK_LCONTROL; break; + case VK_MENU: code = VK_LMENU; break; + case VK_NUMPAD0: code = VK_INSERT; break; + case VK_NUMPAD1: code = VK_END; break; + case VK_NUMPAD2: code = VK_DOWN; break; + case VK_NUMPAD3: code = VK_NEXT; break; + case VK_NUMPAD4: code = VK_LEFT; break; + case VK_NUMPAD5: code = VK_CLEAR; break; + case VK_NUMPAD6: code = VK_RIGHT; break; + case VK_NUMPAD7: code = VK_HOME; break; + case VK_NUMPAD8: code = VK_UP; break; + case VK_NUMPAD9: code = VK_PRIOR; break; + case VK_DECIMAL: code = VK_DELETE; break; + } + + for (ret = 0; ret < vsc2vk_size; ++ret) if (vsc2vk[ret] == code) break; + if (ret >= vsc2vk_size) ret = 0; + + if (type == MAPVK_VK_TO_VSC) + { + if (ret >= 0x200) ret = 0; + else ret &= 0xff; + } + else if (ret >= 0x100) ret += 0xdf00; + break; + case MAPVK_VSC_TO_VK: + case MAPVK_VSC_TO_VK_EX: + if (code & 0xe000) code -= 0xdf00; + if (code >= vsc2vk_size) ret = 0; + else ret = vsc2vk[code]; + + if (type == MAPVK_VSC_TO_VK) + { + switch (ret) + { + case VK_LSHIFT: case VK_RSHIFT: ret = VK_SHIFT; break; + case VK_LCONTROL: case VK_RCONTROL: ret = VK_CONTROL; break; + case VK_LMENU: case VK_RMENU: ret = VK_MENU; break; + } + } + break; + case MAPVK_VK_TO_CHAR: + if (code >= vk2char_size) ret = 0; + else ret = vk2char[code]; + break; + default: + FIXME_(keyboard)( "unknown type %d\n", type ); + return 0; + } + + TRACE_(keyboard)( "returning 0x%04x\n", ret ); + return ret; } /**************************************************************************** -- 2.31.0

2 7

[PATCH 6/6] msv1_0: Implement SpSealMessage and SpUnsealMessage.
by Hans Leidekker 30 Apr '21

30 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/main.c | 75 ++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 73 insertions(+), 2 deletions(-) diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c index 5e6372b138c..f61e3c90efe 100644 --- a/dlls/msv1_0/main.c +++ b/dlls/msv1_0/main.c @@ -1430,14 +1430,85 @@ static NTSTATUS NTAPI ntlm_SpVerifySignature( LSA_SEC_HANDLE handle, SecBufferDe return verify_signature( ctx, ctx->flags, msg, idx ); } +static NTSTATUS NTAPI ntlm_SpSealMessage( LSA_SEC_HANDLE handle, ULONG qop, SecBufferDesc *msg, ULONG msg_seq_no ) +{ + int token_idx, data_idx; + struct ntlm_ctx *ctx; + + TRACE( "%lx, %08x, %p %u\n", handle, qop, msg, msg_seq_no ); + if (qop) FIXME( "ignoring quality of protection %08x\n", qop ); + if (msg_seq_no) FIXME( "ignoring message sequence number %u\n", msg_seq_no ); + + if (!handle) return SEC_E_INVALID_HANDLE; + + if (!msg || !msg->pBuffers || msg->cBuffers < 2 || + (token_idx = get_buffer_index( msg, SECBUFFER_TOKEN )) == -1 || + (data_idx = get_buffer_index( msg, SECBUFFER_DATA )) == -1) return SEC_E_INVALID_TOKEN; + + if (msg->pBuffers[token_idx].cbBuffer < 16) return SEC_E_BUFFER_TOO_SMALL; + + ctx = (struct ntlm_ctx *)handle; + if (ctx->flags & FLAG_NEGOTIATE_NTLM2 && ctx->flags & FLAG_NEGOTIATE_SEAL) + { + create_signature( ctx, ctx->flags, msg, token_idx, SIGN_SEND, FALSE ); + + arc4_process( &ctx->crypt.ntlm2.send_arc4info, msg->pBuffers[data_idx].pvBuffer, + msg->pBuffers[data_idx].cbBuffer ); + if (ctx->flags & FLAG_NEGOTIATE_KEY_EXCHANGE) + arc4_process( &ctx->crypt.ntlm2.send_arc4info, (char *)msg->pBuffers[token_idx].pvBuffer + 4, 8 ); + } + else + { + char *sig = msg->pBuffers[token_idx].pvBuffer; + + create_signature( ctx, ctx->flags | FLAG_NEGOTIATE_SIGN, msg, token_idx, SIGN_SEND, FALSE ); + + arc4_process( &ctx->crypt.ntlm.arc4info, msg->pBuffers[data_idx].pvBuffer, msg->pBuffers[data_idx].cbBuffer ); + arc4_process( &ctx->crypt.ntlm.arc4info, sig + 4, 12 ); + + if (ctx->flags & FLAG_NEGOTIATE_ALWAYS_SIGN || !ctx->flags) memset( sig + 4, 0, 4 ); + } + + return SEC_E_OK; +} + +static NTSTATUS NTAPI ntlm_SpUnsealMessage( LSA_SEC_HANDLE handle, SecBufferDesc *msg, ULONG msg_seq_no, ULONG *qop ) +{ + int token_idx, data_idx; + struct ntlm_ctx *ctx; + + TRACE( "%lx, %p, %u, %p\n", handle, msg, msg_seq_no, qop ); + if (msg_seq_no) FIXME( "ignoring message sequence number %u\n", msg_seq_no ); + + if (!handle) return SEC_E_INVALID_HANDLE; + + if (!msg || !msg->pBuffers || msg->cBuffers < 2 || + (token_idx = get_buffer_index( msg, SECBUFFER_TOKEN )) == -1 || + (data_idx = get_buffer_index( msg, SECBUFFER_DATA )) == -1) return SEC_E_INVALID_TOKEN; + + if (msg->pBuffers[token_idx].cbBuffer < 16) return SEC_E_BUFFER_TOO_SMALL; + + ctx = (struct ntlm_ctx *)handle; + if (ctx->flags & FLAG_NEGOTIATE_NTLM2 && ctx->flags & FLAG_NEGOTIATE_SEAL) + arc4_process( &ctx->crypt.ntlm2.recv_arc4info, msg->pBuffers[data_idx].pvBuffer, + msg->pBuffers[data_idx].cbBuffer ); + else + arc4_process( &ctx->crypt.ntlm.arc4info, msg->pBuffers[data_idx].pvBuffer, + msg->pBuffers[data_idx].cbBuffer); + + /* make sure we use a session key for the signature check, SealMessage always does that, + even in the dummy case */ + return verify_signature( ctx, ctx->flags | FLAG_NEGOTIATE_SIGN, msg, token_idx ); +} + static SECPKG_USER_FUNCTION_TABLE ntlm_user_table = { ntlm_SpInstanceInit, NULL, /* SpInitUserModeContext */ ntlm_SpMakeSignature, ntlm_SpVerifySignature, - NULL, /* SpSealMessage */ - NULL, /* SpUnsealMessage */ + ntlm_SpSealMessage, + ntlm_SpUnsealMessage, NULL, /* SpGetContextToken */ NULL, /* SpQueryContextAttributes */ NULL, /* SpCompleteAuthToken */ -- 2.30.2

1 0

[PATCH 5/6] msv1_0: Implement SpVerifySignature.
by Hans Leidekker 30 Apr '21

30 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/main.c | 57 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-) diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c index d9b9d16fa64..5e6372b138c 100644 --- a/dlls/msv1_0/main.c +++ b/dlls/msv1_0/main.c @@ -1375,12 +1375,67 @@ static NTSTATUS NTAPI ntlm_SpMakeSignature( LSA_SEC_HANDLE handle, ULONG qop, Se return create_signature( ctx, ctx->flags, msg, idx, SIGN_SEND, TRUE ); } +static NTSTATUS verify_signature( struct ntlm_ctx *ctx, unsigned int flags, SecBufferDesc *msg, int idx ) +{ + NTSTATUS status; + unsigned int i; + SecBufferDesc desc; + SecBuffer *buf; + char sig[16]; + + if (!(buf = malloc( msg->cBuffers * sizeof(*buf) ))) return SEC_E_INSUFFICIENT_MEMORY; + desc.ulVersion = SECBUFFER_VERSION; + desc.cBuffers = msg->cBuffers; + desc.pBuffers = buf; + + for (i = 0; i < msg->cBuffers; i++) + { + if (msg->pBuffers[i].BufferType == SECBUFFER_TOKEN) + { + buf[i].BufferType = SECBUFFER_TOKEN; + buf[i].cbBuffer = 16; + buf[i].pvBuffer = sig; + } + else + { + buf[i].BufferType = msg->pBuffers[i].BufferType; + buf[i].cbBuffer = msg->pBuffers[i].cbBuffer; + buf[i].pvBuffer = msg->pBuffers[i].pvBuffer; + } + } + + if ((status = create_signature( ctx, flags, &desc, idx, SIGN_RECV, TRUE )) == SEC_E_OK) + { + if (memcmp( (char *)buf[idx].pvBuffer + 8, (char *)msg->pBuffers[idx].pvBuffer + 8, 8 )) + status = SEC_E_MESSAGE_ALTERED; + } + + free( buf ); + return status; +} + +static NTSTATUS NTAPI ntlm_SpVerifySignature( LSA_SEC_HANDLE handle, SecBufferDesc *msg, ULONG msg_seq_no, ULONG *qop ) +{ + struct ntlm_ctx *ctx = (struct ntlm_ctx *)handle; + int idx; + + TRACE( "%lx, %p, %u, %p\n", handle, msg, msg_seq_no, qop ); + if (msg_seq_no) FIXME( "ignoring message sequence number %u\n", msg_seq_no ); + + if (!handle) return SEC_E_INVALID_HANDLE; + if (!msg || !msg->pBuffers || msg->cBuffers < 2 || (idx = get_buffer_index( msg, SECBUFFER_TOKEN )) == -1) + return SEC_E_INVALID_TOKEN; + if (msg->pBuffers[idx].cbBuffer < 16) return SEC_E_BUFFER_TOO_SMALL; + + return verify_signature( ctx, ctx->flags, msg, idx ); +} + static SECPKG_USER_FUNCTION_TABLE ntlm_user_table = { ntlm_SpInstanceInit, NULL, /* SpInitUserModeContext */ ntlm_SpMakeSignature, - NULL, /* SpVerifySignature */ + ntlm_SpVerifySignature, NULL, /* SpSealMessage */ NULL, /* SpUnsealMessage */ NULL, /* SpGetContextToken */ -- 2.30.2

1 0

[PATCH 4/6] msv1_0: Implement SpMakeSignature.
by Hans Leidekker 30 Apr '21

30 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/main.c | 199 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 198 insertions(+), 1 deletion(-) diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c index e039b68c920..d9b9d16fa64 100644 --- a/dlls/msv1_0/main.c +++ b/dlls/msv1_0/main.c @@ -523,6 +523,26 @@ static void arc4_init( struct arc4_info *info, const char *key, unsigned int len } } +static void arc4_process( struct arc4_info *info, char *buf, unsigned int len ) +{ + char *state = info->state; + unsigned int x = info->x, y = info->y, a, b; + + while (len--) + { + x = (x + 1) & 0xff; + a = state[x]; + y = (y + a) & 0xff; + b = state[y]; + state[x] = b; + state[y] = a; + *buf++ ^= state[(a + b) & 0xff]; + } + + info->x = x; + info->y = y; +} + static int get_buffer_index( SecBufferDesc *desc, ULONG type ) { int idx; @@ -1178,11 +1198,188 @@ static NTSTATUS NTAPI ntlm_SpInstanceInit( ULONG version, SECPKG_DLL_FUNCTIONS * return STATUS_SUCCESS; } +struct hmac_md5_ctx +{ + struct md5_ctx ctx; + char outer_padding[64]; +}; + +static void hmac_md5_init( struct hmac_md5_ctx *ctx, const char *key, unsigned int key_len ) +{ + char inner_padding[64], tmp_key[16]; + unsigned int i; + + if (key_len > 64) + { + struct md5_ctx tmp_ctx; + + MD5Init( &tmp_ctx ); + MD5Update( &tmp_ctx, key, key_len ); + MD5Final( &tmp_ctx ); + memcpy( tmp_key, tmp_ctx.digest, 16 ); + + key = tmp_key; + key_len = 16; + } + + memset( inner_padding, 0, 64 ); + memset( ctx->outer_padding, 0, 64 ); + memcpy( inner_padding, key, key_len ); + memcpy( ctx->outer_padding, key, key_len ); + + for (i = 0; i < 64; i++) + { + inner_padding[i] ^= 0x36; + ctx->outer_padding[i] ^= 0x5c; + } + + MD5Init( &ctx->ctx ); + MD5Update( &ctx->ctx, inner_padding, 64 ); +} + +static void hmac_md5_update( struct hmac_md5_ctx *ctx, const char *buf, unsigned int len ) +{ + MD5Update( &ctx->ctx, buf, len ); +} + +static void hmac_md5_final( struct hmac_md5_ctx *ctx, char *digest ) +{ + struct md5_ctx outer_ctx; + char inner_digest[16]; + + MD5Final( &ctx->ctx ); + memcpy( inner_digest, ctx->ctx.digest, 16 ); + + MD5Init( &outer_ctx ); + MD5Update( &outer_ctx, ctx->outer_padding, 64 ); + MD5Update( &outer_ctx, inner_digest, 16 ); + MD5Final( &outer_ctx ); + + memcpy( digest, outer_ctx.digest, 16 ); +} + +static SECURITY_STATUS create_signature( struct ntlm_ctx *ctx, unsigned int flags, SecBufferDesc *msg, int idx, + enum sign_direction dir, BOOL encrypt ) +{ + unsigned int i, sign_version = 1; + char *sig = msg->pBuffers[idx].pvBuffer; + + if (flags & FLAG_NEGOTIATE_NTLM2 && flags & FLAG_NEGOTIATE_SIGN) + { + char digest[16], seq_no[4]; + struct hmac_md5_ctx hmac_md5; + + if (dir == SIGN_SEND) + { + seq_no[0] = (ctx->crypt.ntlm2.send_seq_no >> 0) & 0xff; + seq_no[1] = (ctx->crypt.ntlm2.send_seq_no >> 8) & 0xff; + seq_no[2] = (ctx->crypt.ntlm2.send_seq_no >> 16) & 0xff; + seq_no[3] = (ctx->crypt.ntlm2.send_seq_no >> 24) & 0xff; + ctx->crypt.ntlm2.send_seq_no++; + + hmac_md5_init( &hmac_md5, ctx->crypt.ntlm2.send_sign_key, 16 ); + } + else + { + seq_no[0] = (ctx->crypt.ntlm2.recv_seq_no >> 0) & 0xff; + seq_no[1] = (ctx->crypt.ntlm2.recv_seq_no >> 8) & 0xff; + seq_no[2] = (ctx->crypt.ntlm2.recv_seq_no >> 16) & 0xff; + seq_no[3] = (ctx->crypt.ntlm2.recv_seq_no >> 24) & 0xff; + ctx->crypt.ntlm2.recv_seq_no++; + + hmac_md5_init( &hmac_md5, ctx->crypt.ntlm2.recv_sign_key, 16 ); + } + + hmac_md5_update( &hmac_md5, seq_no, 4 ); + for (i = 0; i < msg->cBuffers; ++i) + { + if (msg->pBuffers[i].BufferType & SECBUFFER_DATA) + hmac_md5_update( &hmac_md5, msg->pBuffers[i].pvBuffer, msg->pBuffers[i].cbBuffer ); + } + hmac_md5_final( &hmac_md5, digest ); + + if (encrypt && flags & FLAG_NEGOTIATE_KEY_EXCHANGE) + { + if (dir == SIGN_SEND) + arc4_process( &ctx->crypt.ntlm2.send_arc4info, digest, 8 ); + else + arc4_process( &ctx->crypt.ntlm2.recv_arc4info, digest, 8 ); + } + + sig[0] = (sign_version >> 0) & 0xff; + sig[1] = (sign_version >> 8) & 0xff; + sig[2] = (sign_version >> 16) & 0xff; + sig[3] = (sign_version >> 24) & 0xff; + memcpy( sig + 4, digest, 8 ); + memcpy( sig + 12, seq_no, 4 ); + + msg->pBuffers[idx].cbBuffer = 16; + return SEC_E_OK; + } + + if (flags & FLAG_NEGOTIATE_SIGN) + { + unsigned int crc = 0; + + for (i = 0; i < msg->cBuffers; ++i) + { + if (msg->pBuffers[i].BufferType & SECBUFFER_DATA) + crc = RtlComputeCrc32( crc, msg->pBuffers[i].pvBuffer, msg->pBuffers[i].cbBuffer ); + } + + sig[0] = (sign_version >> 0) & 0xff; + sig[1] = (sign_version >> 8) & 0xff; + sig[2] = (sign_version >> 16) & 0xff; + sig[3] = (sign_version >> 24) & 0xff; + memset( sig + 4, 0, 4 ); + sig[8] = (crc >> 0) & 0xff; + sig[9] = (crc >> 8) & 0xff; + sig[10] = (crc >> 16) & 0xff; + sig[11] = (crc >> 24) & 0xff; + sig[12] = (ctx->crypt.ntlm.seq_no >> 0) & 0xff; + sig[13] = (ctx->crypt.ntlm.seq_no >> 8) & 0xff; + sig[14] = (ctx->crypt.ntlm.seq_no >> 16) & 0xff; + sig[15] = (ctx->crypt.ntlm.seq_no >> 24) & 0xff; + ctx->crypt.ntlm.seq_no++; + + if (encrypt) arc4_process( &ctx->crypt.ntlm.arc4info, sig + 4, 12 ); + return SEC_E_OK; + } + + if (flags & FLAG_NEGOTIATE_ALWAYS_SIGN || !flags) + { + /* create dummy signature */ + memset( msg->pBuffers[idx].pvBuffer, 0, 16 ); + memset( msg->pBuffers[idx].pvBuffer, 1, 1 ); + msg->pBuffers[idx].cbBuffer = 16; + return SEC_E_OK; + } + + return SEC_E_UNSUPPORTED_FUNCTION; +} + +static NTSTATUS NTAPI ntlm_SpMakeSignature( LSA_SEC_HANDLE handle, ULONG qop, SecBufferDesc *msg, ULONG msg_seq_no ) +{ + struct ntlm_ctx *ctx = (struct ntlm_ctx *)handle; + int idx; + + TRACE( "%lx, 0x%08x, %p, %u\n", handle, qop, msg, msg_seq_no ); + if (qop) FIXME( "ignoring quality of protection %08x\n", qop ); + if (msg_seq_no) FIXME( "ignoring message sequence number %u\n", msg_seq_no ); + + if (!handle) return SEC_E_INVALID_HANDLE; + if (!msg || !msg->pBuffers || msg->cBuffers < 2 || (idx = get_buffer_index( msg, SECBUFFER_TOKEN )) == -1) + return SEC_E_INVALID_TOKEN; + if (msg->pBuffers[idx].cbBuffer < 16) return SEC_E_BUFFER_TOO_SMALL; + + return create_signature( ctx, ctx->flags, msg, idx, SIGN_SEND, TRUE ); +} + static SECPKG_USER_FUNCTION_TABLE ntlm_user_table = { ntlm_SpInstanceInit, NULL, /* SpInitUserModeContext */ - NULL, /* SpMakeSignature */ + ntlm_SpMakeSignature, NULL, /* SpVerifySignature */ NULL, /* SpSealMessage */ NULL, /* SpUnsealMessage */ -- 2.30.2

1 0

[PATCH 3/6] msv1_0: Implement SpQueryContextAttributes.
by Hans Leidekker 30 Apr '21

30 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/main.c | 76 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 75 insertions(+), 1 deletion(-) diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c index 28cad0cb14c..e039b68c920 100644 --- a/dlls/msv1_0/main.c +++ b/dlls/msv1_0/main.c @@ -1047,6 +1047,80 @@ static NTSTATUS NTAPI ntlm_SpDeleteContext( LSA_SEC_HANDLE handle ) return SEC_E_OK; } +static SecPkgInfoW *build_package_info( const SecPkgInfoW *info ) +{ + SecPkgInfoW *ret; + DWORD size_name = (wcslen(info->Name) + 1) * sizeof(WCHAR); + DWORD size_comment = (wcslen(info->Comment) + 1) * sizeof(WCHAR); + + if (!(ret = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*ret) + size_name + size_comment ))) return NULL; + ret->fCapabilities = info->fCapabilities; + ret->wVersion = info->wVersion; + ret->wRPCID = info->wRPCID; + ret->cbMaxToken = info->cbMaxToken; + ret->Name = (SEC_WCHAR *)(ret + 1); + memcpy( ret->Name, info->Name, size_name ); + ret->Comment = (SEC_WCHAR *)((char *)ret->Name + size_name); + memcpy( ret->Comment, info->Comment, size_comment ); + return ret; +} + +static NTSTATUS NTAPI ntlm_SpQueryContextAttributes( LSA_SEC_HANDLE handle, ULONG attr, void *buf ) +{ + TRACE( "%lx, %u, %p\n", handle, attr, buf ); + + if (!handle) return SEC_E_INVALID_HANDLE; + + switch (attr) + { +#define X(x) case (x) : FIXME(#x" stub\n"); break + X(SECPKG_ATTR_ACCESS_TOKEN); + X(SECPKG_ATTR_AUTHORITY); + X(SECPKG_ATTR_DCE_INFO); + X(SECPKG_ATTR_KEY_INFO); + X(SECPKG_ATTR_LIFESPAN); + X(SECPKG_ATTR_NAMES); + X(SECPKG_ATTR_NATIVE_NAMES); + X(SECPKG_ATTR_PACKAGE_INFO); + X(SECPKG_ATTR_PASSWORD_EXPIRY); + X(SECPKG_ATTR_SESSION_KEY); + X(SECPKG_ATTR_STREAM_SIZES); + X(SECPKG_ATTR_TARGET_INFORMATION); + case SECPKG_ATTR_FLAGS: + { + SecPkgContext_Flags *flags = (SecPkgContext_Flags *)buf; + struct ntlm_ctx *ctx = (struct ntlm_ctx *)handle; + + flags->Flags = 0; + if (ctx->flags & FLAG_NEGOTIATE_SIGN) flags->Flags |= ISC_RET_INTEGRITY; + if (ctx->flags & FLAG_NEGOTIATE_SEAL) flags->Flags |= ISC_RET_CONFIDENTIALITY; + return SEC_E_OK; + } + case SECPKG_ATTR_SIZES: + { + SecPkgContext_Sizes *sizes = (SecPkgContext_Sizes *)buf; + sizes->cbMaxToken = NTLM_MAX_BUF; + sizes->cbMaxSignature = 16; + sizes->cbBlockSize = 0; + sizes->cbSecurityTrailer = 16; + return SEC_E_OK; + } + case SECPKG_ATTR_NEGOTIATION_INFO: + { + SecPkgContext_NegotiationInfoW *info = (SecPkgContext_NegotiationInfoW *)buf; + if (!(info->PackageInfo = build_package_info( &ntlm_package_info ))) return SEC_E_INSUFFICIENT_MEMORY; + info->NegotiationState = SECPKG_NEGOTIATION_COMPLETE; + return SEC_E_OK; + } +#undef X + default: + FIXME( "unknown attribute %u\n", attr ); + break; + } + + return SEC_E_UNSUPPORTED_FUNCTION; +} + static SECPKG_FUNCTION_TABLE ntlm_table = { ntlm_LsaApInitializePackage, @@ -1073,7 +1147,7 @@ static SECPKG_FUNCTION_TABLE ntlm_table = NULL, /* ApplyControlToken */ NULL, /* GetUserInfo */ NULL, /* GetExtendedInformation */ - NULL, /* SpQueryContextAttributes */ + ntlm_SpQueryContextAttributes, NULL, /* SpAddCredentials */ NULL, /* SetExtendedInformation */ NULL, /* SetContextAttributes */ -- 2.30.2

1 0

[PATCH 2/6] msv1_0: Implement SpAcceptLsaModeContext.
by Hans Leidekker 30 Apr '21

30 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/main.c | 209 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 208 insertions(+), 1 deletion(-) diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c index 4b0a636bd77..28cad0cb14c 100644 --- a/dlls/msv1_0/main.c +++ b/dlls/msv1_0/main.c @@ -829,6 +829,213 @@ done: return status; } +static NTSTATUS NTAPI ntlm_SpAcceptLsaModeContext( LSA_SEC_HANDLE cred_handle, LSA_SEC_HANDLE ctx_handle, + SecBufferDesc *input, ULONG ctx_req, ULONG data_rep, + LSA_SEC_HANDLE *new_ctx_handle, SecBufferDesc *output, + ULONG *ctx_attr, TimeStamp *expiry, BOOLEAN *mapped_ctx, + SecBuffer *ctx_data ) +{ + NTSTATUS status = SEC_E_INSUFFICIENT_MEMORY; + struct ntlm_ctx *ctx = NULL; + char *buf, *bin, *want_flags = NULL; + unsigned int len, bin_len; + + TRACE( "%lx, %lx, %08x, %u, %p, %p, %p, %p, %p, %p, %p\n", cred_handle, ctx_handle, ctx_req, data_rep, input, + new_ctx_handle, output, ctx_attr, expiry, mapped_ctx, ctx_data ); + if (ctx_req) FIXME( "ignoring flags %08x\n", ctx_req ); + + if (!(buf = malloc( NTLM_MAX_BUF ))) return SEC_E_INSUFFICIENT_MEMORY; + if (!(bin = malloc( NTLM_MAX_BUF ))) goto done; + + if (!ctx_handle) + { + struct ntlm_cred *cred = (struct ntlm_cred *)cred_handle; + char *argv[3]; + + if (!cred || cred->mode != MODE_SERVER) + { + status = SEC_E_INVALID_HANDLE; + goto done; + } + + if (!input || input->cBuffers < 1) + { + status = SEC_E_INCOMPLETE_MESSAGE; + goto done; + } + + if (input->pBuffers[0].cbBuffer > NTLM_MAX_BUF) + { + status = SEC_E_INVALID_TOKEN; + goto done; + } + else bin_len = input->pBuffers[0].cbBuffer; + + argv[0] = (char *)"ntlm_auth"; + argv[1] = (char *)"--helper-protocol=squid-2.5-ntlmssp"; + argv[2] = NULL; + if ((status = ntlm_funcs->fork( argv, &ctx )) != SEC_E_OK) goto done; + ctx->mode = MODE_SERVER; + + if (!(want_flags = malloc( 73 ))) + { + status = SEC_E_INSUFFICIENT_MEMORY; + goto done; + } + strcpy( want_flags, "SF" ); + if (ctx_req & ASC_REQ_CONFIDENTIALITY) strcat( want_flags, " NTLMSSP_FEATURE_SEAL" ); + if (ctx_req & ASC_REQ_CONNECTION) + { + strcat( want_flags, " NTLMSSP_FEATURE_SESSION_KEY" ); + ctx->attrs |= ASC_RET_CONNECTION; + } + if (ctx_req & ASC_REQ_INTEGRITY) strcat( want_flags, " NTLMSSP_FEATURE_SIGN" ); + if (ctx_req & ASC_REQ_ALLOCATE_MEMORY) FIXME( "ASC_REQ_ALLOCATE_MEMORY\n" ); + if (ctx_req & ASC_REQ_EXTENDED_ERROR) FIXME( "ASC_REQ_EXTENDED_ERROR\n" ); + if (ctx_req & ASC_REQ_MUTUAL_AUTH) FIXME( "ASC_REQ_MUTUAL_AUTH\n" ); + if (ctx_req & ASC_REQ_REPLAY_DETECT) FIXME( "ASC_REQ_REPLAY_DETECT\n" ); + if (ctx_req & ASC_REQ_SEQUENCE_DETECT) FIXME( "ASC_REQ_SEQUENCE_DETECT\n" ); + if (ctx_req & ASC_REQ_STREAM) FIXME( "ASC_REQ_STREAM\n" ); + + if (strlen( want_flags ) > 3) + { + TRACE( "want flags are %s\n", debugstr_a(want_flags) ); + strcpy( buf, want_flags ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + if (!strncmp( buf, "BH", 2 )) ERR( "ntlm_auth doesn't understand new command set\n" ); + } + + memcpy( bin, input->pBuffers[0].pvBuffer, bin_len ); + strcpy( buf, "YR " ); + encode_base64( bin, bin_len, buf + 3 ); + + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + TRACE( "ntlm_auth returned %s\n", buf ); + if (strncmp( buf, "TT ", 3)) + { + status = SEC_E_INTERNAL_ERROR; + goto done; + } + bin_len = decode_base64( buf + 3, len - 3, bin ); + + if (!output || output->cBuffers < 1) + { + status = SEC_E_INSUFFICIENT_MEMORY; + goto done; + } + output->pBuffers[0].cbBuffer = bin_len; + output->pBuffers[0].BufferType = SECBUFFER_DATA; + memcpy( output->pBuffers[0].pvBuffer, bin, bin_len ); + + *new_ctx_handle = (LSA_SEC_HANDLE)ctx; + status = SEC_I_CONTINUE_NEEDED; + } + else + { + if (!input || input->cBuffers < 1) + { + status = SEC_E_INCOMPLETE_MESSAGE; + goto done; + } + + ctx = (struct ntlm_ctx *)ctx_handle; + if (!ctx || ctx->mode != MODE_SERVER) + { + status = SEC_E_INVALID_HANDLE; + goto done; + } + + if (input->pBuffers[0].cbBuffer > NTLM_MAX_BUF) + { + status = SEC_E_INVALID_TOKEN; + goto done; + } + else bin_len = input->pBuffers[0].cbBuffer; + memcpy( bin, input->pBuffers[0].pvBuffer, bin_len ); + + strcpy( buf, "KK " ); + encode_base64( bin, bin_len, buf + 3 ); + + TRACE( "client sent %s\n", debugstr_a(buf) ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + TRACE( "ntlm_auth returned %s\n", debugstr_a(buf) ); + + /* At this point, we get a NA if the user didn't authenticate, but a BH if ntlm_auth could not + * connect to winbindd. Apart from running Wine as root, there is no way to fix this for now, + * so just handle this as a failed login. */ + if (strncmp( buf, "AF ", 3 )) + { + if (!strncmp( buf, "NA ", 3 )) + { + status = SEC_E_LOGON_DENIED; + goto done; + } + else + { + const char err_v3[] = "BH NT_STATUS_ACCESS_DENIED"; + const char err_v4[] = "BH NT_STATUS_UNSUCCESSFUL"; + + if ((len >= strlen(err_v3) && !strncmp( buf, err_v3, strlen(err_v3) )) || + (len >= strlen(err_v4) && !strncmp( buf, err_v4, strlen(err_v4) ))) + { + TRACE( "connection to winbindd failed\n" ); + status = SEC_E_LOGON_DENIED; + } + else status = SEC_E_INTERNAL_ERROR; + goto done; + } + } + output->pBuffers[0].cbBuffer = 0; + + strcpy( buf, "GF" ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + if (len < 3) ctx->flags = 0; + else sscanf( buf + 3, "%x", &ctx->flags ); + + strcpy( buf, "GK" ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + + if (!strncmp( buf, "BH", 2 )) TRACE( "no key negotiated\n" ); + else if (!strncmp( buf, "GK ", 3 )) + { + bin_len = decode_base64( buf + 3, len - 3, bin ); + TRACE( "session key is %s\n", debugstr_a(buf + 3) ); + memcpy( ctx->session_key, bin, bin_len ); + } + + if (len < 3) memset( ctx->session_key, 0 , 16 ); + else + { + if (!strncmp( buf, "BH ", 3 )) + { + TRACE( "helper sent %s\n", debugstr_a(buf + 3) ); + /*FIXME: generate dummy session key = MD4(MD4(password))*/ + memset( ctx->session_key, 0 , 16 ); + } + else if (!strncmp( buf, "GK ", 3 )) + { + bin_len = decode_base64( buf + 3, len - 3, bin ); + TRACE( "session key is %s\n", debugstr_a(buf + 3) ); + memcpy( ctx->session_key, bin, 16 ); + } + } + arc4_init( &ctx->crypt.ntlm.arc4info, ctx->session_key, 16 ); + ctx->crypt.ntlm.seq_no = 0; + + *new_ctx_handle = (LSA_SEC_HANDLE)ctx; + status = SEC_E_OK; + } + +done: + if (status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) ntlm_funcs->cleanup( ctx ); + free( buf ); + free( bin ); + free( want_flags ); + + TRACE( "returning %08x\n", status ); + return status; +} + static NTSTATUS NTAPI ntlm_SpDeleteContext( LSA_SEC_HANDLE handle ) { struct ntlm_ctx *ctx = (struct ntlm_ctx *)handle; @@ -861,7 +1068,7 @@ static SECPKG_FUNCTION_TABLE ntlm_table = NULL, /* GetCredentials */ NULL, /* DeleteCredentials */ ntlm_SpInitLsaModeContext, - NULL, /* SpAcceptLsaModeContext */ + ntlm_SpAcceptLsaModeContext, ntlm_SpDeleteContext, NULL, /* ApplyControlToken */ NULL, /* GetUserInfo */ -- 2.30.2

1 0

[PATCH 1/6] msv1_0: Use RtlAllocateHeap to allocate output buffers.
by Hans Leidekker 30 Apr '21

30 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/main.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c index e07dcf6f352..4b0a636bd77 100644 --- a/dlls/msv1_0/main.c +++ b/dlls/msv1_0/main.c @@ -765,7 +765,8 @@ static NTSTATUS NTAPI ntlm_SpInitLsaModeContext( LSA_SEC_HANDLE cred_handle, LSA if (ctx_req & ISC_REQ_ALLOCATE_MEMORY) { - if (!(output->pBuffers[idx].pvBuffer = malloc( bin_len ))) + /* freed with secur32.FreeContextBuffer */ + if (!(output->pBuffers[idx].pvBuffer = RtlAllocateHeap( GetProcessHeap(), 0, bin_len ))) { status = SEC_E_INSUFFICIENT_MEMORY; goto done; -- 2.30.2

1 0

[PATCH resend] ws2_32: Hook up IPV6_HOPLIMIT
by Alex Henrie 30 Apr '21

30 Apr '21

Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- FelgoLiveClient.exe from https://felgo.com/ sets this option. --- dlls/ws2_32/socket.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c index 29464fb94c9..5c2c2170e14 100644 --- a/dlls/ws2_32/socket.c +++ b/dlls/ws2_32/socket.c @@ -532,6 +532,7 @@ static inline const char *debugstr_sockopt(int level, int optname) { DEBUG_SOCKOPT(WS_IPV6_ADD_MEMBERSHIP); DEBUG_SOCKOPT(WS_IPV6_DROP_MEMBERSHIP); + DEBUG_SOCKOPT(WS_IPV6_HOPLIMIT); DEBUG_SOCKOPT(WS_IPV6_MULTICAST_IF); DEBUG_SOCKOPT(WS_IPV6_MULTICAST_HOPS); DEBUG_SOCKOPT(WS_IPV6_MULTICAST_LOOP); @@ -864,6 +865,7 @@ static const int ws_ipv6_map[][2] = #ifdef IPV6_DROP_MEMBERSHIP MAP_OPTION( IPV6_DROP_MEMBERSHIP ), #endif + MAP_OPTION( IPV6_HOPLIMIT ), MAP_OPTION( IPV6_MULTICAST_IF ), MAP_OPTION( IPV6_MULTICAST_HOPS ), MAP_OPTION( IPV6_MULTICAST_LOOP ), @@ -4203,6 +4205,7 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, #ifdef IPV6_DROP_MEMBERSHIP case WS_IPV6_DROP_MEMBERSHIP: #endif + case WS_IPV6_HOPLIMIT: case WS_IPV6_MULTICAST_IF: case WS_IPV6_MULTICAST_HOPS: case WS_IPV6_MULTICAST_LOOP: @@ -5921,6 +5924,7 @@ int WINAPI WS_setsockopt(SOCKET s, int level, int optname, #ifdef IPV6_DROP_MEMBERSHIP case WS_IPV6_DROP_MEMBERSHIP: #endif + case WS_IPV6_HOPLIMIT: case WS_IPV6_MULTICAST_IF: case WS_IPV6_MULTICAST_HOPS: case WS_IPV6_MULTICAST_LOOP: -- 2.31.1

2 1

[PATCH 1/5] ws2_32/tests: Add some tests for bind().
by Zebediah Figura 30 Apr '21

30 Apr '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ws2_32/tests/sock.c | 66 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/dlls/ws2_32/tests/sock.c b/dlls/ws2_32/tests/sock.c index 5bd18586e51..9cf271d0fea 100644 --- a/dlls/ws2_32/tests/sock.c +++ b/dlls/ws2_32/tests/sock.c @@ -8373,6 +8373,71 @@ static void test_wsaioctl(void) closesocket(s); } +static void test_bind(void) +{ + const struct sockaddr_in invalid_addr = {.sin_family = AF_INET, .sin_addr.s_addr = inet_addr("192.0.2.0")}; + const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)}; + struct sockaddr addr; + SOCKET s, s2; + int ret, len; + + s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + + WSASetLastError(0xdeadbeef); + ret = bind(s, NULL, 0); + ok(ret == -1, "expected failure\n"); + todo_wine ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError()); + + addr.sa_family = 0xdead; + WSASetLastError(0xdeadbeef); + ret = bind(s, &addr, sizeof(addr)); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEAFNOSUPPORT, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr) - 1); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEFAULT, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&invalid_addr, sizeof(invalid_addr)); + ok(ret == -1, "expected failure\n"); + todo_wine ok(WSAGetLastError() == WSAEADDRNOTAVAIL, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(!ret, "expected success\n"); + ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError()); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEINVAL, "got error %u\n", WSAGetLastError()); + + len = sizeof(addr); + ret = getsockname(s, &addr, &len); + ok(!ret, "got error %u\n", WSAGetLastError()); + + s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + + WSASetLastError(0xdeadbeef); + ret = bind(s2, &addr, sizeof(addr)); + ok(ret == -1, "expected failure\n"); + ok(WSAGetLastError() == WSAEADDRINUSE, "got error %u\n", WSAGetLastError()); + + closesocket(s2); + closesocket(s); + + s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + + WSASetLastError(0xdeadbeef); + ret = bind(s, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(!ret, "expected success\n"); + ok(!WSAGetLastError() || WSAGetLastError() == 0xdeadbeef /* win <7 */, "got error %u\n", WSAGetLastError()); + + closesocket(s); +} + START_TEST( sock ) { int i; @@ -8427,6 +8492,7 @@ START_TEST( sock ) test_completion_port(); test_address_list_query(); + test_bind(); /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */ test_send(); -- 2.30.2

2 6

[PATCH 4/4] shell32: use a smaller range of shellview menu IDs in our IContextMenu functions
by Damjan Jovanovic 30 Apr '21

30 Apr '21

The shellview menu IDs are very large, eg. FCIDM_SHVIEW_OPEN is 0x7102, while applications want menu IDs to fit into a small range, eg. 1-1000 for Explorer++. This causes our IContextMenu_QueryContextMenu() functions to leave out most menu options. We should rebase our shellview menu ids by -0x7000 so they occupy a smaller range. This gets both Explorer++ and Double Commander to show the correct right-click menus. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=24893 Signed-off-by: Damjan Jovanovic <damjan.jov(a)gmail.com> --- dlls/shell32/shlview_cmenu.c | 57 +++++++++++++++++++++++++++------- dlls/shell32/tests/shlfolder.c | 8 +++++ 2 files changed, 54 insertions(+), 11 deletions(-)

2 1

[PATCH]: po: Update Lithuanian translation
by Aurimas Fišeras 30 Apr '21

30 Apr '21

1 0

[PATCH 3/4] shell32/tests: test what Shell_MergeMenus() does with a negative adjustment
by Damjan Jovanovic 30 Apr '21

30 Apr '21

Signed-off-by: Damjan Jovanovic <damjan.jov(a)gmail.com> --- dlls/shell32/tests/shlfileop.c | 11 +++++++++++ 1 file changed, 11 insertions(+)

1 0

[PATCH 2/4] shell32: the menu wIDs in hmenu were rebased by idCmdFirst
by Damjan Jovanovic 30 Apr '21

30 Apr '21

Signed-off-by: Damjan Jovanovic <damjan.jov(a)gmail.com> --- dlls/shell32/shlview_cmenu.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)

1 0

[PATCH 1/4] shell32/tests: add more tests for Shell_MergeMenus()
by Damjan Jovanovic 30 Apr '21

30 Apr '21

Show Shell_MergeMenus() really adds the offset instead of changing IDs to start with it, and that it really honours the maximum allowed value. Signed-off-by: Damjan Jovanovic <damjan.jov(a)gmail.com> --- dlls/shell32/tests/shlfileop.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)

1 0

[PATCH] winegstreamer: Delay duration query until caps have been acquired.
by Zebediah Figura 29 Apr '21

29 Apr '21

From: Connor McAdams <cmcadams(a)codeweavers.com> Signed-off-by: Connor McAdams <cmcadams(a)codeweavers.com> Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/quartz/tests/waveparser.c | 2 +- dlls/winegstreamer/wg_parser.c | 7 ++++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/dlls/quartz/tests/waveparser.c b/dlls/quartz/tests/waveparser.c index f3ea8f2b482..f78e15e5c19 100644 --- a/dlls/quartz/tests/waveparser.c +++ b/dlls/quartz/tests/waveparser.c @@ -929,7 +929,7 @@ static void test_seeking(void) duration = 0xdeadbeef; hr = IMediaSeeking_GetDuration(seeking, &duration); ok(hr == S_OK, "Got hr %#x.\n", hr); - todo_wine ok(duration > 0, "Got duration %s.\n", wine_dbgstr_longlong(duration)); + ok(duration > 0, "Got duration %s.\n", wine_dbgstr_longlong(duration)); stop = current = 0xdeadbeef; hr = IMediaSeeking_GetStopPosition(seeking, &stop); diff --git a/dlls/winegstreamer/wg_parser.c b/dlls/winegstreamer/wg_parser.c index d6aceff8cfe..c06e5af8160 100644 --- a/dlls/winegstreamer/wg_parser.c +++ b/dlls/winegstreamer/wg_parser.c @@ -1553,7 +1553,6 @@ static HRESULT CDECL wg_parser_connect(struct wg_parser *parser, uint64_t file_s { struct wg_parser_stream *stream = parser->streams[i]; - stream->duration = query_duration(stream->their_src); while (!stream->has_caps && !parser->error) pthread_cond_wait(&parser->init_cond, &parser->mutex); if (parser->error) @@ -1561,6 +1560,12 @@ static HRESULT CDECL wg_parser_connect(struct wg_parser *parser, uint64_t file_s pthread_mutex_unlock(&parser->mutex); return E_FAIL; } + /* GStreamer doesn't actually provide any guarantees about when duration + * is available, even for seekable streams. However, many elements (e.g. + * avidemux, wavparse, qtdemux) in practice record duration before + * fixing caps, so as a heuristic, wait until we get caps before trying + * to query for duration. */ + stream->duration = query_duration(stream->their_src); } pthread_mutex_unlock(&parser->mutex); -- 2.30.2

1 0

[PATCH 3/4] d3d11/tests: Initialise "constant" in test_device_context_state() (Valgrind).
by Henri Verbeet 29 Apr '21

29 Apr '21

We're mostly just using this to make sure the value we read back is that same as the one we set, so in that sense the actual value is inconsequential. Nevertheless, randomness is generally undesirable in the tests. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d3d11/tests/d3d11.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index ca60170d080..191df67a41d 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -6775,6 +6775,7 @@ static void test_device_context_state(void) 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x00000020, 0x00050050, 0x00000008, 0x0100086a, 0x0400009b, 0x00000001, 0x00000001, 0x00000001, 0x0100003e, }; + static const struct vec4 constant = {1.257f, 1.885f, 2.513f, 3.770f}; ID3DDeviceContextState *context_state, *previous_context_state, *tmp_context_state, *context_state2; UINT ib_offset, vb_offset, vb_stride, so_offset, offset, stride, sample_mask, stencil_ref, count; @@ -6814,7 +6815,6 @@ static void test_device_context_state(void) ID3D11Texture2D *texture; enum DXGI_FORMAT format; float blend_factor[4]; - struct vec4 constant; DWORD data_size; BOOL pred_value; ULONG refcount; -- 2.20.1

2 1

[PATCH 4/4] wined3d: Only read "*rect_count" when "rects" is non-NULL in wined3d_device_context_get_scissor_rects() (Valgrind).
by Henri Verbeet 29 Apr '21

29 Apr '21

When "rects" is NULL, "*rect_count" is potentially uninitialised. That's fairly benign because the resulting "count" value is inconsequential in that case, but it's also unnecessary, and easy to avoid. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/device.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index f3d7cff74bf..813ee773478 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -1722,8 +1722,7 @@ void CDECL wined3d_device_context_get_scissor_rects(const struct wined3d_device_ TRACE("context %p, rect_count %p, rects %p.\n", context, rect_count, rects); - count = rect_count ? min(*rect_count, state->scissor_rect_count) : 1; - if (count && rects) + if (rects && (count = rect_count ? min(*rect_count, state->scissor_rect_count) : 1)) memcpy(rects, state->scissor_rects, count * sizeof(*rects)); if (rect_count) *rect_count = state->scissor_rect_count; -- 2.20.1

1 0

[PATCH 2/4] wined3d: Free the program variants array in shader_spirv_destroy() (Valgrind).
by Henri Verbeet 29 Apr '21

29 Apr '21

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/shader_spirv.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/wined3d/shader_spirv.c b/dlls/wined3d/shader_spirv.c index eb2647db12d..7617ee9d6ef 100644 --- a/dlls/wined3d/shader_spirv.c +++ b/dlls/wined3d/shader_spirv.c @@ -1019,6 +1019,7 @@ static void shader_spirv_destroy(struct wined3d_shader *shader) shader_spirv_invalidate_contexts_graphics_program_variant(&device_vk->d, variant_vk); VK_CALL(vkDestroyShaderModule(device_vk->vk_device, variant_vk->vk_module, NULL)); } + heap_free(program_vk->variants); vkd3d_shader_free_scan_descriptor_info(&program_vk->descriptor_info); shader->backend_data = NULL; -- 2.20.1

1 0

[PATCH 1/4] wined3d: Avoid accessing the bo_user list from outside the command stream thread (Valgrind).
by Henri Verbeet 29 Apr '21

29 Apr '21

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 69 ++++++++++++++++------------------- dlls/wined3d/adapter_vk.c | 77 ++++++++++++++++++--------------------- 2 files changed, 68 insertions(+), 78 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 990991e2e3d..8787324571a 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -4755,6 +4755,7 @@ struct wined3d_view_gl_destroy_ctx { struct wined3d_device *device; const struct wined3d_gl_view *gl_view; + struct wined3d_bo_user *bo_user; struct wined3d_bo_gl *counter_bo; void *object; struct wined3d_view_gl_destroy_ctx *free; @@ -4787,13 +4788,15 @@ static void wined3d_view_gl_destroy_object(void *object) checkGLcall("delete resources"); context_release(context); } + if (ctx->bo_user) + list_remove(&ctx->bo_user->entry); heap_free(ctx->object); heap_free(ctx->free); } -static void wined3d_view_gl_destroy(struct wined3d_device *device, - const struct wined3d_gl_view *gl_view, struct wined3d_bo_gl *counter_bo, void *object) +static void wined3d_view_gl_destroy(struct wined3d_device *device, const struct wined3d_gl_view *gl_view, + struct wined3d_bo_user *bo_user, struct wined3d_bo_gl *counter_bo, void *object) { struct wined3d_view_gl_destroy_ctx *ctx, c; @@ -4801,6 +4804,7 @@ static void wined3d_view_gl_destroy(struct wined3d_device *device, ctx = &c; ctx->device = device; ctx->gl_view = gl_view; + ctx->bo_user = bo_user; ctx->counter_bo = counter_bo; ctx->object = object; ctx->free = ctx != &c ? ctx : NULL; @@ -4813,21 +4817,16 @@ static void wined3d_view_gl_destroy(struct wined3d_device *device, static void adapter_gl_destroy_rendertarget_view(struct wined3d_rendertarget_view *view) { struct wined3d_rendertarget_view_gl *view_gl = wined3d_rendertarget_view_gl(view); - struct wined3d_device *device = view_gl->v.resource->device; - unsigned int swapchain_count = device->swapchain_count; + struct wined3d_resource *resource = view_gl->v.resource; TRACE("view_gl %p.\n", view_gl); - /* Take a reference to the device, in case releasing the view's resource - * would cause the device to be destroyed. However, swapchain resources - * don't take a reference to the device, and we wouldn't want to increment - * the refcount on a device that's in the process of being destroyed. */ - if (swapchain_count) - wined3d_device_incref(device); + /* Take a reference to the resource, in case releasing the resource + * would cause the device to be destroyed. */ + wined3d_resource_incref(resource); wined3d_rendertarget_view_cleanup(&view_gl->v); - wined3d_view_gl_destroy(device, &view_gl->gl_view, NULL, view_gl); - if (swapchain_count) - wined3d_device_decref(device); + wined3d_view_gl_destroy(resource->device, &view_gl->gl_view, NULL, NULL, view_gl); + wined3d_resource_decref(resource); } static HRESULT adapter_gl_create_shader_resource_view(const struct wined3d_view_desc *desc, @@ -4859,22 +4858,20 @@ static HRESULT adapter_gl_create_shader_resource_view(const struct wined3d_view_ static void adapter_gl_destroy_shader_resource_view(struct wined3d_shader_resource_view *view) { struct wined3d_shader_resource_view_gl *view_gl = wined3d_shader_resource_view_gl(view); - struct wined3d_device *device = view_gl->v.resource->device; - unsigned int swapchain_count = device->swapchain_count; + struct wined3d_resource *resource = view_gl->v.resource; TRACE("view_gl %p.\n", view_gl); - /* Take a reference to the device, in case releasing the view's resource - * would cause the device to be destroyed. However, swapchain resources - * don't take a reference to the device, and we wouldn't want to increment - * the refcount on a device that's in the process of being destroyed. */ - if (swapchain_count) - wined3d_device_incref(device); - list_remove(&view_gl->bo_user.entry); + /* Take a reference to the resource. There are two reasons for this: + * - Releasing the resource could in turn cause the device to be + * destroyed, but we still need the device for + * wined3d_view_vk_destroy(). + * - We shouldn't free buffer resources until after we've removed the + * view from its bo_user list. */ + wined3d_resource_incref(resource); wined3d_shader_resource_view_cleanup(&view_gl->v); - wined3d_view_gl_destroy(device, &view_gl->gl_view, NULL, view_gl); - if (swapchain_count) - wined3d_device_decref(device); + wined3d_view_gl_destroy(resource->device, &view_gl->gl_view, &view_gl->bo_user, NULL, view_gl); + wined3d_resource_decref(resource); } static HRESULT adapter_gl_create_unordered_access_view(const struct wined3d_view_desc *desc, @@ -4906,22 +4903,20 @@ static HRESULT adapter_gl_create_unordered_access_view(const struct wined3d_view static void adapter_gl_destroy_unordered_access_view(struct wined3d_unordered_access_view *view) { struct wined3d_unordered_access_view_gl *view_gl = wined3d_unordered_access_view_gl(view); - struct wined3d_device *device = view_gl->v.resource->device; - unsigned int swapchain_count = device->swapchain_count; + struct wined3d_resource *resource = view_gl->v.resource; TRACE("view_gl %p.\n", view_gl); - /* Take a reference to the device, in case releasing the view's resource - * would cause the device to be destroyed. However, swapchain resources - * don't take a reference to the device, and we wouldn't want to increment - * the refcount on a device that's in the process of being destroyed. */ - if (swapchain_count) - wined3d_device_incref(device); - list_remove(&view_gl->bo_user.entry); + /* Take a reference to the resource. There are two reasons for this: + * - Releasing the resource could in turn cause the device to be + * destroyed, but we still need the device for + * wined3d_view_vk_destroy(). + * - We shouldn't free buffer resources until after we've removed the + * view from its bo_user list. */ + wined3d_resource_incref(resource); wined3d_unordered_access_view_cleanup(&view_gl->v); - wined3d_view_gl_destroy(device, &view_gl->gl_view, &view_gl->counter_bo, view_gl); - if (swapchain_count) - wined3d_device_decref(device); + wined3d_view_gl_destroy(resource->device, &view_gl->gl_view, &view_gl->bo_user, &view_gl->counter_bo, view_gl); + wined3d_resource_decref(resource); } static HRESULT adapter_gl_create_sampler(struct wined3d_device *device, const struct wined3d_sampler_desc *desc, diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 0abae24fd1f..99d7547b834 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -1304,6 +1304,7 @@ struct wined3d_view_vk_destroy_ctx struct wined3d_device_vk *device_vk; VkBufferView *vk_buffer_view; VkImageView *vk_image_view; + struct wined3d_bo_user *bo_user; struct wined3d_bo_vk *vk_counter_bo; VkBufferView *vk_counter_view; uint64_t *command_buffer_id; @@ -1350,6 +1351,8 @@ static void wined3d_view_vk_destroy_object(void *object) TRACE("Destroyed image view 0x%s.\n", wine_dbgstr_longlong(*ctx->vk_image_view)); } } + if (ctx->bo_user) + list_remove(&ctx->bo_user->entry); if (ctx->vk_counter_bo && ctx->vk_counter_bo->vk_buffer) wined3d_context_vk_destroy_bo(wined3d_context_vk(context), ctx->vk_counter_bo); if (ctx->vk_counter_view) @@ -1374,7 +1377,7 @@ static void wined3d_view_vk_destroy_object(void *object) } static void wined3d_view_vk_destroy(struct wined3d_device *device, VkBufferView *vk_buffer_view, - VkImageView *vk_image_view, struct wined3d_bo_vk *vk_counter_bo, + VkImageView *vk_image_view, struct wined3d_bo_user *bo_user, struct wined3d_bo_vk *vk_counter_bo, VkBufferView *vk_counter_view, uint64_t *command_buffer_id, void *view_vk) { struct wined3d_view_vk_destroy_ctx *ctx, c; @@ -1384,6 +1387,7 @@ static void wined3d_view_vk_destroy(struct wined3d_device *device, VkBufferView ctx->device_vk = wined3d_device_vk(device); ctx->vk_buffer_view = vk_buffer_view; ctx->vk_image_view = vk_image_view; + ctx->bo_user = bo_user; ctx->vk_counter_bo = vk_counter_bo; ctx->vk_counter_view = vk_counter_view; ctx->command_buffer_id = command_buffer_id; @@ -1398,22 +1402,17 @@ static void wined3d_view_vk_destroy(struct wined3d_device *device, VkBufferView static void adapter_vk_destroy_rendertarget_view(struct wined3d_rendertarget_view *view) { struct wined3d_rendertarget_view_vk *view_vk = wined3d_rendertarget_view_vk(view); - struct wined3d_device *device = view_vk->v.resource->device; - unsigned int swapchain_count = device->swapchain_count; + struct wined3d_resource *resource = view_vk->v.resource; TRACE("view_vk %p.\n", view_vk); - /* Take a reference to the device, in case releasing the view's resource - * would cause the device to be destroyed. However, swapchain resources - * don't take a reference to the device, and we wouldn't want to increment - * the refcount on a device that's in the process of being destroyed. */ - if (swapchain_count) - wined3d_device_incref(device); + /* Take a reference to the resource, in case releasing the resource + * would cause the device to be destroyed. */ + wined3d_resource_incref(resource); wined3d_rendertarget_view_cleanup(&view_vk->v); - wined3d_view_vk_destroy(device, NULL, &view_vk->vk_image_view, - NULL, NULL, &view_vk->command_buffer_id, view_vk); - if (swapchain_count) - wined3d_device_decref(device); + wined3d_view_vk_destroy(resource->device, NULL, &view_vk->vk_image_view, + NULL, NULL, NULL, &view_vk->command_buffer_id, view_vk); + wined3d_resource_decref(resource); } static HRESULT adapter_vk_create_shader_resource_view(const struct wined3d_view_desc *desc, @@ -1445,30 +1444,28 @@ static HRESULT adapter_vk_create_shader_resource_view(const struct wined3d_view_ static void adapter_vk_destroy_shader_resource_view(struct wined3d_shader_resource_view *view) { struct wined3d_shader_resource_view_vk *srv_vk = wined3d_shader_resource_view_vk(view); - struct wined3d_device *device = srv_vk->v.resource->device; - unsigned int swapchain_count = device->swapchain_count; + struct wined3d_resource *resource = srv_vk->v.resource; struct wined3d_view_vk *view_vk = &srv_vk->view_vk; VkBufferView *vk_buffer_view = NULL; VkImageView *vk_image_view = NULL; TRACE("srv_vk %p.\n", srv_vk); - /* Take a reference to the device, in case releasing the view's resource - * would cause the device to be destroyed. However, swapchain resources - * don't take a reference to the device, and we wouldn't want to increment - * the refcount on a device that's in the process of being destroyed. */ - if (swapchain_count) - wined3d_device_incref(device); - if (srv_vk->v.resource->type == WINED3D_RTYPE_BUFFER) + /* Take a reference to the resource. There are two reasons for this: + * - Releasing the resource could in turn cause the device to be + * destroyed, but we still need the device for + * wined3d_view_vk_destroy(). + * - We shouldn't free buffer resources until after we've removed the + * view from its bo_user list. */ + wined3d_resource_incref(resource); + if (resource->type == WINED3D_RTYPE_BUFFER) vk_buffer_view = &view_vk->u.vk_buffer_view; else vk_image_view = &view_vk->u.vk_image_info.imageView; - list_remove(&view_vk->bo_user.entry); wined3d_shader_resource_view_cleanup(&srv_vk->v); - wined3d_view_vk_destroy(device, vk_buffer_view, vk_image_view, - NULL, NULL, &view_vk->command_buffer_id, srv_vk); - if (swapchain_count) - wined3d_device_decref(device); + wined3d_view_vk_destroy(resource->device, vk_buffer_view, vk_image_view, + &view_vk->bo_user, NULL, NULL, &view_vk->command_buffer_id, srv_vk); + wined3d_resource_decref(resource); } static HRESULT adapter_vk_create_unordered_access_view(const struct wined3d_view_desc *desc, @@ -1500,30 +1497,28 @@ static HRESULT adapter_vk_create_unordered_access_view(const struct wined3d_view static void adapter_vk_destroy_unordered_access_view(struct wined3d_unordered_access_view *view) { struct wined3d_unordered_access_view_vk *uav_vk = wined3d_unordered_access_view_vk(view); - struct wined3d_device *device = uav_vk->v.resource->device; - unsigned int swapchain_count = device->swapchain_count; + struct wined3d_resource *resource = uav_vk->v.resource; struct wined3d_view_vk *view_vk = &uav_vk->view_vk; VkBufferView *vk_buffer_view = NULL; VkImageView *vk_image_view = NULL; TRACE("uav_vk %p.\n", uav_vk); - /* Take a reference to the device, in case releasing the view's resource - * would cause the device to be destroyed. However, swapchain resources - * don't take a reference to the device, and we wouldn't want to increment - * the refcount on a device that's in the process of being destroyed. */ - if (swapchain_count) - wined3d_device_incref(device); - if (uav_vk->v.resource->type == WINED3D_RTYPE_BUFFER) + /* Take a reference to the resource. There are two reasons for this: + * - Releasing the resource could in turn cause the device to be + * destroyed, but we still need the device for + * wined3d_view_vk_destroy(). + * - We shouldn't free buffer resources until after we've removed the + * view from its bo_user list. */ + wined3d_resource_incref(resource); + if (resource->type == WINED3D_RTYPE_BUFFER) vk_buffer_view = &view_vk->u.vk_buffer_view; else vk_image_view = &view_vk->u.vk_image_info.imageView; - list_remove(&view_vk->bo_user.entry); wined3d_unordered_access_view_cleanup(&uav_vk->v); - wined3d_view_vk_destroy(device, vk_buffer_view, vk_image_view, &uav_vk->counter_bo, - &uav_vk->vk_counter_view, &view_vk->command_buffer_id, uav_vk); - if (swapchain_count) - wined3d_device_decref(device); + wined3d_view_vk_destroy(resource->device, vk_buffer_view, vk_image_view, &view_vk->bo_user, + &uav_vk->counter_bo, &uav_vk->vk_counter_view, &view_vk->command_buffer_id, uav_vk); + wined3d_resource_decref(resource); } static HRESULT adapter_vk_create_sampler(struct wined3d_device *device, const struct wined3d_sampler_desc *desc, -- 2.20.1

1 0

[PATCH v2 1/2] winegstreamer: Delay duration query until caps have been acquired.
by Connor McAdams 29 Apr '21

29 Apr '21

Signed-off-by: Connor McAdams <cmcadams(a)codeweavers.com> --- dlls/winegstreamer/wg_parser.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/winegstreamer/wg_parser.c b/dlls/winegstreamer/wg_parser.c index 5529321490e..f90362981df 100644 --- a/dlls/winegstreamer/wg_parser.c +++ b/dlls/winegstreamer/wg_parser.c @@ -1553,9 +1553,9 @@ static HRESULT CDECL wg_parser_connect(struct wg_parser *parser, uint64_t file_s { struct wg_parser_stream *stream = parser->streams[i]; - stream->duration = query_duration(stream->their_src); while (!stream->has_caps && !parser->error) pthread_cond_wait(&parser->init_cond, &parser->mutex); + stream->duration = query_duration(stream->their_src); if (parser->error) { pthread_mutex_unlock(&parser->mutex); -- 2.25.1

2 3

[PATCH 10/10] msvcrt: Import round implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 31 ++++++++++++++++++++++++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 30 insertions(+), 16 deletions(-)

1 0

[PATCH 09/10] msvcrt: Import lround implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 9 ++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 8 insertions(+), 16 deletions(-)

1 0

[PATCH 08/10] msvcrt: Import lroundf implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 9 ++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 8 insertions(+), 16 deletions(-)

1 0

[PATCH 07/10] msvcrt: Import llround implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 9 ++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 8 insertions(+), 16 deletions(-)

1 0

[PATCH 06/10] msvcrt: Import llroundf implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 9 ++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 8 insertions(+), 16 deletions(-)

1 0

[PATCH 05/10] msvcrt: Import roundf implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 25 ++++++++++++++++++++++++- dlls/msvcrt/unixlib.c | 13 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 24 insertions(+), 16 deletions(-)

1 0

[PATCH 04/10] msvcrt: Import yn implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 3 +- dlls/msvcrt/math.c | 72 +++++++++++++++++++++++++++++++++++++------ dlls/msvcrt/unixlib.c | 16 +--------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 64 insertions(+), 28 deletions(-)

1 0

[PATCH 03/10] msvcrt: Import jn implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 128 +++++++++++++++++++++++++++++++++++++++++- dlls/msvcrt/unixlib.c | 14 ----- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 125 insertions(+), 19 deletions(-)

1 0

[PATCH 02/10] msvcrt: Import y1 implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 46 +++++++++++++++++++++++++++++++++---------- dlls/msvcrt/unixlib.c | 14 ------------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 36 insertions(+), 26 deletions(-)

1 0

[PATCH 01/10] msvcrt: Import j1 implementation from musl.
by Piotr Caban 29 Apr '21

29 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 232 +++++++++++++++++++++++++++++++++++++++++- dlls/msvcrt/unixlib.c | 14 --- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 229 insertions(+), 19 deletions(-)

1 0

[PATCH v8] ntdll: Allow renaming a file/directory to a different case of itself.
by Gabriel Ivăncescu 29 Apr '21

29 Apr '21

Renaming a file or directory from e.g. foobar to FooBar (or any other case change) should work, like on Windows, instead of being a no-op. Clobbering an existing file must also respect the new case. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=46203 Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- We just prepend the unix original case filename (without path) to the wineserver data before the actual unix filename, and a field `caselen` which is the length of this data. dlls/kernel32/tests/file.c | 4 +- dlls/ntdll/tests/file.c | 4 +- dlls/ntdll/unix/file.c | 63 ++++++++++++++++++++++-- server/fd.c | 98 +++++++++++++++++++++++++------------- server/protocol.def | 2 + 5 files changed, 131 insertions(+), 40 deletions(-) diff --git a/dlls/kernel32/tests/file.c b/dlls/kernel32/tests/file.c index 8560524..9ca56e1 100644 --- a/dlls/kernel32/tests/file.c +++ b/dlls/kernel32/tests/file.c @@ -2040,7 +2040,7 @@ static void test_MoveFileA(void) ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); if (hfile != INVALID_HANDLE_VALUE) { - todo_wine ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), + ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), "MoveFile failed to change casing on same file: got %s\n", find_data.cFileName); } CloseHandle(hfile); @@ -2085,7 +2085,7 @@ static void test_MoveFileA(void) ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); if (hfile != INVALID_HANDLE_VALUE) { - todo_wine ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), + ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), "MoveFile failed to change casing on same directory: got %s\n", find_data.cFileName); } CloseHandle(hfile); diff --git a/dlls/ntdll/tests/file.c b/dlls/ntdll/tests/file.c index d469b44..49f4e34 100644 --- a/dlls/ntdll/tests/file.c +++ b/dlls/ntdll/tests/file.c @@ -2315,7 +2315,7 @@ static void test_file_link_information(void) ok(handle != INVALID_HANDLE_VALUE, "FindFirstFileW: failed, error %d\n", GetLastError()); if (handle != INVALID_HANDLE_VALUE) { - todo_wine ok(!lstrcmpW(wcsrchr(newpath, '\\') + 1, find_data.cFileName), + ok(!lstrcmpW(wcsrchr(newpath, '\\') + 1, find_data.cFileName), "Link did not change casing on existing target file: got %s\n", wine_dbgstr_w(find_data.cFileName)); } @@ -2900,7 +2900,7 @@ static void test_file_link_information(void) ok(handle != INVALID_HANDLE_VALUE, "FindFirstFileW: failed, error %d\n", GetLastError()); if (handle != INVALID_HANDLE_VALUE) { - todo_wine ok(!lstrcmpW(wcsrchr(oldpath, '\\') + 1, find_data.cFileName), + ok(!lstrcmpW(wcsrchr(oldpath, '\\') + 1, find_data.cFileName), "Link did not change casing on same file: got %s\n", wine_dbgstr_w(find_data.cFileName)); } diff --git a/dlls/ntdll/unix/file.c b/dlls/ntdll/unix/file.c index e32de57..a3af5bb 100644 --- a/dlls/ntdll/unix/file.c +++ b/dlls/ntdll/unix/file.c @@ -3400,6 +3400,55 @@ NTSTATUS nt_to_unix_file_name( const OBJECT_ATTRIBUTES *attr, char **name_ret, U } +/*********************************************************************** + * nt_to_unix_file_name_with_actual_case + * + * Same as nt_to_unix_file_name, but additionally return unix file name + * without path, with the actual case from the NT file name. + */ +static NTSTATUS nt_to_unix_file_name_with_actual_case( const OBJECT_ATTRIBUTES *attr, char **name_ret, + char **actual_case_ret, UINT disposition ) +{ + const WCHAR *nt_filename = attr->ObjectName->Buffer; + char *actual_case; + NTSTATUS status; + int len; + + /* strip off trailing backslashes; we also accept '/' for unix namespaces */ + for (len = attr->ObjectName->Length / sizeof(WCHAR); len != 0; len--) + if (nt_filename[len - 1] != '\\' && nt_filename[len - 1] != '/') + break; + + /* get the last component */ + for (nt_filename += len; nt_filename != attr->ObjectName->Buffer; nt_filename--) + if (nt_filename[-1] == '\\' || nt_filename[-1] == '/') + break; + len = attr->ObjectName->Buffer + len - nt_filename; + + if (!(actual_case = malloc( len * 3 + 1 ))) return STATUS_NO_MEMORY; + + status = nt_to_unix_file_name( attr, name_ret, disposition ); + if (status != STATUS_SUCCESS && status != STATUS_NO_SUCH_FILE) + { + free( actual_case ); + return status; + } + + len = ntdll_wcstoumbs( nt_filename, len, actual_case, len * 3, TRUE ); + if (len > 0) + actual_case[len] = 0; + else + { + char *p = strrchr( *name_ret, '/' ); + p = p ? p + 1 : *name_ret; + strcpy( actual_case, p ); + } + + *actual_case_ret = actual_case; + return status; +} + + /****************************************************************************** * wine_nt_to_unix_file_name * @@ -4522,8 +4571,8 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, { FILE_RENAME_INFORMATION *info = ptr; UNICODE_STRING name_str, redir; + char *unix_name, *file_case; OBJECT_ATTRIBUTES attr; - char *unix_name; name_str.Buffer = info->FileName; name_str.Length = info->FileNameLength; @@ -4531,7 +4580,7 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, InitializeObjectAttributes( &attr, &name_str, OBJ_CASE_INSENSITIVE, info->RootDirectory, NULL ); get_redirect( &attr, &redir ); - io->u.Status = nt_to_unix_file_name( &attr, &unix_name, FILE_OPEN_IF ); + io->u.Status = nt_to_unix_file_name_with_actual_case( &attr, &unix_name, &file_case, FILE_OPEN_IF ); if (io->u.Status == STATUS_SUCCESS || io->u.Status == STATUS_NO_SUCH_FILE) { SERVER_START_REQ( set_fd_name_info ) @@ -4539,15 +4588,18 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, req->handle = wine_server_obj_handle( handle ); req->rootdir = wine_server_obj_handle( attr.RootDirectory ); req->namelen = attr.ObjectName->Length; + req->caselen = strlen( file_case ); req->link = FALSE; req->replace = info->ReplaceIfExists; wine_server_add_data( req, attr.ObjectName->Buffer, attr.ObjectName->Length ); + wine_server_add_data( req, file_case, req->caselen ); wine_server_add_data( req, unix_name, strlen(unix_name) ); io->u.Status = wine_server_call( req ); } SERVER_END_REQ; free( unix_name ); + free( file_case ); } free( redir.Buffer ); } @@ -4559,8 +4611,8 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, { FILE_LINK_INFORMATION *info = ptr; UNICODE_STRING name_str, redir; + char *unix_name, *file_case; OBJECT_ATTRIBUTES attr; - char *unix_name; name_str.Buffer = info->FileName; name_str.Length = info->FileNameLength; @@ -4568,7 +4620,7 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, InitializeObjectAttributes( &attr, &name_str, OBJ_CASE_INSENSITIVE, info->RootDirectory, NULL ); get_redirect( &attr, &redir ); - io->u.Status = nt_to_unix_file_name( &attr, &unix_name, FILE_OPEN_IF ); + io->u.Status = nt_to_unix_file_name_with_actual_case( &attr, &unix_name, &file_case, FILE_OPEN_IF ); if (io->u.Status == STATUS_SUCCESS || io->u.Status == STATUS_NO_SUCH_FILE) { SERVER_START_REQ( set_fd_name_info ) @@ -4576,15 +4628,18 @@ NTSTATUS WINAPI NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, req->handle = wine_server_obj_handle( handle ); req->rootdir = wine_server_obj_handle( attr.RootDirectory ); req->namelen = attr.ObjectName->Length; + req->caselen = strlen( file_case ); req->link = TRUE; req->replace = info->ReplaceIfExists; wine_server_add_data( req, attr.ObjectName->Buffer, attr.ObjectName->Length ); + wine_server_add_data( req, file_case, req->caselen ); wine_server_add_data( req, unix_name, strlen(unix_name) ); io->u.Status = wine_server_call( req ); } SERVER_END_REQ; free( unix_name ); + free( file_case ); } free( redir.Buffer ); } diff --git a/server/fd.c b/server/fd.c index 481e9a8..3e51528 100644 --- a/server/fd.c +++ b/server/fd.c @@ -2488,11 +2488,14 @@ static void set_fd_disposition( struct fd *fd, int unlink ) /* set new name for the fd */ static void set_fd_name( struct fd *fd, struct fd *root, const char *nameptr, data_size_t len, - struct unicode_str nt_name, int create_link, int replace ) + const char *file_case, data_size_t caselen, struct unicode_str nt_name, + int create_link, int replace ) { + size_t pathlen, filenamelen; struct inode *inode; struct stat st, st2; - char *name; + int different_case; + char *name, *tmp; if (!fd->inode || !fd->unix_name) { @@ -2526,6 +2529,23 @@ static void set_fd_name( struct fd *fd, struct fd *root, const char *nameptr, da name = combined_name; } + tmp = strrchr( name, '/' ); + tmp = tmp ? tmp + 1 : name; + pathlen = tmp - name; + filenamelen = strlen( tmp ); + different_case = (filenamelen != caselen || memcmp( tmp, file_case, caselen )); + + if (filenamelen < caselen) + { + tmp = realloc( name, pathlen + caselen + 1 ); + if (!tmp) + { + set_error( STATUS_NO_MEMORY ); + goto failed; + } + name = tmp; + } + /* when creating a hard link, source cannot be a dir */ if (create_link && !fstat( fd->unix_fd, &st ) && S_ISDIR( st.st_mode )) { @@ -2538,47 +2558,58 @@ static void set_fd_name( struct fd *fd, struct fd *root, const char *nameptr, da if (!fstat( fd->unix_fd, &st2 ) && st.st_ino == st2.st_ino && st.st_dev == st2.st_dev) { if (create_link && !replace) set_error( STATUS_OBJECT_NAME_COLLISION ); - free( name ); - return; - } + if (!different_case) + { + free( name ); + return; + } - if (!replace) - { - set_error( STATUS_OBJECT_NAME_COLLISION ); - goto failed; + /* creating a link with a different case on itself renames the file */ + create_link = 0; } - - /* can't replace directories or special files */ - if (!S_ISREG( st.st_mode )) + else { - set_error( STATUS_ACCESS_DENIED ); - goto failed; - } + if (!replace) + { + set_error( STATUS_OBJECT_NAME_COLLISION ); + goto failed; + } - /* can't replace an opened file */ - if ((inode = get_inode( st.st_dev, st.st_ino, -1 ))) - { - int is_empty = list_empty( &inode->open ); - release_object( inode ); - if (!is_empty) + /* can't replace directories or special files */ + if (!S_ISREG( st.st_mode )) { set_error( STATUS_ACCESS_DENIED ); goto failed; } - } - /* link() expects that the target doesn't exist */ - /* rename() cannot replace files with directories */ - if (create_link || S_ISDIR( st2.st_mode )) - { - if (unlink( name )) + /* can't replace an opened file */ + if ((inode = get_inode( st.st_dev, st.st_ino, -1 ))) { - file_set_error(); - goto failed; + int is_empty = list_empty( &inode->open ); + release_object( inode ); + if (!is_empty) + { + set_error( STATUS_ACCESS_DENIED ); + goto failed; + } + } + + /* link() expects that the target doesn't exist */ + /* rename() cannot replace files with directories */ + if (create_link || S_ISDIR( st2.st_mode ) || different_case) + { + if (unlink( name )) + { + file_set_error(); + goto failed; + } } } } + memcpy( name + pathlen, file_case, caselen ); + name[pathlen + caselen] = 0; + if (create_link) { if (link( fd->unix_name, name )) @@ -2879,16 +2910,19 @@ DECL_HANDLER(set_fd_disp_info) /* set fd name information */ DECL_HANDLER(set_fd_name_info) { + const char *fullname, *file_case; struct fd *fd, *root_fd = NULL; struct unicode_str nt_name; - if (req->namelen > get_req_data_size()) + if (req->namelen > get_req_data_size() || get_req_data_size() - req->namelen < req->caselen) { set_error( STATUS_INVALID_PARAMETER ); return; } nt_name.str = get_req_data(); nt_name.len = (req->namelen / sizeof(WCHAR)) * sizeof(WCHAR); + file_case = (const char *)get_req_data() + req->namelen; + fullname = file_case + req->caselen; if (req->rootdir) { @@ -2902,8 +2936,8 @@ DECL_HANDLER(set_fd_name_info) if ((fd = get_handle_fd_obj( current->process, req->handle, 0 ))) { - set_fd_name( fd, root_fd, (const char *)get_req_data() + req->namelen, - get_req_data_size() - req->namelen, nt_name, req->link, req->replace ); + set_fd_name( fd, root_fd, fullname, (const char *)get_req_data() + get_req_data_size() - fullname, + file_case, req->caselen, nt_name, req->link, req->replace ); release_object( fd ); } if (root_fd) release_object( root_fd ); diff --git a/server/protocol.def b/server/protocol.def index 7c22fae..a4517e6 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -3527,9 +3527,11 @@ struct handle_info obj_handle_t handle; /* handle to a file or directory */ obj_handle_t rootdir; /* root directory */ data_size_t namelen; /* length of NT name in bytes */ + data_size_t caselen; /* length of the actual case filename */ int link; /* link instead of renaming */ int replace; /* replace an existing file? */ VARARG(name,unicode_str,namelen); /* NT name */ + VARARG(actual_case,string,caselen); /* new file name's actual case (without path) */ VARARG(filename,string); /* new file name */ @END -- 2.30.0

3 5

[PATCH] reg: Use correct error message if RegCreateKeyExW() fails
by Hugh McMaster 29 Apr '21

29 Apr '21

Signed-off-by: Hugh McMaster <hugh.mcmaster(a)outlook.com> --- programs/reg/add.c | 2 +- programs/reg/reg.rc | 1 + programs/reg/resource.h | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/programs/reg/add.c b/programs/reg/add.c index ff209bfc0ff..db909167f30 100644 --- a/programs/reg/add.c +++ b/programs/reg/add.c @@ -157,7 +157,7 @@ static int run_add(HKEY root, WCHAR *path, WCHAR *value_name, BOOL value_empty, if (RegCreateKeyExW(root, path, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ|KEY_WRITE, NULL, &hkey, NULL)) { - output_message(STRING_INVALID_KEY); + output_message(STRING_ACCESS_DENIED); return 1; } diff --git a/programs/reg/reg.rc b/programs/reg/reg.rc index 021734db0a7..0f8ff4a5bc4 100644 --- a/programs/reg/reg.rc +++ b/programs/reg/reg.rc @@ -176,4 +176,5 @@ STRINGTABLE \ Access the registry using the 32-bit view.\n\n\ \ /reg:64\n\ \ Access the registry using the 64-bit view.\n\n" + STRING_ACCESS_DENIED, "reg: Unable to access or create the specified registry key\n" } diff --git a/programs/reg/resource.h b/programs/reg/resource.h index b673e21883a..b569eb41d3d 100644 --- a/programs/reg/resource.h +++ b/programs/reg/resource.h @@ -62,3 +62,4 @@ #define STRING_KEY_NONEXIST 139 #define STRING_KEY_IMPORT_FAILED 140 #define STRING_REG_VIEW_USAGE 141 +#define STRING_ACCESS_DENIED 142 -- 2.31.1

1 0

[PATCH] winex11.drv: Fix drawing of layered windows with a client window.
by Giovanni Mascellani 29 Apr '21

29 Apr '21

Testing on Windows 10, it seems that when a window has both a surface (because it is layered) and a client window (because a d3d9 or analogous device was created for it), the surface takes the priority, i.e., gdi and d3d9 are ignored, and just the layered bitmap is painted. Before this change, expose events lead to redrawing the surface only on the whole window, but not on the client window. This implies that if a d3d9 device is created for a layered window, it takes the priority in the client window region, contradicting the behavior observed on Windows. Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- dlls/winex11.drv/event.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/dlls/winex11.drv/event.c b/dlls/winex11.drv/event.c index 99943478729..38c8bd825bb 100644 --- a/dlls/winex11.drv/event.c +++ b/dlls/winex11.drv/event.c @@ -938,21 +938,21 @@ static BOOL X11DRV_Expose( HWND hwnd, XEvent *xev ) rect.right = pos.x + event->width; rect.bottom = pos.y + event->height; - if (event->window != data->client_window) + if (event->window == data->client_window) + OffsetRect( &rect, data->client_rect.left - data->whole_rect.left, + data->client_rect.top - data->whole_rect.top ); + if (data->surface) { - if (data->surface) - { - surface_region = expose_surface( data->surface, &rect ); - if (!surface_region) flags = 0; - else OffsetRgn( surface_region, data->whole_rect.left - data->client_rect.left, - data->whole_rect.top - data->client_rect.top ); + surface_region = expose_surface( data->surface, &rect ); + if (!surface_region) flags = 0; + else OffsetRgn( surface_region, data->whole_rect.left - data->client_rect.left, + data->whole_rect.top - data->client_rect.top ); - if (data->vis.visualid != default_visual.visualid) - data->surface->funcs->flush( data->surface ); - } - OffsetRect( &rect, data->whole_rect.left - data->client_rect.left, - data->whole_rect.top - data->client_rect.top ); + if (data->vis.visualid != default_visual.visualid) + data->surface->funcs->flush( data->surface ); } + OffsetRect( &rect, data->whole_rect.left - data->client_rect.left, + data->whole_rect.top - data->client_rect.top ); if (event->window != root_window) { -- 2.31.1

3 5

[PATCH] winetest: Fix the path to the ntoskrnl.exe/tests source.
by Francois Gouget 29 Apr '21

29 Apr '21

It's the only test with a .exe extension for which the source is not in programs! Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- programs/winetest/main.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/programs/winetest/main.c b/programs/winetest/main.c index ce3fbb4224a..290cd5f086f 100644 --- a/programs/winetest/main.c +++ b/programs/winetest/main.c @@ -518,7 +518,8 @@ static const char* get_test_source_file(const char* test, const char* subtest) static char buffer[MAX_PATH]; int len = strlen(test); - if (len > 4 && !strcmp( test + len - 4, ".exe" )) + if (len > 4 && !strcmp( test + len - 4, ".exe" ) && + strcmp( test, "ntoskrnl.exe" )) /* the one exception! */ { len = sprintf(buffer, "programs/%s", test) - 4; buffer[len] = 0; -- 2.20.1

1 0

[PATCH 2/2] winevulkan: Use wine_ prefix for Unix thunks.
by Jacek Caban 29 Apr '21

29 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winevulkan/make_vulkan | 4 +- dlls/winevulkan/vulkan.c | 98 ++++++++++++++++++------------------- 2 files changed, 51 insertions(+), 51 deletions(-)

1 0

[PATCH 1/2] winevulkan: Don't use wine_ prefix on PE side.
by Jacek Caban 29 Apr '21

29 Apr '21

There is no ABI ambiguity, so we may just use public names. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winevulkan/loader.c | 34 ++++++++++++++--------------- dlls/winevulkan/make_vulkan | 37 +++++++++++--------------------- dlls/winevulkan/vulkan_loader.h | 2 -- dlls/winevulkan/vulkan_private.h | 1 + 4 files changed, 31 insertions(+), 43 deletions(-)

1 0

[PATCH 5/5] msv1_0: Implement SpInitLsaModeContext and SpDeleteContext.
by Hans Leidekker 29 Apr '21

29 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/Makefile.in | 1 + dlls/msv1_0/main.c | 561 +++++++++++++++++++++++++++++++++++++++- dlls/msv1_0/unixlib.c | 68 +++++ dlls/msv1_0/unixlib.h | 1 + 4 files changed, 629 insertions(+), 2 deletions(-) diff --git a/dlls/msv1_0/Makefile.in b/dlls/msv1_0/Makefile.in index 21a9c61e317..6e7a8f958d3 100644 --- a/dlls/msv1_0/Makefile.in +++ b/dlls/msv1_0/Makefile.in @@ -1,4 +1,5 @@ MODULE = msv1_0.dll +IMPORTS = netapi32 advapi32 EXTRADLLFLAGS = -mno-cygwin diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c index 7dabd8e2ff5..e07dcf6f352 100644 --- a/dlls/msv1_0/main.c +++ b/dlls/msv1_0/main.c @@ -19,6 +19,7 @@ #include <stdarg.h> #include <stdlib.h> +#include <wchar.h> #include "ntstatus.h" #define WIN32_NO_STATUS #include "windef.h" @@ -28,6 +29,10 @@ #include "ntsecapi.h" #include "ntsecpkg.h" #include "rpc.h" +#include "wincred.h" +#include "lmwksta.h" +#include "lmapibuf.h" +#include "lmerr.h" #include "wine/debug.h" #include "unixlib.h" @@ -282,6 +287,558 @@ static NTSTATUS NTAPI ntlm_SpFreeCredentialsHandle( LSA_SEC_HANDLE handle ) return SEC_E_OK; } +static BOOL get_cached_credential( const UNICODE_STRING *target, CREDENTIALW **cred ) +{ + const WCHAR *ptr, *host; + WCHAR *hostonly; + size_t len; + BOOL ret; + + if (!target) return FALSE; + + len = target->Length / sizeof(WCHAR); + if ((host = wmemchr( target->Buffer, '/', len ))) + { + host++; + len -= host - target->Buffer; + if (!(ptr = wmemchr( host, ':', len ))) ptr = wmemchr( host, '/', len ); + if (!ptr) ptr = host + len; + } + else + { + host = target->Buffer; + ptr = host + len; + } + + if (!(hostonly = malloc( (ptr - host + 1) * sizeof(WCHAR) ))) return FALSE; + memcpy( hostonly, host, (ptr - host) * sizeof(WCHAR) ); + hostonly[ptr - host] = 0; + + ret = CredReadW( hostonly, CRED_TYPE_DOMAIN_PASSWORD, 0, cred ); + free( hostonly ); + return ret; +} + +static UINT encode_base64( const char *bin, unsigned int len, char *base64 ) +{ + static const char base64enc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + UINT n = 0, x; + + while (len > 0) + { + /* first 6 bits, all from bin[0] */ + base64[n++] = base64enc[(bin[0] & 0xfc) >> 2]; + x = (bin[0] & 3) << 4; + + /* next 6 bits, 2 from bin[0] and 4 from bin[1] */ + if (len == 1) + { + base64[n++] = base64enc[x]; + base64[n++] = '='; + base64[n++] = '='; + break; + } + base64[n++] = base64enc[x | ((bin[1] & 0xf0) >> 4)]; + x = (bin[1] & 0x0f) << 2; + + /* next 6 bits 4 from bin[1] and 2 from bin[2] */ + if (len == 2) + { + base64[n++] = base64enc[x]; + base64[n++] = '='; + break; + } + base64[n++] = base64enc[x | ((bin[2] & 0xc0) >> 6)]; + + /* last 6 bits, all from bin[2] */ + base64[n++] = base64enc[bin[2] & 0x3f]; + bin += 3; + len -= 3; + } + base64[n] = 0; + return n; +} + +static inline char decode_char( char c ) +{ + if (c >= 'A' && c <= 'Z') return c - 'A'; + if (c >= 'a' && c <= 'z') return c - 'a' + 26; + if (c >= '0' && c <= '9') return c - '0' + 52; + if (c == '+') return 62; + if (c == '/') return 63; + return 64; +} + +static unsigned int decode_base64( const char *base64, unsigned int len, char *buf ) +{ + unsigned int i = 0; + char c0, c1, c2, c3; + const char *p = base64; + + while (len > 4) + { + if ((c0 = decode_char( p[0] )) > 63) return 0; + if ((c1 = decode_char( p[1] )) > 63) return 0; + if ((c2 = decode_char( p[2] )) > 63) return 0; + if ((c3 = decode_char( p[3] )) > 63) return 0; + if (buf) + { + buf[i + 0] = (c0 << 2) | (c1 >> 4); + buf[i + 1] = (c1 << 4) | (c2 >> 2); + buf[i + 2] = (c2 << 6) | c3; + } + len -= 4; + i += 3; + p += 4; + } + if (p[2] == '=') + { + if ((c0 = decode_char( p[0] )) > 63) return 0; + if ((c1 = decode_char( p[1] )) > 63) return 0; + if (buf) buf[i] = (c0 << 2) | (c1 >> 4); + i++; + } + else if (p[3] == '=') + { + if ((c0 = decode_char( p[0] )) > 63) return 0; + if ((c1 = decode_char( p[1] )) > 63) return 0; + if ((c2 = decode_char( p[2] )) > 63) return 0; + if (buf) + { + buf[i + 0] = (c0 << 2) | (c1 >> 4); + buf[i + 1] = (c1 << 4) | (c2 >> 2); + } + i += 2; + } + else + { + if ((c0 = decode_char( p[0] )) > 63) return 0; + if ((c1 = decode_char( p[1] )) > 63) return 0; + if ((c2 = decode_char( p[2] )) > 63) return 0; + if ((c3 = decode_char( p[3] )) > 63) return 0; + if (buf) + { + buf[i + 0] = (c0 << 2) | (c1 >> 4); + buf[i + 1] = (c1 << 4) | (c2 >> 2); + buf[i + 2] = (c2 << 6) | c3; + } + i += 3; + } + return i; +} + +struct md4_ctx +{ + unsigned int buf[4]; + unsigned int i[2]; + unsigned char in[64]; + unsigned char digest[16]; +}; + +void WINAPI MD4Init( struct md4_ctx * ); +void WINAPI MD4Update( struct md4_ctx *, const char *, unsigned int ); +void WINAPI MD4Final( struct md4_ctx * ); + +static void create_ntlm1_session_key( const char *secret, unsigned int len, char *session_key ) +{ + struct md4_ctx ctx; + char hash[16]; + + MD4Init( &ctx ); + MD4Update( &ctx, secret, len ); + MD4Final( &ctx ); + memcpy( hash, ctx.digest, 16 ); + + MD4Init( &ctx ); + MD4Update( &ctx, hash, 16 ); + MD4Final( &ctx ); + memcpy( session_key, ctx.digest, 16 ); +} + +struct md5_ctx +{ + unsigned int i[2]; + unsigned int buf[4]; + unsigned char in[64]; + unsigned char digest[16]; +}; + +void WINAPI MD5Init( struct md5_ctx * ); +void WINAPI MD5Update( struct md5_ctx *, const char *, unsigned int ); +void WINAPI MD5Final( struct md5_ctx * ); + +static void calc_ntlm2_subkey( const char *session_key, const char *magic, char *subkey ) +{ + struct md5_ctx ctx; + + MD5Init( &ctx ); + MD5Update( &ctx, session_key, 16 ); + MD5Update( &ctx, magic, strlen(magic) + 1 ); + MD5Final( &ctx ); + memcpy( subkey, ctx.digest, 16 ); +} + +static const char client_to_server_sign_constant[] = "session key to client-to-server signing key magic constant"; +static const char client_to_server_seal_constant[] = "session key to client-to-server sealing key magic constant"; +static const char server_to_client_sign_constant[] = "session key to server-to-client signing key magic constant"; +static const char server_to_client_seal_constant[] = "session key to server-to-client sealing key magic constant"; + +static void create_ntlm2_subkeys( struct ntlm_ctx *ctx ) +{ + if (ctx->mode == MODE_CLIENT) + { + calc_ntlm2_subkey( ctx->session_key, client_to_server_sign_constant, ctx->crypt.ntlm2.send_sign_key ); + calc_ntlm2_subkey( ctx->session_key, client_to_server_seal_constant, ctx->crypt.ntlm2.send_seal_key ); + calc_ntlm2_subkey( ctx->session_key, server_to_client_sign_constant, ctx->crypt.ntlm2.recv_sign_key ); + calc_ntlm2_subkey( ctx->session_key, server_to_client_seal_constant, ctx->crypt.ntlm2.recv_seal_key ); + } + else + { + calc_ntlm2_subkey( ctx->session_key, server_to_client_sign_constant, ctx->crypt.ntlm2.send_sign_key ); + calc_ntlm2_subkey( ctx->session_key, server_to_client_seal_constant, ctx->crypt.ntlm2.send_seal_key ); + calc_ntlm2_subkey( ctx->session_key, client_to_server_sign_constant, ctx->crypt.ntlm2.recv_sign_key ); + calc_ntlm2_subkey( ctx->session_key, client_to_server_seal_constant, ctx->crypt.ntlm2.recv_seal_key ); + } +} + +/* + * The arc4 code is based on dlls/advapi32/crypt_arc4.c by Mike McCormack, + * which in turn is based on public domain code by Wei Dai + */ +static void arc4_init( struct arc4_info *info, const char *key, unsigned int len ) +{ + unsigned int key_idx = 0, state_idx = 0, i, a; + + info->x = info->y = 0; + for (i = 0; i < 256; i++) info->state[i] = i; + + for (i = 0; i < 256; i++) + { + a = info->state[i]; + state_idx += key[key_idx] + a; + state_idx &= 0xff; + info->state[i] = info->state[state_idx]; + info->state[state_idx] = a; + if (++key_idx >= len) key_idx = 0; + } +} + +static int get_buffer_index( SecBufferDesc *desc, ULONG type ) +{ + int idx; + for (idx = 0; idx < desc->cBuffers; idx++) + { + if (desc->pBuffers[idx].BufferType == type) return idx; + } + return -1; +} + +static NTSTATUS NTAPI ntlm_SpInitLsaModeContext( LSA_SEC_HANDLE cred_handle, LSA_SEC_HANDLE ctx_handle, + UNICODE_STRING *target, ULONG ctx_req, ULONG data_rep, + SecBufferDesc *input, LSA_SEC_HANDLE *new_ctx_handle, + SecBufferDesc *output, ULONG *ctx_attr, TimeStamp *expiry, + BOOLEAN *mapped_ctx, SecBuffer *ctx_data ) +{ + NTSTATUS status = SEC_E_INSUFFICIENT_MEMORY; + struct ntlm_ctx *ctx = NULL; + char *buf, *bin, *want_flags = NULL, *username = NULL, *domain = NULL, *password = NULL; + unsigned int len, bin_len; + int idx; + + TRACE( "%lx, %lx, %s, 0x%08x, %u, %p, %p, %p, %p, %p, %p, %p\n", cred_handle, ctx_handle, debugstr_us(target), + ctx_req, data_rep, input, new_ctx_handle, output, ctx_attr, expiry, mapped_ctx, ctx_data ); + + /* when communicating with the client there can be the following reply packets: + * YR <base64 blob> should be sent to the server + * PW should be sent back to helper with base64 encoded password + * AF <base64 blob> client is done, blob should be sent to server with KK prefixed + * GF <string list> a string list of negotiated flags + * GK <base64 blob> base64 encoded session key + * BH <char reason> something broke + * + * The squid cache size is 2010 chars and that's what ntlm_auth uses */ + + if (!(buf = malloc( NTLM_MAX_BUF ))) return SEC_E_INSUFFICIENT_MEMORY; + if (!(bin = malloc( NTLM_MAX_BUF ))) goto done; + + if (!ctx_handle && !input) + { + char *argv[5]; + int password_len = 0; + struct ntlm_cred *cred = (struct ntlm_cred *)cred_handle; + + if (!cred || cred->mode != MODE_CLIENT) + { + status = SEC_E_INVALID_HANDLE; + goto done; + } + + argv[0] = (char *)"ntlm_auth"; + argv[1] = (char *)"--helper-protocol=ntlmssp-client-1"; + if (!cred->username_arg && !cred->domain_arg) + { + WKSTA_USER_INFO_1 *ui = NULL; + NET_API_STATUS ret; + CREDENTIALW *cached; + + if (get_cached_credential( target, &cached )) + { + WCHAR *p; + if ((p = wcschr( cached->UserName, '\\' ))) + { + if (!(domain = get_domain_arg( cached->UserName, p - cached->UserName ))) goto done; + p++; + } + else + { + if (!(domain = get_domain_arg( NULL, 0 ))) goto done; + p = cached->UserName; + } + if (!(username = get_username_arg( p, -1 ))) goto done; + + if (cached->CredentialBlobSize) + { + password_len = WideCharToMultiByte( CP_UNIXCP, WC_NO_BEST_FIT_CHARS, (WCHAR *)cached->CredentialBlob, + cached->CredentialBlobSize / sizeof(WCHAR), NULL, 0, NULL, NULL ); + if (!(password = malloc( password_len ))) goto done; + WideCharToMultiByte( CP_UNIXCP, WC_NO_BEST_FIT_CHARS, (WCHAR *)cached->CredentialBlob, + cached->CredentialBlobSize / sizeof(WCHAR), password, password_len, NULL, NULL ); + } + CredFree( cached ); + + argv[2] = username; + argv[3] = domain; + argv[4] = NULL; + } + else + { + ret = NetWkstaUserGetInfo( NULL, 1, (BYTE **)&ui ); + if (ret != NERR_Success || !ui || cred->no_cached_credentials) + { + status = SEC_E_NO_CREDENTIALS; + goto done; + } + if (!(username = get_username_arg( ui->wkui1_username, -1 ))) goto done; + NetApiBufferFree( ui ); + TRACE("using cached credentials\n"); + + argv[2] = username; + argv[3] = (char *)"--use-cached-creds"; + argv[4] = NULL; + } + } + else + { + argv[2] = cred->username_arg; + argv[3] = cred->domain_arg; + argv[4] = NULL; + } + + if ((status = ntlm_funcs->fork( argv, &ctx )) != SEC_E_OK) goto done; + status = SEC_E_INSUFFICIENT_MEMORY; + + ctx->mode = MODE_CLIENT; + memset( ctx->session_key, 0, sizeof(ctx->session_key) ); + + /* generate the dummy session key = MD4(MD4(password))*/ + if (password || cred->password) + { + WCHAR *passwordW; + len = MultiByteToWideChar( CP_ACP, 0, password ? password : cred->password, + password ? password_len : cred->password_len, NULL, 0 ); + if (!(passwordW = malloc( len * sizeof(WCHAR) ))) goto done; + MultiByteToWideChar( CP_ACP, 0, password ? password : cred->password, + password ? password_len : cred->password_len, passwordW, len ); + + create_ntlm1_session_key( (const char *)passwordW, len * sizeof(WCHAR), ctx->session_key ); + free( passwordW ); + } + + /* allocate space for a maximum string of + * "SF NTLMSSP_FEATURE_SIGN NTLMSSP_FEATURE_SEAL NTLMSSP_FEATURE_SESSION_KEY" + */ + if (!(want_flags = malloc( 73 ))) goto done; + strcpy( want_flags, "SF" ); + if (ctx_req & ISC_REQ_CONFIDENTIALITY) strcat( want_flags, " NTLMSSP_FEATURE_SEAL" ); + if ((ctx_req & ISC_REQ_INTEGRITY) || (ctx_req & ISC_REQ_REPLAY_DETECT) || + (ctx_req & ISC_REQ_SEQUENCE_DETECT)) strcat( want_flags, " NTLMSSP_FEATURE_SIGN" ); + + if (ctx_req & ISC_REQ_CONNECTION) ctx->attrs |= ISC_RET_CONNECTION; + if (ctx_req & ISC_REQ_EXTENDED_ERROR) ctx->attrs |= ISC_RET_EXTENDED_ERROR; + if (ctx_req & ISC_REQ_MUTUAL_AUTH) ctx->attrs |= ISC_RET_MUTUAL_AUTH; + if (ctx_req & ISC_REQ_USE_DCE_STYLE) ctx->attrs |= ISC_RET_USED_DCE_STYLE; + if (ctx_req & ISC_REQ_DELEGATE) ctx->attrs |= ISC_RET_DELEGATE; + if (ctx_req & ISC_REQ_STREAM) FIXME( "ISC_REQ_STREAM\n" ); + + /* use cached credentials if no password was given, fall back to an empty password on failure */ + if (!password && !cred->password) + { + strcpy( buf, "OK" ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + + /* if the helper replied with "PW" using cached credentials failed */ + if (!strncmp( buf, "PW", 2 )) + { + TRACE( "using cached credentials failed\n" ); + strcpy( buf, "PW AA==" ); + } + else strcpy( buf, "OK" ); /* just do a noop on the next run */ + } + else + { + strcpy( buf, "PW " ); + encode_base64( password ? password : cred->password, password ? password_len : cred->password_len, buf + 3 ); + } + + TRACE( "sending to ntlm_auth: %s\n", debugstr_a(buf) ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + TRACE( "ntlm_auth returned %s\n", debugstr_a(buf) ); + + if (strlen( want_flags ) > 2) + { + TRACE( "want flags are %s\n", debugstr_a(want_flags) ); + strcpy( buf, want_flags ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + if (!strncmp( buf, "BH", 2 )) ERR( "ntlm_auth doesn't understand new command set\n" ); + } + + strcpy( buf, "YR" ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + TRACE( "ntlm_auth returned %s\n", buf ); + if (strncmp( buf, "YR ", 3 )) + { + status = SEC_E_INTERNAL_ERROR; + goto done; + } + bin_len = decode_base64( buf + 3, len - 3, bin ); + + *new_ctx_handle = (LSA_SEC_HANDLE)ctx; + status = SEC_I_CONTINUE_NEEDED; + } + else /* !ctx_handle && !input */ + { + if (!input || ((idx = get_buffer_index( input, SECBUFFER_TOKEN )) == -1)) + { + status = SEC_E_INVALID_TOKEN; + goto done; + } + + ctx = (struct ntlm_ctx *)ctx_handle; + if (!ctx || ctx->mode != MODE_CLIENT) + { + status = SEC_E_INVALID_HANDLE; + goto done; + } + + if (!input->pBuffers[idx].pvBuffer || input->pBuffers[idx].cbBuffer > NTLM_MAX_BUF) + { + status = SEC_E_INVALID_TOKEN; + goto done; + } + bin_len = input->pBuffers[idx].cbBuffer; + memcpy( bin, input->pBuffers[idx].pvBuffer, bin_len ); + + strcpy( buf, "TT " ); + encode_base64( bin, bin_len, buf + 3 ); + TRACE( "server sent: %s\n", debugstr_a(buf) ); + + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len ))) goto done; + TRACE( "ntlm_auth returned: %s\n", debugstr_a(buf) ); + + if (strncmp( buf, "KK ", 3 ) && strncmp( buf, "AF ", 3 )) + { + status = SEC_E_INVALID_TOKEN; + goto done; + } + bin_len = decode_base64( buf + 3, len - 3, bin ); + + *new_ctx_handle = (LSA_SEC_HANDLE)ctx; + status = SEC_E_OK; + } + + if (!output || ((idx = get_buffer_index( output, SECBUFFER_TOKEN )) == -1)) + { + if (!ctx_handle && !input) *new_ctx_handle = 0; + status = SEC_E_BUFFER_TOO_SMALL; + goto done; + } + + if (ctx_req & ISC_REQ_ALLOCATE_MEMORY) + { + if (!(output->pBuffers[idx].pvBuffer = malloc( bin_len ))) + { + status = SEC_E_INSUFFICIENT_MEMORY; + goto done; + } + output->pBuffers[idx].cbBuffer = bin_len; + } + else if (output->pBuffers[idx].cbBuffer < bin_len) + { + if (!ctx_handle && !input) *new_ctx_handle = 0; + status = SEC_E_BUFFER_TOO_SMALL; + goto done; + } + + if (!output->pBuffers[idx].pvBuffer) + { + if (!ctx_handle && !input) *new_ctx_handle = 0; + status = SEC_E_INTERNAL_ERROR; + goto done; + } + + output->pBuffers[idx].cbBuffer = bin_len; + memcpy( output->pBuffers[idx].pvBuffer, bin, bin_len ); + if (status == SEC_E_OK) + { + strcpy( buf, "GF" ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + if (len < 3) ctx->flags = 0; + else sscanf( buf + 3, "%x", &ctx->flags ); + + strcpy( buf, "GK" ); + if ((status = ntlm_funcs->chat( ctx, buf, NTLM_MAX_BUF, &len )) != SEC_E_OK) goto done; + + if (!strncmp( buf, "BH", 2 )) TRACE( "no key negotiated\n" ); + else if (!strncmp( buf, "GK ", 3 )) + { + bin_len = decode_base64( buf + 3, len - 3, bin ); + TRACE( "session key is %s\n", debugstr_a(buf + 3) ); + memcpy( ctx->session_key, bin, bin_len ); + } + + arc4_init( &ctx->crypt.ntlm.arc4info, ctx->session_key, 16 ); + ctx->crypt.ntlm.seq_no = 0; + create_ntlm2_subkeys( ctx ); + arc4_init( &ctx->crypt.ntlm2.send_arc4info, ctx->crypt.ntlm2.send_seal_key, 16 ); + arc4_init( &ctx->crypt.ntlm2.recv_arc4info, ctx->crypt.ntlm2.recv_seal_key, 16 ); + ctx->crypt.ntlm2.send_seq_no = 0; + ctx->crypt.ntlm2.recv_seq_no = 0; + } + +done: + if (status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) ntlm_funcs->cleanup( ctx ); + free( username ); + free( domain ); + free( password ); + free( buf ); + free( bin ); + free( want_flags ); + + TRACE( "returning %08x\n", status ); + return status; +} + +static NTSTATUS NTAPI ntlm_SpDeleteContext( LSA_SEC_HANDLE handle ) +{ + struct ntlm_ctx *ctx = (struct ntlm_ctx *)handle; + + TRACE( "%lx\n", handle ); + + if (!ctx) return SEC_E_INVALID_HANDLE; + ntlm_funcs->cleanup( ctx ); + return SEC_E_OK; +} + static SECPKG_FUNCTION_TABLE ntlm_table = { ntlm_LsaApInitializePackage, @@ -302,9 +859,9 @@ static SECPKG_FUNCTION_TABLE ntlm_table = NULL, /* SaveCredentials */ NULL, /* GetCredentials */ NULL, /* DeleteCredentials */ - NULL, /* SpInitLsaModeContext */ + ntlm_SpInitLsaModeContext, NULL, /* SpAcceptLsaModeContext */ - NULL, /* SpDeleteContext */ + ntlm_SpDeleteContext, NULL, /* ApplyControlToken */ NULL, /* GetUserInfo */ NULL, /* GetExtendedInformation */ diff --git a/dlls/msv1_0/unixlib.c b/dlls/msv1_0/unixlib.c index 098b921e985..83975803aa2 100644 --- a/dlls/msv1_0/unixlib.c +++ b/dlls/msv1_0/unixlib.c @@ -41,6 +41,73 @@ WINE_DEFAULT_DEBUG_CHANNEL(ntlm); WINE_DECLARE_DEBUG_CHANNEL(winediag); +#define INITIAL_BUFFER_SIZE 200 + +static SECURITY_STATUS read_line( struct ntlm_ctx *ctx, unsigned int *offset ) +{ + char *newline; + + if (!ctx->com_buf) + { + if (!(ctx->com_buf = RtlAllocateHeap( GetProcessHeap(), 0, INITIAL_BUFFER_SIZE ))) + return SEC_E_INSUFFICIENT_MEMORY; + ctx->com_buf_size = INITIAL_BUFFER_SIZE; + ctx->com_buf_offset = 0; + } + + do + { + ssize_t size; + if (ctx->com_buf_offset + INITIAL_BUFFER_SIZE > ctx->com_buf_size) + { + char *buf = RtlReAllocateHeap( GetProcessHeap(), 0, ctx->com_buf, ctx->com_buf_size + INITIAL_BUFFER_SIZE ); + if (!buf) return SEC_E_INSUFFICIENT_MEMORY; + ctx->com_buf_size += INITIAL_BUFFER_SIZE; + ctx->com_buf = buf; + } + size = read( ctx->pipe_in, ctx->com_buf + ctx->com_buf_offset, ctx->com_buf_size - ctx->com_buf_offset ); + if (size <= 0) return SEC_E_INTERNAL_ERROR; + + ctx->com_buf_offset += size; + newline = memchr( ctx->com_buf, '\n', ctx->com_buf_offset ); + } while (!newline); + + /* if there's a newline character, and we read more than that newline, we have to store the offset so we can + preserve the additional data */ + if (newline != ctx->com_buf + ctx->com_buf_offset) *offset = (ctx->com_buf + ctx->com_buf_offset) - (newline + 1); + else *offset = 0; + + *newline = 0; + return SEC_E_OK; +} + +static SECURITY_STATUS CDECL ntlm_chat( struct ntlm_ctx *ctx, char *buf, unsigned int buflen, unsigned int *retlen ) +{ + SECURITY_STATUS status = SEC_E_OK; + unsigned int offset; + + write( ctx->pipe_out, buf, strlen(buf) ); + write( ctx->pipe_out, "\n", 1 ); + + if ((status = read_line( ctx, &offset )) != SEC_E_OK) return status; + *retlen = strlen( ctx->com_buf ); + + if (*retlen > buflen) return SEC_E_BUFFER_TOO_SMALL; + if (*retlen < 2) return SEC_E_ILLEGAL_MESSAGE; + if (!strncmp( ctx->com_buf, "ERR", 3 )) return SEC_E_INVALID_TOKEN; + + memcpy( buf, ctx->com_buf, *retlen + 1 ); + + if (!offset) ctx->com_buf_offset = 0; + else + { + memmove( ctx->com_buf, ctx->com_buf + ctx->com_buf_offset, offset ); + ctx->com_buf_offset = offset; + } + + return SEC_E_OK; +} + static void CDECL ntlm_cleanup( struct ntlm_ctx *ctx ) { if (!ctx || (ctx->mode != MODE_CLIENT && ctx->mode != MODE_SERVER)) return; @@ -172,6 +239,7 @@ static BOOL check_version( void ) static const struct ntlm_funcs funcs = { + ntlm_chat, ntlm_cleanup, ntlm_fork, }; diff --git a/dlls/msv1_0/unixlib.h b/dlls/msv1_0/unixlib.h index c0dd4ca1456..3f88251848b 100644 --- a/dlls/msv1_0/unixlib.h +++ b/dlls/msv1_0/unixlib.h @@ -90,6 +90,7 @@ struct ntlm_ctx struct ntlm_funcs { + SECURITY_STATUS (CDECL *chat)( struct ntlm_ctx *, char *, unsigned int, unsigned int * ); void (CDECL *cleanup)( struct ntlm_ctx * ); SECURITY_STATUS (CDECL *fork)( char **, struct ntlm_ctx ** ); }; -- 2.30.2

1 0

[PATCH 4/5] msv1_0: Implement SpAcquireCredentialsHandle and SpFreeCredentialsHandle.
by Hans Leidekker 29 Apr '21

29 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/main.c | 170 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 168 insertions(+), 2 deletions(-) diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c index 1b143ebf3bd..7dabd8e2ff5 100644 --- a/dlls/msv1_0/main.c +++ b/dlls/msv1_0/main.c @@ -18,6 +18,7 @@ */ #include <stdarg.h> +#include <stdlib.h> #include "ntstatus.h" #define WIN32_NO_STATUS #include "windef.h" @@ -29,6 +30,7 @@ #include "rpc.h" #include "wine/debug.h" +#include "unixlib.h" WINE_DEFAULT_DEBUG_CHANNEL(ntlm); @@ -68,6 +70,12 @@ static inline const char *debugstr_as( const STRING *str ) return debugstr_an( str->Buffer, str->Length ); } +static inline const char *debugstr_us( const UNICODE_STRING *str ) +{ + if (!str) return "<null>"; + return debugstr_wn( str->Buffer, str->Length / sizeof(WCHAR) ); +} + static NTSTATUS NTAPI ntlm_LsaApInitializePackage( ULONG package_id, LSA_DISPATCH_TABLE *dispatch, LSA_STRING *database, LSA_STRING *confidentiality, LSA_STRING **package_name ) @@ -116,6 +124,164 @@ static NTSTATUS NTAPI ntlm_SpGetInfo( SecPkgInfoW *info ) return STATUS_SUCCESS; } +static char *get_username_arg( const WCHAR *user, int user_len ) +{ + static const char arg[] = "--username="; + int len = sizeof(arg); + char *ret; + + len += WideCharToMultiByte( CP_UNIXCP, WC_NO_BEST_FIT_CHARS, user, user_len, NULL, 0, NULL, NULL ); + if (!(ret = malloc( len ))) return NULL; + memcpy( ret, arg, sizeof(arg) - 1 ); + WideCharToMultiByte( CP_UNIXCP, WC_NO_BEST_FIT_CHARS, user, user_len, ret + sizeof(arg) - 1, + len - sizeof(arg) + 1, NULL, NULL ); + ret[len - 1] = 0; + return ret; +} + +static char *get_domain_arg( const WCHAR *domain, int domain_len ) +{ + static const char arg[] = "--domain="; + int len = sizeof(arg); + char *ret; + + len += WideCharToMultiByte( CP_UNIXCP, WC_NO_BEST_FIT_CHARS, domain, domain_len, NULL, 0, NULL, NULL ); + if (!(ret = malloc( len ))) return NULL; + memcpy( ret, arg, sizeof(arg) - 1 ); + WideCharToMultiByte( CP_UNIXCP, WC_NO_BEST_FIT_CHARS, domain, domain_len, ret + sizeof(arg) - 1, + len - sizeof(arg) + 1, NULL, NULL ); + ret[len - 1] = 0; + return ret; +} + +static NTSTATUS NTAPI ntlm_SpAcquireCredentialsHandle( UNICODE_STRING *principal, ULONG cred_use, LUID *logon_id, + void *auth_data, void *get_key_fn, void *get_key_arg, + LSA_SEC_HANDLE *handle, TimeStamp *expiry ) +{ + SECURITY_STATUS status = SEC_E_INSUFFICIENT_MEMORY; + struct ntlm_cred *cred = NULL; + WCHAR *domain = NULL, *user = NULL, *password = NULL; + SEC_WINNT_AUTH_IDENTITY_W *id = NULL; + + TRACE( "%s, 0x%08x, %p, %p, %p, %p, %p, %p\n", debugstr_us(principal), cred_use, logon_id, auth_data, + get_key_fn, get_key_arg, cred, expiry ); + + switch (cred_use) + { + case SECPKG_CRED_INBOUND: + if (!(cred = malloc( sizeof(*cred) ))) return SEC_E_INSUFFICIENT_MEMORY; + cred->mode = MODE_SERVER; + cred->username_arg = NULL; + cred->domain_arg = NULL; + cred->password = NULL; + cred->password_len = 0; + cred->no_cached_credentials = 0; + + *handle = (LSA_SEC_HANDLE)cred; + status = SEC_E_OK; + break; + + case SECPKG_CRED_OUTBOUND: + if (!(cred = malloc( sizeof(*cred) ))) return SEC_E_INSUFFICIENT_MEMORY; + + cred->mode = MODE_CLIENT; + cred->username_arg = NULL; + cred->domain_arg = NULL; + cred->password = NULL; + cred->password_len = 0; + cred->no_cached_credentials = 0; + + if ((id = auth_data)) + { + int domain_len = 0, user_len = 0, password_len = 0; + if (id->Flags & SEC_WINNT_AUTH_IDENTITY_ANSI) + { + if (id->DomainLength) + { + domain_len = MultiByteToWideChar( CP_ACP, 0, (char *)id->Domain, id->DomainLength, NULL, 0 ); + if (!(domain = malloc( sizeof(WCHAR) * domain_len ))) goto done; + MultiByteToWideChar( CP_ACP, 0, (char *)id->Domain, id->DomainLength, domain, domain_len ); + } + if (id->UserLength) + { + user_len = MultiByteToWideChar( CP_ACP, 0, (char *)id->User, id->UserLength, NULL, 0 ); + if (!(user = malloc( sizeof(WCHAR) * user_len ))) goto done; + MultiByteToWideChar( CP_ACP, 0, (char *)id->User, id->UserLength, user, user_len ); + } + if (id->PasswordLength) + { + password_len = MultiByteToWideChar( CP_ACP, 0,(char *)id->Password, id->PasswordLength, NULL, 0 ); + if (!(password = malloc( sizeof(WCHAR) * password_len ))) goto done; + MultiByteToWideChar( CP_ACP, 0, (char *)id->Password, id->PasswordLength, password, password_len ); + } + } + else + { + domain = id->Domain; + domain_len = id->DomainLength; + user = id->User; + user_len = id->UserLength; + password = id->Password; + password_len = id->PasswordLength; + } + + TRACE( "username is %s\n", debugstr_wn(user, user_len) ); + TRACE( "domain name is %s\n", debugstr_wn(domain, domain_len) ); + + cred->username_arg = get_username_arg( user, user_len ); + cred->domain_arg = get_domain_arg( domain, domain_len ); + if (password_len) + { + cred->password_len = WideCharToMultiByte( CP_UNIXCP, WC_NO_BEST_FIT_CHARS, password, password_len, + NULL, 0, NULL, NULL ); + if (!(cred->password = malloc( cred->password_len ))) goto done; + WideCharToMultiByte( CP_UNIXCP, WC_NO_BEST_FIT_CHARS, password, password_len, cred->password, + cred->password_len, NULL, NULL ); + } + } + + *handle = (LSA_SEC_HANDLE)cred; + status = SEC_E_OK; + break; + + case SECPKG_CRED_BOTH: + FIXME( "SECPKG_CRED_BOTH not supported\n" ); + status = SEC_E_UNSUPPORTED_FUNCTION; + break; + + default: + status = SEC_E_UNKNOWN_CREDENTIALS; + break; + } + +done: + if (id && (id->Flags & SEC_WINNT_AUTH_IDENTITY_ANSI)) + { + free( domain ); + free( user ); + free( password ); + } + if (status != SEC_E_OK) free( cred ); + return status; +} + +static NTSTATUS NTAPI ntlm_SpFreeCredentialsHandle( LSA_SEC_HANDLE handle ) +{ + struct ntlm_cred *cred = (struct ntlm_cred *)handle; + + TRACE( "%lx\n", handle ); + + if (!cred) return SEC_E_OK; + + cred->mode = MODE_INVALID; + if (cred->password) memset( cred->password, 0, cred->password_len ); + free( cred->password ); + free( cred->username_arg ); + free( cred->domain_arg ); + free( cred ); + return SEC_E_OK; +} + static SECPKG_FUNCTION_TABLE ntlm_table = { ntlm_LsaApInitializePackage, @@ -130,9 +296,9 @@ static SECPKG_FUNCTION_TABLE ntlm_table = NULL, /* SpShutdown */ ntlm_SpGetInfo, NULL, /* AcceptCredentials */ - NULL, /* SpAcquireCredentialsHandle */ + ntlm_SpAcquireCredentialsHandle, NULL, /* SpQueryCredentialsAttributes */ - NULL, /* SpFreeCredentialsHandle */ + ntlm_SpFreeCredentialsHandle, NULL, /* SaveCredentials */ NULL, /* GetCredentials */ NULL, /* DeleteCredentials */ -- 2.30.2

1 0

[PATCH 3/5] msv1_0: Add a Unix library to support ntlm_auth.
by Hans Leidekker 29 Apr '21

29 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/Makefile.in | 3 +- dlls/msv1_0/main.c | 31 ++++++- dlls/msv1_0/msv1_0.spec | 2 +- dlls/msv1_0/unixlib.c | 185 ++++++++++++++++++++++++++++++++++++++++ dlls/msv1_0/unixlib.h | 97 +++++++++++++++++++++ 5 files changed, 315 insertions(+), 3 deletions(-) create mode 100644 dlls/msv1_0/unixlib.c create mode 100644 dlls/msv1_0/unixlib.h diff --git a/dlls/msv1_0/Makefile.in b/dlls/msv1_0/Makefile.in index 155ce593ab1..21a9c61e317 100644 --- a/dlls/msv1_0/Makefile.in +++ b/dlls/msv1_0/Makefile.in @@ -3,4 +3,5 @@ MODULE = msv1_0.dll EXTRADLLFLAGS = -mno-cygwin C_SRCS = \ - main.c + main.c \ + unixlib.c diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c index d3480c563f0..1b143ebf3bd 100644 --- a/dlls/msv1_0/main.c +++ b/dlls/msv1_0/main.c @@ -32,9 +32,12 @@ WINE_DEFAULT_DEBUG_CHANNEL(ntlm); +static HINSTANCE instance; static ULONG ntlm_package_id; static LSA_DISPATCH_TABLE lsa_dispatch; +const struct ntlm_funcs *ntlm_funcs = NULL; + #define NTLM_CAPS \ ( SECPKG_FLAG_INTEGRITY \ | SECPKG_FLAG_PRIVACY \ @@ -75,6 +78,12 @@ static NTSTATUS NTAPI ntlm_LsaApInitializePackage( ULONG package_id, LSA_DISPATC TRACE( "%08x, %p, %s, %s, %p\n", package_id, dispatch, debugstr_as(database), debugstr_as(confidentiality), package_name ); + if (!ntlm_funcs && __wine_init_unix_lib( instance, DLL_PROCESS_ATTACH, NULL, &ntlm_funcs )) + { + ERR( "no NTLM support, expect problems\n" ); + return STATUS_UNSUCCESSFUL; + } + if (!(str = dispatch->AllocateLsaHeap( sizeof(*str) + sizeof("NTLM" )))) return STATUS_NO_MEMORY; ptr = (char *)(str + 1); memcpy( ptr, "NTLM", sizeof("NTLM") ); @@ -90,7 +99,13 @@ static NTSTATUS NTAPI ntlm_LsaApInitializePackage( ULONG package_id, LSA_DISPATC static NTSTATUS NTAPI ntlm_SpInitialize( ULONG_PTR package_id, SECPKG_PARAMETERS *params, LSA_SECPKG_FUNCTION_TABLE *lsa_function_table ) { - FIXME( "%lu, %p, %p\n", package_id, params, lsa_function_table ); + TRACE( "%lu, %p, %p\n", package_id, params, lsa_function_table ); + + if (!ntlm_funcs && __wine_init_unix_lib( instance, DLL_PROCESS_ATTACH, NULL, &ntlm_funcs )) + { + ERR( "no NTLM support, expect problems\n" ); + return STATUS_UNSUCCESSFUL; + } return STATUS_SUCCESS; } @@ -186,3 +201,17 @@ NTSTATUS NTAPI SpUserModeInitialize( ULONG lsa_version, ULONG *package_version, *table_count = 1; return STATUS_SUCCESS; } + +BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, void *reserved ) +{ + switch (reason) + { + case DLL_PROCESS_ATTACH: + instance = hinst; + DisableThreadLibraryCalls( hinst ); + break; + case DLL_PROCESS_DETACH: + break; + } + return TRUE; +} diff --git a/dlls/msv1_0/msv1_0.spec b/dlls/msv1_0/msv1_0.spec index f751ed40521..9dc2eefae5e 100644 --- a/dlls/msv1_0/msv1_0.spec +++ b/dlls/msv1_0/msv1_0.spec @@ -1,4 +1,4 @@ -@ stub DllMain +@ stdcall -private DllMain(long long ptr) @ stub LsaApCallPackage @ stub LsaApCallPackagePassthrough @ stub LsaApCallPackageUntrusted diff --git a/dlls/msv1_0/unixlib.c b/dlls/msv1_0/unixlib.c new file mode 100644 index 00000000000..098b921e985 --- /dev/null +++ b/dlls/msv1_0/unixlib.c @@ -0,0 +1,185 @@ +/* + * Unix interface for ntlm_auth + * + * Copyright 2005, 2006 Kai Blin + * Copyright 2021 Hans Leidekker for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#if 0 +#pragma makedep unix +#endif + +#include <stdarg.h> +#include <unistd.h> +#include <fcntl.h> +#include <errno.h> +#include <sys/wait.h> +#include "ntstatus.h" +#define WIN32_NO_STATUS +#include "windef.h" +#include "winternl.h" +#include "winbase.h" +#include "sspi.h" + +#include "wine/debug.h" +#include "unixlib.h" + +WINE_DEFAULT_DEBUG_CHANNEL(ntlm); +WINE_DECLARE_DEBUG_CHANNEL(winediag); + +static void CDECL ntlm_cleanup( struct ntlm_ctx *ctx ) +{ + if (!ctx || (ctx->mode != MODE_CLIENT && ctx->mode != MODE_SERVER)) return; + ctx->mode = MODE_INVALID; + + /* closing stdin will terminate ntlm_auth */ + close( ctx->pipe_out ); + close( ctx->pipe_in ); + + if (ctx->pid > 0) /* reap child */ + { + pid_t ret; + do { + ret = waitpid( ctx->pid, NULL, 0 ); + } while (ret < 0 && errno == EINTR); + } + + RtlFreeHeap( GetProcessHeap(), 0, ctx->com_buf ); + RtlFreeHeap( GetProcessHeap(), 0, ctx ); +} + +static SECURITY_STATUS CDECL ntlm_fork( char **argv, struct ntlm_ctx **ret_ctx ) +{ + int pipe_in[2], pipe_out[2]; + struct ntlm_ctx *ctx; + +#ifdef HAVE_PIPE2 + if (pipe2( pipe_in, O_CLOEXEC ) < 0) +#endif + { + if (pipe( pipe_in ) < 0 ) return SEC_E_INTERNAL_ERROR; + fcntl( pipe_in[0], F_SETFD, FD_CLOEXEC ); + fcntl( pipe_in[1], F_SETFD, FD_CLOEXEC ); + } +#ifdef HAVE_PIPE2 + if (pipe2( pipe_out, O_CLOEXEC ) < 0) +#endif + { + if (pipe( pipe_out ) < 0) + { + close( pipe_in[0] ); + close( pipe_in[1] ); + return SEC_E_INTERNAL_ERROR; + } + fcntl( pipe_out[0], F_SETFD, FD_CLOEXEC ); + fcntl( pipe_out[1], F_SETFD, FD_CLOEXEC ); + } + + if (!(ctx = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ctx) ))) + { + close( pipe_in[0] ); + close( pipe_in[1] ); + close( pipe_out[0] ); + close( pipe_out[1] ); + return SEC_E_INSUFFICIENT_MEMORY; + } + + if (!(ctx->pid = fork())) /* child */ + { + dup2( pipe_out[0], 0 ); + close( pipe_out[0] ); + close( pipe_out[1] ); + + dup2( pipe_in[1], 1 ); + close( pipe_in[0] ); + close( pipe_in[1] ); + + execvp( argv[0], argv ); + + write( 1, "BH\n", 3 ); + _exit( 1 ); + } + else + { + ctx->pipe_in = pipe_in[0]; + close( pipe_in[1] ); + ctx->pipe_out = pipe_out[1]; + close( pipe_out[0] ); + *ret_ctx = ctx; + } + + return SEC_E_OK; +} + +#define NTLM_AUTH_MAJOR_VERSION 3 +#define NTLM_AUTH_MINOR_VERSION 0 +#define NTLM_AUTH_MICRO_VERSION 25 + +static BOOL check_version( void ) +{ + struct ntlm_ctx *ctx; + char *argv[3], buf[80]; + BOOL ret = FALSE; + int len; + + argv[0] = (char *)"ntlm_auth"; + argv[1] = (char *)"--version"; + argv[2] = NULL; + if (ntlm_fork( argv, &ctx ) != SEC_E_OK) return FALSE; + + if ((len = read( ctx->pipe_in, buf, sizeof(buf) - 1 )) > 8) + { + char *newline; + int major = 0, minor = 0, micro = 0; + + if ((newline = memchr( buf, '\n', len ))) *newline = 0; + else buf[len] = 0; + + if (sscanf( buf, "Version %d.%d.%d", &major, &minor, &micro ) == 3) + { + if (((major > NTLM_AUTH_MAJOR_VERSION) || + (major == NTLM_AUTH_MAJOR_VERSION && minor > NTLM_AUTH_MINOR_VERSION) || + (major == NTLM_AUTH_MAJOR_VERSION && minor == NTLM_AUTH_MINOR_VERSION && + micro >= NTLM_AUTH_MICRO_VERSION))) + { + TRACE( "detected ntlm_auth version %d.%d.%d\n", major, minor, micro ); + ret = TRUE; + } + } + } + + if (!ret) ERR_(winediag)( "ntlm_auth was not found or is outdated. " + "Make sure that ntlm_auth >= %d.%d.%d is in your path. " + "Usually, you can find it in the winbind package of your distribution.\n", + NTLM_AUTH_MAJOR_VERSION, NTLM_AUTH_MINOR_VERSION, NTLM_AUTH_MICRO_VERSION ); + ntlm_cleanup( ctx ); + return ret; +} + +static const struct ntlm_funcs funcs = +{ + ntlm_cleanup, + ntlm_fork, +}; + +NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out ) +{ + if (reason != DLL_PROCESS_ATTACH) return STATUS_SUCCESS; + if (!check_version()) return STATUS_DLL_NOT_FOUND; + *(const struct ntlm_funcs **)ptr_out = &funcs; + return STATUS_SUCCESS; +} diff --git a/dlls/msv1_0/unixlib.h b/dlls/msv1_0/unixlib.h new file mode 100644 index 00000000000..c0dd4ca1456 --- /dev/null +++ b/dlls/msv1_0/unixlib.h @@ -0,0 +1,97 @@ +/* + * Copyright 2005, 2006 Kai Blin + * Copyright 2021 Hans Leidekker for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <sys/types.h> + +enum sign_direction +{ + SIGN_SEND, + SIGN_RECV, +}; + +enum mode +{ + MODE_INVALID = -1, + MODE_CLIENT, + MODE_SERVER, +}; + +struct ntlm_cred +{ + enum mode mode; + char *username_arg; + char *domain_arg; + char *password; + int password_len; + int no_cached_credentials; /* don't try to use cached Samba credentials */ +}; + +struct arc4_info +{ + char x; + char y; + char state[256]; +}; + +#define FLAG_NEGOTIATE_SIGN 0x00000010 +#define FLAG_NEGOTIATE_SEAL 0x00000020 +#define FLAG_NEGOTIATE_ALWAYS_SIGN 0x00008000 +#define FLAG_NEGOTIATE_NTLM2 0x00080000 +#define FLAG_NEGOTIATE_KEY_EXCHANGE 0x40000000 + +struct ntlm_ctx +{ + enum mode mode; + pid_t pid; + unsigned int attrs; + int pipe_in; + int pipe_out; + char *com_buf; + unsigned int com_buf_size; + unsigned int com_buf_offset; + char session_key[16]; + unsigned int flags; + struct + { + struct + { + unsigned int seq_no; + struct arc4_info arc4info; + } ntlm; + struct + { + char send_sign_key[16]; + char send_seal_key[16]; + char recv_sign_key[16]; + char recv_seal_key[16]; + unsigned int send_seq_no; + unsigned int recv_seq_no; + struct arc4_info send_arc4info; + struct arc4_info recv_arc4info; + } ntlm2; + } crypt; +}; + +struct ntlm_funcs +{ + void (CDECL *cleanup)( struct ntlm_ctx * ); + SECURITY_STATUS (CDECL *fork)( char **, struct ntlm_ctx ** ); +}; + +extern const struct ntlm_funcs *ntlm_funcs; -- 2.30.2

1 0

[PATCH 2/5] msv1_0: Initial implementation of the LSA and user mode interfaces.
by Hans Leidekker 29 Apr '21

29 Apr '21

Just enough to initialize the provider. Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msv1_0/Makefile.in | 3 + dlls/msv1_0/main.c | 188 ++++++++++++++++++++++++++++++++++++++++ dlls/msv1_0/msv1_0.spec | 4 +- 3 files changed, 193 insertions(+), 2 deletions(-) create mode 100644 dlls/msv1_0/main.c diff --git a/dlls/msv1_0/Makefile.in b/dlls/msv1_0/Makefile.in index ceac399a207..155ce593ab1 100644 --- a/dlls/msv1_0/Makefile.in +++ b/dlls/msv1_0/Makefile.in @@ -1,3 +1,6 @@ MODULE = msv1_0.dll EXTRADLLFLAGS = -mno-cygwin + +C_SRCS = \ + main.c diff --git a/dlls/msv1_0/main.c b/dlls/msv1_0/main.c new file mode 100644 index 00000000000..d3480c563f0 --- /dev/null +++ b/dlls/msv1_0/main.c @@ -0,0 +1,188 @@ +/* + * Copyright 2005, 2006 Kai Blin + * Copyright 2021 Hans Leidekker for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <stdarg.h> +#include "ntstatus.h" +#define WIN32_NO_STATUS +#include "windef.h" +#include "winbase.h" +#include "winternl.h" +#include "sspi.h" +#include "ntsecapi.h" +#include "ntsecpkg.h" +#include "rpc.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(ntlm); + +static ULONG ntlm_package_id; +static LSA_DISPATCH_TABLE lsa_dispatch; + +#define NTLM_CAPS \ + ( SECPKG_FLAG_INTEGRITY \ + | SECPKG_FLAG_PRIVACY \ + | SECPKG_FLAG_TOKEN_ONLY \ + | SECPKG_FLAG_CONNECTION \ + | SECPKG_FLAG_MULTI_REQUIRED \ + | SECPKG_FLAG_IMPERSONATION \ + | SECPKG_FLAG_ACCEPT_WIN32_NAME \ + | SECPKG_FLAG_NEGOTIABLE \ + | SECPKG_FLAG_LOGON \ + | SECPKG_FLAG_RESTRICTED_TOKENS ) + +#define NTLM_MAX_BUF 1904 + +static const SecPkgInfoW ntlm_package_info = +{ + NTLM_CAPS, + 1, + RPC_C_AUTHN_WINNT, + NTLM_MAX_BUF, + (SEC_WCHAR *)L"NTLM", + (SEC_WCHAR *)L"NTLM Security Package" +}; + +static inline const char *debugstr_as( const STRING *str ) +{ + if (!str) return "<null>"; + return debugstr_an( str->Buffer, str->Length ); +} + +static NTSTATUS NTAPI ntlm_LsaApInitializePackage( ULONG package_id, LSA_DISPATCH_TABLE *dispatch, + LSA_STRING *database, LSA_STRING *confidentiality, + LSA_STRING **package_name ) +{ + LSA_STRING *str; + char *ptr; + + TRACE( "%08x, %p, %s, %s, %p\n", package_id, dispatch, debugstr_as(database), debugstr_as(confidentiality), + package_name ); + + if (!(str = dispatch->AllocateLsaHeap( sizeof(*str) + sizeof("NTLM" )))) return STATUS_NO_MEMORY; + ptr = (char *)(str + 1); + memcpy( ptr, "NTLM", sizeof("NTLM") ); + RtlInitString( str, ptr ); + + ntlm_package_id = package_id; + lsa_dispatch = *dispatch; + + *package_name = str; + return STATUS_SUCCESS; +} + +static NTSTATUS NTAPI ntlm_SpInitialize( ULONG_PTR package_id, SECPKG_PARAMETERS *params, + LSA_SECPKG_FUNCTION_TABLE *lsa_function_table ) +{ + FIXME( "%lu, %p, %p\n", package_id, params, lsa_function_table ); + return STATUS_SUCCESS; +} + +static NTSTATUS NTAPI ntlm_SpGetInfo( SecPkgInfoW *info ) +{ + TRACE( "%p\n", info ); + *info = ntlm_package_info; + return STATUS_SUCCESS; +} + +static SECPKG_FUNCTION_TABLE ntlm_table = +{ + ntlm_LsaApInitializePackage, + NULL, /* LsaLogonUser */ + NULL, /* CallPackage */ + NULL, /* LogonTerminated */ + NULL, /* CallPackageUntrusted */ + NULL, /* CallPackagePassthrough */ + NULL, /* LogonUserEx */ + NULL, /* LogonUserEx2 */ + ntlm_SpInitialize, + NULL, /* SpShutdown */ + ntlm_SpGetInfo, + NULL, /* AcceptCredentials */ + NULL, /* SpAcquireCredentialsHandle */ + NULL, /* SpQueryCredentialsAttributes */ + NULL, /* SpFreeCredentialsHandle */ + NULL, /* SaveCredentials */ + NULL, /* GetCredentials */ + NULL, /* DeleteCredentials */ + NULL, /* SpInitLsaModeContext */ + NULL, /* SpAcceptLsaModeContext */ + NULL, /* SpDeleteContext */ + NULL, /* ApplyControlToken */ + NULL, /* GetUserInfo */ + NULL, /* GetExtendedInformation */ + NULL, /* SpQueryContextAttributes */ + NULL, /* SpAddCredentials */ + NULL, /* SetExtendedInformation */ + NULL, /* SetContextAttributes */ + NULL, /* SetCredentialsAttributes */ + NULL, /* ChangeAccountPassword */ + NULL, /* QueryMetaData */ + NULL, /* ExchangeMetaData */ + NULL, /* GetCredUIContext */ + NULL, /* UpdateCredentials */ + NULL, /* ValidateTargetInfo */ + NULL, /* PostLogonUser */ +}; + +NTSTATUS NTAPI SpLsaModeInitialize( ULONG lsa_version, ULONG *package_version, SECPKG_FUNCTION_TABLE **table, + ULONG *table_count ) +{ + TRACE( "%08x, %p, %p, %p\n", lsa_version, package_version, table, table_count ); + + *package_version = SECPKG_INTERFACE_VERSION; + *table = &ntlm_table; + *table_count = 1; + return STATUS_SUCCESS; +} + +static NTSTATUS NTAPI ntlm_SpInstanceInit( ULONG version, SECPKG_DLL_FUNCTIONS *dll_functions, void **user_functions ) +{ + TRACE( "%08x, %p, %p\n", version, dll_functions, user_functions ); + return STATUS_SUCCESS; +} + +static SECPKG_USER_FUNCTION_TABLE ntlm_user_table = +{ + ntlm_SpInstanceInit, + NULL, /* SpInitUserModeContext */ + NULL, /* SpMakeSignature */ + NULL, /* SpVerifySignature */ + NULL, /* SpSealMessage */ + NULL, /* SpUnsealMessage */ + NULL, /* SpGetContextToken */ + NULL, /* SpQueryContextAttributes */ + NULL, /* SpCompleteAuthToken */ + NULL, /* SpDeleteContext */ + NULL, /* SpFormatCredentialsFn */ + NULL, /* SpMarshallSupplementalCreds */ + NULL, /* SpExportSecurityContext */ + NULL /* SpImportSecurityContext */ +}; + +NTSTATUS NTAPI SpUserModeInitialize( ULONG lsa_version, ULONG *package_version, SECPKG_USER_FUNCTION_TABLE **table, + ULONG *table_count ) +{ + TRACE( "%08x, %p, %p, %p\n", lsa_version, package_version, table, table_count ); + + *package_version = SECPKG_INTERFACE_VERSION; + *table = &ntlm_user_table; + *table_count = 1; + return STATUS_SUCCESS; +} diff --git a/dlls/msv1_0/msv1_0.spec b/dlls/msv1_0/msv1_0.spec index cb544188b87..f751ed40521 100644 --- a/dlls/msv1_0/msv1_0.spec +++ b/dlls/msv1_0/msv1_0.spec @@ -15,5 +15,5 @@ @ stub MsvValidateTarget @ stub SpInitialize @ stub SpInstanceInit -@ stub SpLsaModeInitialize -@ stub SpUserModeInitialize +@ stdcall SpLsaModeInitialize(long ptr ptr ptr) +@ stdcall SpUserModeInitialize(long ptr ptr ptr) -- 2.30.2

1 0

[PATCH 1/5] msv1_0: New dll.
by Hans Leidekker 29 Apr '21

29 Apr '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- configure.ac | 1 + dlls/msv1_0/Makefile.in | 3 +++ dlls/msv1_0/msv1_0.spec | 19 +++++++++++++++++++ 3 files changed, 23 insertions(+) create mode 100644 dlls/msv1_0/Makefile.in create mode 100644 dlls/msv1_0/msv1_0.spec diff --git a/configure.ac b/configure.ac index 42d141d3214..ae5a1407dd3 100644 --- a/configure.ac +++ b/configure.ac @@ -3486,6 +3486,7 @@ WINE_CONFIG_MAKEFILE(dlls/mssip32) WINE_CONFIG_MAKEFILE(dlls/mstask) WINE_CONFIG_MAKEFILE(dlls/mstask/tests) WINE_CONFIG_MAKEFILE(dlls/msvcirt) +WINE_CONFIG_MAKEFILE(dlls/msv1_0) WINE_CONFIG_MAKEFILE(dlls/msvcirt/tests) WINE_CONFIG_MAKEFILE(dlls/msvcm80) WINE_CONFIG_MAKEFILE(dlls/msvcm90) diff --git a/dlls/msv1_0/Makefile.in b/dlls/msv1_0/Makefile.in new file mode 100644 index 00000000000..ceac399a207 --- /dev/null +++ b/dlls/msv1_0/Makefile.in @@ -0,0 +1,3 @@ +MODULE = msv1_0.dll + +EXTRADLLFLAGS = -mno-cygwin diff --git a/dlls/msv1_0/msv1_0.spec b/dlls/msv1_0/msv1_0.spec new file mode 100644 index 00000000000..cb544188b87 --- /dev/null +++ b/dlls/msv1_0/msv1_0.spec @@ -0,0 +1,19 @@ +@ stub DllMain +@ stub LsaApCallPackage +@ stub LsaApCallPackagePassthrough +@ stub LsaApCallPackageUntrusted +@ stub LsaApInitializePackage +@ stub LsaApLogonTerminated +@ stub LsaApLogonUserEx2 +@ stub Msv1_0ExportSubAuthenticationRoutine +@ stub Msv1_0SubAuthenticationPresent +@ stub MsvGetLogonAttemptCount +@ stub MsvIsIpAddressLocal +@ stub MsvIsLocalhostAliases +@ stub MsvSamLogoff +@ stub MsvSamValidate +@ stub MsvValidateTarget +@ stub SpInitialize +@ stub SpInstanceInit +@ stub SpLsaModeInitialize +@ stub SpUserModeInitialize -- 2.30.2

1 0

[PATCH 3/3] riched20: Implement TxGetNaturalSize().
by Huw Davies 29 Apr '21

29 Apr '21

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/riched20/tests/txtsrv.c | 6 +++--- dlls/riched20/txtsrv.c | 39 +++++++++++++++++++++++++++++++----- 2 files changed, 37 insertions(+), 8 deletions(-) diff --git a/dlls/riched20/tests/txtsrv.c b/dlls/riched20/tests/txtsrv.c index 7ca6074587d..3cfd5e63753 100644 --- a/dlls/riched20/tests/txtsrv.c +++ b/dlls/riched20/tests/txtsrv.c @@ -705,7 +705,7 @@ static void _check_txgetnaturalsize(HRESULT res, LONG width, LONG height, HDC hd expected_width = expected_rect.right - expected_rect.left; expected_height = expected_rect.bottom - expected_rect.top; ok_(__FILE__,line)(res == S_OK, "ITextServices_TxGetNaturalSize failed: 0x%08x.\n", res); - ok_(__FILE__,line)(width >= expected_width && width <= expected_width + 1, + todo_wine ok_(__FILE__,line)(width >= expected_width && width <= expected_width + 1, "got wrong width: %d, expected: %d {+1}.\n", width, expected_width); ok_(__FILE__,line)(height == expected_height, "got wrong height: %d, expected: %d.\n", height, expected_height); @@ -717,7 +717,7 @@ static void test_TxGetNaturalSize(void) ITextHost *host; HRESULT result; SIZEL extent; - static const WCHAR test_text[] = {'T','e','s','t','S','o','m','e','T','e','x','t',0}; + static const WCHAR test_text[] = L"TestSomeText"; LONG width, height; HDC hdcDraw; HWND hwnd; @@ -752,7 +752,7 @@ static void test_TxGetNaturalSize(void) height = 0; result = ITextServices_TxGetNaturalSize(txtserv, DVASPECT_CONTENT, hdcDraw, NULL, NULL, TXTNS_FITTOCONTENT, &extent, &width, &height); - todo_wine CHECK_TXGETNATURALSIZE(result, width, height, hdcDraw, rect, test_text); + CHECK_TXGETNATURALSIZE(result, width, height, hdcDraw, rect, test_text); ReleaseDC(hwnd, hdcDraw); DestroyWindow(hwnd); diff --git a/dlls/riched20/txtsrv.c b/dlls/riched20/txtsrv.c index 79ade0f6117..5736964c1b1 100644 --- a/dlls/riched20/txtsrv.c +++ b/dlls/riched20/txtsrv.c @@ -366,14 +366,43 @@ DECLSPEC_HIDDEN HRESULT __thiscall fnTextSrv_TxGetBaseLinePos(ITextServices *ifa } DEFINE_THISCALL_WRAPPER(fnTextSrv_TxGetNaturalSize,36) -DECLSPEC_HIDDEN HRESULT __thiscall fnTextSrv_TxGetNaturalSize(ITextServices *iface, DWORD dwAspect, HDC hdcDraw, - HDC hicTargetDev, DVTARGETDEVICE *ptd, DWORD dwMode, - const SIZEL *psizelExtent, LONG *pwidth, LONG *pheight) +DECLSPEC_HIDDEN HRESULT __thiscall fnTextSrv_TxGetNaturalSize( ITextServices *iface, DWORD aspect, HDC draw, + HDC target, DVTARGETDEVICE *td, DWORD mode, + const SIZEL *extent, LONG *width, LONG *height ) { struct text_services *services = impl_from_ITextServices( iface ); + RECT rect; + HDC dc = draw; + BOOL rewrap = FALSE; + HRESULT hr; - FIXME( "%p: STUB\n", services ); - return E_NOTIMPL; + TRACE( "%p: aspect %d, draw %p, target %p, td %p, mode %08x, extent %s, *width %d, *height %d\n", services, + aspect, draw, target, td, mode, wine_dbgstr_point( (POINT *)extent ), *width, *height ); + + if (aspect != DVASPECT_CONTENT || target || td || mode != TXTNS_FITTOCONTENT ) + FIXME( "Many arguments are ignored\n" ); + + SetRect( &rect, 0, 0, *width, *height ); + + hr = update_client_rect( services, &rect ); + if (FAILED( hr )) return hr; + if (hr == S_OK) rewrap = TRUE; + + if (!dc && services->editor->in_place_active) + dc = ITextHost_TxGetDC( services->host ); + if (!dc) return E_FAIL; + + if (rewrap) + { + editor_mark_rewrap_all( services->editor ); + wrap_marked_paras_dc( services->editor, dc, FALSE ); + } + + *width = services->editor->nTotalWidth; + *height = services->editor->nTotalLength; + + if (!draw) ITextHost_TxReleaseDC( services->host, dc ); + return S_OK; } DEFINE_THISCALL_WRAPPER(fnTextSrv_TxGetDropTarget,8) -- 2.23.0

3 2

[PATCH] ntdll/tests: Remove Qpc(Interrupt|System)TimeIncrement(Shift) checks.
by Rémi Bernon 29 Apr '21

29 Apr '21

They are not fixed and are updated from time to time (every few secs), randomly failing the tests on the testbot. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/ntdll/tests/time.c | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/dlls/ntdll/tests/time.c b/dlls/ntdll/tests/time.c index 2ed28a35d8e..90737521a4d 100644 --- a/dlls/ntdll/tests/time.c +++ b/dlls/ntdll/tests/time.c @@ -172,14 +172,6 @@ static void test_RtlQueryPerformanceCounter(void) "unexpected QpcBypassEnabled %x, expected 0x83\n", usd->u3.s.QpcBypassEnabled ); ok( usd->QpcFrequency == 10000000, "unexpected QpcFrequency %I64d, expected 10000000\n", usd->QpcFrequency ); ok( !usd->u3.s.QpcShift, "unexpected QpcShift %d, expected 0\n", usd->u3.s.QpcShift ); - ok( usd->QpcInterruptTimeIncrement == ((ULONGLONG)1 << 63), - "unexpected QpcInterruptTimeIncrement %I64x, expected 1<<63\n", usd->QpcInterruptTimeIncrement ); - ok( usd->QpcInterruptTimeIncrementShift == 1, - "unexpected QpcInterruptTimeIncrementShift %d, expected 1\n", usd->QpcInterruptTimeIncrementShift ); - ok( usd->QpcSystemTimeIncrement == ((ULONGLONG)1 << 63), - "unexpected QpcSystemTimeIncrement %I64x, expected 1<<63\n", usd->QpcSystemTimeIncrement ); - ok( usd->QpcSystemTimeIncrementShift == 1, - "unexpected QpcSystemTimeIncrementShift %d, expected 1\n", usd->QpcSystemTimeIncrementShift ); hsd = NULL; status = pNtQuerySystemInformation( SystemHypervisorSharedPageInformation, &hsd, sizeof(void *), &len ); @@ -201,10 +193,6 @@ static void test_RtlQueryPerformanceCounter(void) else { ok( usd->u3.s.QpcShift == 10, "unexpected QpcShift %d, expected 10\n", usd->u3.s.QpcShift ); - ok( usd->QpcInterruptTimeIncrementShift == 2, - "unexpected QpcInterruptTimeIncrementShift %d, expected 2\n", usd->QpcInterruptTimeIncrementShift ); - ok( usd->QpcSystemTimeIncrementShift == 2, - "unexpected QpcSystemTimeIncrementShift %d, expected 2\n", usd->QpcSystemTimeIncrementShift ); tsc0 = __rdtsc(); ret = pRtlQueryPerformanceCounter( &counter ); -- 2.31.0

1 0

[PATCH v2] ntdll/tests: Add RtlQueryPerformanceCounter tests.
by Rémi Bernon 29 Apr '21

29 Apr '21

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- v2: Stop trying to be smart and just use the helper everywhere instead of __umulh. Rename it too. dlls/ntdll/tests/time.c | 106 ++++++++++++++++++++++++++++++++++++++++ include/winternl.h | 1 + 2 files changed, 107 insertions(+) diff --git a/dlls/ntdll/tests/time.c b/dlls/ntdll/tests/time.c index 51d9115b87c..f9133f276a3 100644 --- a/dlls/ntdll/tests/time.c +++ b/dlls/ntdll/tests/time.c @@ -19,8 +19,10 @@ */ #define NONAMELESSUNION +#define NONAMELESSSTRUCT #include "ntdll_test.h" #include "ddk/wdm.h" +#include "intrin.h" #define TICKSPERSEC 10000000 #define TICKSPERMSEC 10000 @@ -35,6 +37,9 @@ static NTSTATUS (WINAPI *pRtlQueryTimeZoneInformation)( RTL_TIME_ZONE_INFORMATIO static NTSTATUS (WINAPI *pRtlQueryDynamicTimeZoneInformation)( RTL_DYNAMIC_TIME_ZONE_INFORMATION *); static BOOL (WINAPI *pRtlQueryUnbiasedInterruptTime)( ULONGLONG *time ); +static BOOL (WINAPI *pRtlQueryPerformanceCounter)(LARGE_INTEGER*); +static BOOL (WINAPI *pRtlQueryPerformanceFrequency)(LARGE_INTEGER*); + static const int MonthLengths[2][12] = { { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, @@ -122,6 +127,104 @@ static void test_NtQueryPerformanceCounter(void) ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status); } +struct hypervisor_shared_data +{ + UINT64 unknown; + UINT64 QpcMultiplier; + UINT64 QpcBias; +}; + +/* 128-bit multiply a by b and return the high 64 bits, same as __umulh */ +static UINT64 multiply_tsc(UINT64 a, UINT64 b) +{ + UINT64 ah = a >> 32, al = (UINT32)a, bh = b >> 32, bl = (UINT32)b, m; + m = (ah * bl) + (bh * al) + ((al * bl) >> 32); + return (ah * bh) + (m >> 32); +} + +static void test_RtlQueryPerformanceCounter(void) +{ + struct hypervisor_shared_data *hsd; + KSHARED_USER_DATA *usd = (void *)0x7ffe0000; + LARGE_INTEGER frequency, counter; + NTSTATUS status; + UINT64 tsc0, tsc1; + ULONG len; + BOOL ret; + + if (!pRtlQueryPerformanceCounter || !pRtlQueryPerformanceFrequency) + { + win_skip( "RtlQueryPerformanceCounter/Frequency not available, skipping tests\n" ); + return; + } + + if (!(usd->u3.s.QpcBypassEnabled & SHARED_GLOBAL_FLAGS_QPC_BYPASS_ENABLED)) + { + todo_wine win_skip("QpcBypassEnabled is not set, skipping tests\n"); + return; + } + + if ((usd->u3.s.QpcBypassEnabled & SHARED_GLOBAL_FLAGS_QPC_BYPASS_USE_HV_PAGE)) + { + ok( usd->u3.s.QpcBypassEnabled == (SHARED_GLOBAL_FLAGS_QPC_BYPASS_ENABLED|SHARED_GLOBAL_FLAGS_QPC_BYPASS_USE_HV_PAGE|SHARED_GLOBAL_FLAGS_QPC_BYPASS_USE_RDTSCP), + "unexpected QpcBypassEnabled %x, expected 0x83\n", usd->u3.s.QpcBypassEnabled ); + ok( usd->QpcFrequency == 10000000, "unexpected QpcFrequency %I64d, expected 10000000\n", usd->QpcFrequency ); + ok( !usd->u3.s.QpcShift, "unexpected QpcShift %d, expected 0\n", usd->u3.s.QpcShift ); + ok( usd->QpcInterruptTimeIncrement == ((ULONGLONG)1 << 63), + "unexpected QpcInterruptTimeIncrement %I64x, expected 1<<63\n", usd->QpcInterruptTimeIncrement ); + ok( usd->QpcInterruptTimeIncrementShift == 1, + "unexpected QpcInterruptTimeIncrementShift %d, expected 1\n", usd->QpcInterruptTimeIncrementShift ); + ok( usd->QpcSystemTimeIncrement == ((ULONGLONG)1 << 63), + "unexpected QpcSystemTimeIncrement %I64x, expected 1<<63\n", usd->QpcSystemTimeIncrement ); + ok( usd->QpcSystemTimeIncrementShift == 1, + "unexpected QpcSystemTimeIncrementShift %d, expected 1\n", usd->QpcSystemTimeIncrementShift ); + + hsd = NULL; + status = pNtQuerySystemInformation( SystemHypervisorSharedPageInformation, &hsd, sizeof(void *), &len ); + ok( !status, "NtQuerySystemInformation returned %x\n", status ); + ok( len == sizeof(void *), "unexpected SystemHypervisorSharedPageInformation length %u\n", len ); + ok( !!hsd, "unexpected SystemHypervisorSharedPageInformation address %p\n", hsd ); + + tsc0 = __rdtsc(); + ret = pRtlQueryPerformanceCounter( &counter ); + tsc1 = __rdtsc(); + ok( ret, "RtlQueryPerformanceCounter failed\n" ); + + tsc0 = multiply_tsc(tsc0, hsd->QpcMultiplier) + hsd->QpcBias + usd->QpcBias; + tsc1 = multiply_tsc(tsc1, hsd->QpcMultiplier) + hsd->QpcBias + usd->QpcBias; + + ok( tsc0 <= counter.QuadPart, "rdtscp %I64d and RtlQueryPerformanceCounter %I64d are out of order\n", tsc0, counter.QuadPart ); + ok( counter.QuadPart <= tsc1, "RtlQueryPerformanceCounter %I64d and rdtscp %I64d are out of order\n", counter.QuadPart, tsc1 ); + } + else + { + ok( usd->u3.s.QpcShift == 10, "unexpected QpcShift %d, expected 10\n", usd->u3.s.QpcShift ); + ok( usd->QpcInterruptTimeIncrementShift == 2, + "unexpected QpcInterruptTimeIncrementShift %d, expected 2\n", usd->QpcInterruptTimeIncrementShift ); + ok( usd->QpcSystemTimeIncrementShift == 2, + "unexpected QpcSystemTimeIncrementShift %d, expected 2\n", usd->QpcSystemTimeIncrementShift ); + + tsc0 = __rdtsc(); + ret = pRtlQueryPerformanceCounter( &counter ); + tsc1 = __rdtsc(); + ok( ret, "RtlQueryPerformanceCounter failed\n" ); + + tsc0 += usd->QpcBias; + tsc0 >>= usd->u3.s.QpcShift; + tsc1 += usd->QpcBias; + tsc1 >>= usd->u3.s.QpcShift; + + ok( tsc0 <= counter.QuadPart, "rdtscp %I64d and RtlQueryPerformanceCounter %I64d are out of order\n", tsc0, counter.QuadPart ); + ok( counter.QuadPart <= tsc1, "RtlQueryPerformanceCounter %I64d and rdtscp %I64d are out of order\n", counter.QuadPart, tsc1 ); + } + + ret = pRtlQueryPerformanceFrequency( &frequency ); + ok( ret, "RtlQueryPerformanceFrequency failed\n" ); + ok( frequency.QuadPart == usd->QpcFrequency, + "RtlQueryPerformanceFrequency returned %I64d, expected USD QpcFrequency %I64d\n", + frequency.QuadPart, usd->QpcFrequency ); +} + static void test_RtlQueryTimeZoneInformation(void) { RTL_DYNAMIC_TIME_ZONE_INFORMATION tzinfo, tzinfo2; @@ -266,6 +369,8 @@ START_TEST(time) pRtlQueryDynamicTimeZoneInformation = (void *)GetProcAddress(mod, "RtlQueryDynamicTimeZoneInformation"); pRtlQueryUnbiasedInterruptTime = (void *)GetProcAddress(mod, "RtlQueryUnbiasedInterruptTime"); + pRtlQueryPerformanceCounter = (void *)GetProcAddress(mod, "RtlQueryPerformanceCounter"); + pRtlQueryPerformanceFrequency = (void *)GetProcAddress(mod, "RtlQueryPerformanceFrequency"); if (pRtlTimeToTimeFields && pRtlTimeFieldsToTime) test_pRtlTimeToTimeFields(); @@ -274,4 +379,5 @@ START_TEST(time) test_NtQueryPerformanceCounter(); test_RtlQueryTimeZoneInformation(); test_user_shared_data_time(); + test_RtlQueryPerformanceCounter(); } diff --git a/include/winternl.h b/include/winternl.h index d35d509eb41..fcdedaec8aa 100644 --- a/include/winternl.h +++ b/include/winternl.h @@ -1551,6 +1551,7 @@ typedef enum _SYSTEM_INFORMATION_CLASS { SystemFileCacheInformationEx = 81, SystemDynamicTimeZoneInformation = 102, SystemLogicalProcessorInformationEx = 107, + SystemHypervisorSharedPageInformation = 197, SystemInformationClassMax } SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS; -- 2.30.2

3 3

[PATCH v3 1/3] user32: Move ToUnicodeEx from wineandroid.drv to user32.
by Rémi Bernon 29 Apr '21

29 Apr '21

As a fallback implementation, using English keyboard layout. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- v3: Call driver first and return early if it implements the call. dlls/user32/driver.c | 2 +- dlls/user32/input.c | 80 ++++++++++++++++++- dlls/wineandroid.drv/keyboard.c | 94 ----------------------- dlls/wineandroid.drv/wineandroid.drv.spec | 1 - 4 files changed, 77 insertions(+), 100 deletions(-) diff --git a/dlls/user32/driver.c b/dlls/user32/driver.c index 7ac77141696..e5855e1c51b 100644 --- a/dlls/user32/driver.c +++ b/dlls/user32/driver.c @@ -286,7 +286,7 @@ static BOOL CDECL nulldrv_RegisterHotKey( HWND hwnd, UINT modifiers, UINT vk ) static INT CDECL nulldrv_ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, LPWSTR str, int size, UINT flags, HKL layout ) { - return 0; + return -2; /* use default implementation */ } static BOOL CDECL nulldrv_UnloadKeyboardLayout( HKL layout ) diff --git a/dlls/user32/input.c b/dlls/user32/input.c index 805bfe3e9de..24942f72aa1 100644 --- a/dlls/user32/input.c +++ b/dlls/user32/input.c @@ -877,11 +877,83 @@ INT WINAPI ToUnicode(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, /**************************************************************************** * ToUnicodeEx (USER32.@) */ -INT WINAPI ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, - LPWSTR lpwStr, int size, UINT flags, HKL hkl) +INT WINAPI ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, + WCHAR *str, int size, UINT flags, HKL layout ) { - if (!lpKeyState) return 0; - return USER_Driver->pToUnicodeEx(virtKey, scanCode, lpKeyState, lpwStr, size, flags, hkl); + BOOL shift, ctrl, numlock; + WCHAR buffer[2]; + INT len; + + TRACE_(keyboard)( "virt %u, scan %u, state %p, str %p, size %d, flags %x, layout %p.\n", + virt, scan, state, str, size, flags, layout ); + + if (!state) return 0; + if ((len = USER_Driver->pToUnicodeEx( virt, scan, state, str, size, flags, layout )) >= -1) return len; + + shift = state[VK_SHIFT] & 0x80; + ctrl = state[VK_CONTROL] & 0x80; + numlock = state[VK_NUMLOCK] & 0x01; + + /* FIXME: English keyboard layout specific */ + + if (scan & 0x8000) buffer[0] = 0; /* key up */ + else if (!ctrl) + { + switch (virt) + { + case VK_BACK: buffer[0] = '\b'; break; + case VK_OEM_1: buffer[0] = shift ? ':' : ';'; break; + case VK_OEM_2: buffer[0] = shift ? '?' : '/'; break; + case VK_OEM_3: buffer[0] = shift ? '~' : '`'; break; + case VK_OEM_4: buffer[0] = shift ? '{' : '['; break; + case VK_OEM_5: buffer[0] = shift ? '|' : '\\'; break; + case VK_OEM_6: buffer[0] = shift ? '}' : ']'; break; + case VK_OEM_7: buffer[0] = shift ? '"' : '\''; break; + case VK_OEM_COMMA: buffer[0] = shift ? '<' : ','; break; + case VK_OEM_MINUS: buffer[0] = shift ? '_' : '-'; break; + case VK_OEM_PERIOD: buffer[0] = shift ? '>' : '.'; break; + case VK_OEM_PLUS: buffer[0] = shift ? '+' : '='; break; + case VK_RETURN: buffer[0] = '\r'; break; + case VK_SPACE: buffer[0] = ' '; break; + case VK_TAB: buffer[0] = '\t'; break; + case VK_MULTIPLY: buffer[0] = '*'; break; + case VK_ADD: buffer[0] = '+'; break; + case VK_SUBTRACT: buffer[0] = '-'; break; + case VK_DIVIDE: buffer[0] = '/'; break; + default: + if (virt >= '0' && virt <= '9') + buffer[0] = shift ? ")!@#$%^&*("[virt - '0'] : virt; + else if (virt >= 'A' && virt <= 'Z') + buffer[0] = shift || (state[VK_CAPITAL] & 0x01) ? virt : virt + 'a' - 'A'; + else if (virt >= VK_NUMPAD0 && virt <= VK_NUMPAD9 && numlock && !shift) + buffer[0] = '0' + virt - VK_NUMPAD0; + else if (virt == VK_DECIMAL && numlock && !shift) + buffer[0] = '.'; + else + buffer[0] = 0; + break; + } + } + else /* Control codes */ + { + switch (virt) + { + case VK_OEM_4: buffer[0] = 0x1b; break; + case VK_OEM_5: buffer[0] = 0x1c; break; + case VK_OEM_6: buffer[0] = 0x1d; break; + case VK_SUBTRACT: buffer[0] = 0x1e; break; + default: + if (virt >= 'A' && virt <= 'Z') buffer[0] = virt - 'A' + 1; + else buffer[0] = 0; + break; + } + } + buffer[1] = 0; + len = wcslen( buffer ); + lstrcpynW( str, buffer, size ); + + TRACE_(keyboard)( "ret %d, str %s.\n", len, debugstr_w(str) ); + return len; } /**************************************************************************** diff --git a/dlls/wineandroid.drv/keyboard.c b/dlls/wineandroid.drv/keyboard.c index 0a6ede0ec5f..04565c3fad8 100644 --- a/dlls/wineandroid.drv/keyboard.c +++ b/dlls/wineandroid.drv/keyboard.c @@ -750,100 +750,6 @@ jboolean keyboard_event( JNIEnv *env, jobject obj, jint win, jint action, jint k } -/*********************************************************************** - * ANDROID_ToUnicodeEx - */ -INT CDECL ANDROID_ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, - LPWSTR buf, int size, UINT flags, HKL hkl ) -{ - WCHAR buffer[2]; - BOOL shift = state[VK_SHIFT] & 0x80; - BOOL ctrl = state[VK_CONTROL] & 0x80; - BOOL numlock = state[VK_NUMLOCK] & 0x01; - - buffer[0] = buffer[1] = 0; - - if (scan & 0x8000) return 0; /* key up */ - - /* FIXME: hardcoded layout */ - - if (!ctrl) - { - switch (virt) - { - case VK_BACK: buffer[0] = '\b'; break; - case VK_OEM_1: buffer[0] = shift ? ':' : ';'; break; - case VK_OEM_2: buffer[0] = shift ? '?' : '/'; break; - case VK_OEM_3: buffer[0] = shift ? '~' : '`'; break; - case VK_OEM_4: buffer[0] = shift ? '{' : '['; break; - case VK_OEM_5: buffer[0] = shift ? '|' : '\\'; break; - case VK_OEM_6: buffer[0] = shift ? '}' : ']'; break; - case VK_OEM_7: buffer[0] = shift ? '"' : '\''; break; - case VK_OEM_COMMA: buffer[0] = shift ? '<' : ','; break; - case VK_OEM_MINUS: buffer[0] = shift ? '_' : '-'; break; - case VK_OEM_PERIOD: buffer[0] = shift ? '>' : '.'; break; - case VK_OEM_PLUS: buffer[0] = shift ? '+' : '='; break; - case VK_RETURN: buffer[0] = '\r'; break; - case VK_SPACE: buffer[0] = ' '; break; - case VK_TAB: buffer[0] = '\t'; break; - case VK_MULTIPLY: buffer[0] = '*'; break; - case VK_ADD: buffer[0] = '+'; break; - case VK_SUBTRACT: buffer[0] = '-'; break; - case VK_DIVIDE: buffer[0] = '/'; break; - default: - if (virt >= '0' && virt <= '9') - { - buffer[0] = shift ? ")!@#$%^&*("[virt - '0'] : virt; - break; - } - if (virt >= 'A' && virt <= 'Z') - { - buffer[0] = shift || (state[VK_CAPITAL] & 0x01) ? virt : virt + 'a' - 'A'; - break; - } - if (virt >= VK_NUMPAD0 && virt <= VK_NUMPAD9 && numlock && !shift) - { - buffer[0] = '0' + virt - VK_NUMPAD0; - break; - } - if (virt == VK_DECIMAL && numlock && !shift) - { - buffer[0] = '.'; - break; - } - break; - } - } - else /* Control codes */ - { - if (virt >= 'A' && virt <= 'Z') - buffer[0] = virt - 'A' + 1; - else - { - switch (virt) - { - case VK_OEM_4: - buffer[0] = 0x1b; - break; - case VK_OEM_5: - buffer[0] = 0x1c; - break; - case VK_OEM_6: - buffer[0] = 0x1d; - break; - case VK_SUBTRACT: - buffer[0] = 0x1e; - break; - } - } - } - - lstrcpynW( buf, buffer, size ); - TRACE( "returning %d / %s\n", strlenW( buffer ), debugstr_wn(buf, strlenW( buffer ))); - return strlenW( buffer ); -} - - /*********************************************************************** * ANDROID_GetKeyNameText */ diff --git a/dlls/wineandroid.drv/wineandroid.drv.spec b/dlls/wineandroid.drv/wineandroid.drv.spec index 00de23de27e..6f27c1586b3 100644 --- a/dlls/wineandroid.drv/wineandroid.drv.spec +++ b/dlls/wineandroid.drv/wineandroid.drv.spec @@ -7,7 +7,6 @@ @ cdecl GetKeyNameText(long ptr long) ANDROID_GetKeyNameText @ cdecl GetKeyboardLayout(long) ANDROID_GetKeyboardLayout @ cdecl MapVirtualKeyEx(long long long) ANDROID_MapVirtualKeyEx -@ cdecl ToUnicodeEx(long long ptr ptr long long long) ANDROID_ToUnicodeEx @ cdecl VkKeyScanEx(long long) ANDROID_VkKeyScanEx @ cdecl SetCursor(long) ANDROID_SetCursor @ cdecl ChangeDisplaySettingsEx(ptr ptr long long long) ANDROID_ChangeDisplaySettingsEx -- 2.31.0

2 4

[tools] winetest/build-patterns: Identify patterns with new and possibly fixed failures.
by Francois Gouget 29 Apr '21

29 Apr '21

Show the patterns with new failures first, then those that always failed, and finally those that do not have any recent failure and thus may be fixed. This should help catch new failures while they are fresh. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- winetest/build-patterns | 113 ++++++++++++++++++++++++++++++++++------ winetest/winetest.conf | 3 ++ 2 files changed, 100 insertions(+), 16 deletions(-) diff --git a/winetest/build-patterns b/winetest/build-patterns index e87fabc2f..32bae6b31 100755 --- a/winetest/build-patterns +++ b/winetest/build-patterns @@ -31,7 +31,7 @@ sub BEGIN } unshift @INC, $1 if ($0 =~ m=^(/.*)/[^/]+$=); } -use vars qw/$workdir $gitdir/; +use vars qw/$workdir $gitdir $patternbuilds/; require "winetest.conf"; my $name0=$0; @@ -262,9 +262,19 @@ my %reports; # should be included in that test's failure pattern. # # - failtype -# The type of the most recent failure (see fail_type()). +# The type of the most recent failure (see fail_type(), last). # In particular this distinguishes random failures from non-random ones. # +# - first +# The @sortedbuilds index of the oldest build with a failure matching +# failtype. So if failtype is 'random' this ignores any 'missing dll' +# failures that may have occurred before. +# scalar(@sortedbuilds) if there is no failure. +# +# - last +# The @sortedbuilds index of the most recent build with a failure. +# -1 if there is none. +# # - status # A hashtable of test results indexed by the build name. my %tests; @@ -388,11 +398,16 @@ foreach my $testname (keys %tests) next if (!$testreport); # Record information about the failures for this report: + # - The index of the first (oldest) and last (most recent) failures. + # Initialized for easy min / max calculations. + $testreport->{first} = @sortedbuilds; + $testreport->{last} = -1; # - Type of failure: random or not (missing dll, etc.) $testreport->{failtype} = ""; - foreach my $build (@sortedbuilds) + for my $i (0..@sortedbuilds-1) { + my $build = $sortedbuilds[$i]; my $status = $testreport->{status}->{$build->{name}}; if (!defined $status) { @@ -419,7 +434,13 @@ foreach my $testname (keys %tests) # missing dll to the test running and crashing. # Either way the relevant round of failures starts now. $testreport->{failed} = 1; - last; + $testreport->{first} = $i; + $testreport->{last} = $i; + $testreport->{failtype} = $failtype; + } + else + { + $testreport->{last} = $i; } } } @@ -525,8 +546,9 @@ sub get_status_html($$) sub write_patterns_list($$$$) { - my ($html, $pagereports, $mainpage, $testnames) = @_; + my ($html, $pagereports, $mainpage, $list) = @_; + my $testnames = $list->{testnames}; for my $i (0..@$testnames-1) { my $testname = $testnames->[$i]; @@ -537,9 +559,9 @@ sub write_patterns_list($$$$) print $html " <small>(<a href='$mainpage#$testname'>see all results</a></small>)" if ($mainpage); print $html "<div class='ralign'>"; - my $href = $i ? $testnames->[$i-1] : ""; - print $html "<a href='#$href'>↑</a>"; - $href = $i+1 < @$testnames ? $testnames->[$i+1] : undef; + my $href = $i ? $testnames->[$i-1] : $list->{prevunit}; + print $html "<a href='#$href'>↑</a>" if (defined $href); + $href = $i+1 < @$testnames ? $testnames->[$i+1] : $list->{nextunit}; print $html "<a href='#$href'>↓</a>" if (defined $href); print $html "</div></div>\n"; @@ -669,18 +691,37 @@ sub write_patterns_page($$$) <div class="main"> EOF - # Build a list of test units that will appear on this page so we can - # link them to each other. - my $testnames = []; + # Show the test units with recent failures first. + # Also use these lists to link the test units to each other. + my %lists = ( + recent => {title => "Recent failures", + desc => "have recent failures (that is failures that did not happen for the $patternbuilds oldest builds).", + testnames => []}, + regular => {title => "Regular failures", + desc => "had failures.", + testnames => []}, + old => {title => "Old failures", + desc => "had no failure in the most recent $patternbuilds builds. Fixed or just rare failures?", + testnames => []}, + ); foreach my $testname (sort keys %tests) { my $test = $tests{$testname}; - my $addtest; + + my $first = @sortedbuilds; + my $last = -1; foreach my $reportdir (keys %$pagereports) { my $testreport = $test->{testreports}->{$reportdir}; next if (!$testreport->{failed}); - $addtest = 1; + + $first = $testreport->{first} if ($testreport->{first} < $first); + # For non-random failures we only care about the transition to + # the failure state, which is recorded in 'first'. + my $replast = $testreport->{failtype} eq "random" ? $testreport->{last} : + $testreport->{first} == @sortedbuilds ? -1 : + $testreport->{first}; + $last = $replast if ($replast > $last); foreach my $status (values %{$testreport->{status}}) { @@ -689,12 +730,52 @@ EOF $test->{colors}->{$status} = undef; } } - push @$testnames, $testname if ($addtest); + next if ($last == -1); # no report had a pattern of interest + + my $listid = ($last < @sortedbuilds - $patternbuilds) ? "old" : + ($first > $patternbuilds) ? "recent" : + "regular"; + push @{$lists{$listid}->{testnames}}, $testname; + } + + # Generate the lists index (and up test unit links) + print $html "<h1>$title</h1>\n"; + print $html "<ul>\n"; + my @listids = ("recent", "regular", "old"); + my $prevunit = ""; + foreach my $listid (@listids) + { + my $list = $lists{$listid}; + my $count = @{$list->{testnames}}; + next if (!$count); + print $html "<li><a href='#$listid'>$count test units</a> $list->{desc}</li>\n"; + $list->{prevunit} = $prevunit; + $prevunit = $list->{testnames}->[-1]; + } + print $html "</ul>\n"; + + # Link the last test unit of each list to the first one of the next list + my $nextunit; + foreach my $listid (reverse @listids) + { + my $list = $lists{$listid}; + my $count = @{$list->{testnames}}; + next if (!$count); + $list->{nextunit} = $nextunit; + $nextunit = $list->{testnames}->[0]; } + # Generate the test unit lists themselves my $mainpage = $subpage ? "patterns.html" : ""; - print $html "<h2>$title</h2>\n"; - write_patterns_list($html, $pagereports, $mainpage, $testnames); + foreach my $listid (@listids) + { + my $list = $lists{$listid}; + my $count = @{$list->{testnames}}; + next if (!$count); + print $html "<h2 id='$listid'>$list->{title}</h2>\n"; + write_patterns_list($html, $pagereports, $mainpage, $list); + } + print $html "</div></body></html>\n"; close($html); diff --git a/winetest/winetest.conf b/winetest/winetest.conf index 84824a2b3..f193f8eed 100644 --- a/winetest/winetest.conf +++ b/winetest/winetest.conf @@ -24,4 +24,7 @@ $maxunitsize = 32 * 1024; # This should be in line with programs\winetest\send.c $maxfilesize = 1.5 * 1024 * 1024; +# The number of builds after which a failure is considered old / new +$patternbuilds = 10; + 1; # keep require happy -- 2.20.1

1 0

[PATCH] ws2_32/sock: WSARecv/WSASend checks async pendings of the socket.
by dongwan_kim＠tmax.co.kr 29 Apr '21

29 Apr '21

Hi, My name is Dongwan Kim. I found the misbehavior of WSARecv/WSASend when they are called multiple times for overlapped I/O to the same socket . Specifically, the problem occurs if WSARecv is called when overlapped I/O gets ready. WSARecv intercepts the message from the socket. for example, Alice Bob WSARecv( SOCKET_A, buffer1 ) ; <----- X ... <----- Y WSARecv(SOCKET_A, buffer2) ; Bob sent messages( X , Y ) to Alice. Alice should get X to buffer1, Y to buffer 2 respectively. But, In the current version of wine , Alice could get Y to buffer 1 because WSARecv always tries to get message from the socket without checking if there are waiting syncs. I attached my solution and the programs for testing. The test server program receives messages from client with WSARecv. you can run it as : test_server.exe 9088 9088 is port number which is hard-coded in test client program... The test client program sends fragments of a file to server. you can run it as : test_client.exe localhost [file_to_send] I tested with a 96MB file. The programs are not clean... If you need, I can send the source code. Thanks. Best Regards.

1 0

[PATCH 1/7] d3d8/tests: Port test_sample_mask() from d3d9.
by Zebediah Figura 28 Apr '21

28 Apr '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/d3d8/tests/visual.c | 88 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/dlls/d3d8/tests/visual.c b/dlls/d3d8/tests/visual.c index fc8a05a3c40..f25549388d0 100644 --- a/dlls/d3d8/tests/visual.c +++ b/dlls/d3d8/tests/visual.c @@ -11070,6 +11070,93 @@ static void test_desktop_window(void) IDirect3D8_Release(d3d); } +static void test_sample_mask(void) +{ + IDirect3DSurface8 *rt, *ms_rt; + struct surface_readback rb; + IDirect3DDevice8 *device; + IDirect3D8 *d3d; + ULONG refcount; + DWORD colour; + HWND window; + HRESULT hr; + + static const struct + { + struct vec3 position; + DWORD diffuse; + } + quad[] = + { + {{-1.0f, -1.0f, 0.1f}, 0xffffffff}, + {{-1.0f, 1.0f, 0.1f}, 0xffffffff}, + {{ 1.0f, -1.0f, 0.1f}, 0xffffffff}, + {{ 1.0f, 1.0f, 0.1f}, 0xffffffff}, + }; + + window = create_window(); + d3d = Direct3DCreate8(D3D_SDK_VERSION); + ok(!!d3d, "Failed to create a D3D object.\n"); + + if (FAILED(IDirect3D8_CheckDeviceMultiSampleType(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, + D3DFMT_A8R8G8B8, TRUE, D3DMULTISAMPLE_2_SAMPLES))) + { + skip("Multisampling not supported for D3DFMT_A8R8G8B8.\n"); + IDirect3D8_Release(d3d); + DestroyWindow(window); + return; + } + + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a 3D device.\n"); + IDirect3D8_Release(d3d); + DestroyWindow(window); + return; + } + + hr = IDirect3DDevice8_CreateRenderTarget(device, 128, 128, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, FALSE, &rt); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_CreateRenderTarget(device, 128, 128, + D3DFMT_A8R8G8B8, D3DMULTISAMPLE_2_SAMPLES, FALSE, &ms_rt); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_SetRenderTarget(device, ms_rt, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_BeginScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_LIGHTING, FALSE); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_MULTISAMPLEMASK, 0x5); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0f, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_SetVertexShader(device, D3DFVF_XYZ | D3DFVF_DIFFUSE); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice8_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0])); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice8_CopyRects(device, ms_rt, NULL, 0, rt, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + get_rt_readback(rt, &rb); + colour = get_readback_color(&rb, 64, 64); + ok(color_match(colour, 0xffff8080, 1), "Got unexpected colour %08x.\n", colour); + release_surface_readback(&rb); + + hr = IDirect3DDevice8_EndScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + IDirect3DSurface8_Release(ms_rt); + IDirect3DSurface8_Release(rt); + refcount = IDirect3DDevice8_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + IDirect3D8_Release(d3d); + DestroyWindow(window); +} + START_TEST(visual) { D3DADAPTER_IDENTIFIER8 identifier; @@ -11147,4 +11234,5 @@ START_TEST(visual) test_sysmem_draw(); test_alphatest(); test_desktop_window(); + test_sample_mask(); } -- 2.30.2

2 9

[PATCH 1/5] ws2_32/tests: Move address lookup tests to protocol.c.
by Zebediah Figura 28 Apr '21

28 Apr '21

sock.c is huge. This doesn't bother some people, but I find that it can be harder to navigate and slower to compile. Splitting it is tricky, but I think there's a pretty natural divide between functions that operate on sockets (e.g. bind, listen, recv, getsockname) and functions that don't (e.g. get*info, inet_*, get*by*, WSC*). Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ws2_32/tests/protocol.c | 809 ++++++++++++++++++++++++++++++++++- dlls/ws2_32/tests/sock.c | 805 ---------------------------------- 2 files changed, 808 insertions(+), 806 deletions(-) diff --git a/dlls/ws2_32/tests/protocol.c b/dlls/ws2_32/tests/protocol.c index d6e454a5fbd..21b26d12aec 100644 --- a/dlls/ws2_32/tests/protocol.c +++ b/dlls/ws2_32/tests/protocol.c @@ -23,9 +23,18 @@ #include <windef.h> #include <winbase.h> #include <winsock2.h> +#include <ws2tcpip.h> #include "wine/test.h" +static void (WINAPI *pFreeAddrInfoExW)(ADDRINFOEXW *ai); +static int (WINAPI *pGetAddrInfoExW)(const WCHAR *name, const WCHAR *servname, DWORD namespace, + GUID *namespace_id, const ADDRINFOEXW *hints, ADDRINFOEXW **result, + struct timeval *timeout, OVERLAPPED *overlapped, + LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine, HANDLE *handle); +static int (WINAPI *pGetAddrInfoExOverlappedResult)(OVERLAPPED *overlapped); +static const char *(WINAPI *p_inet_ntop)(int family, void *addr, char *string, ULONG size); + /* TCP and UDP over IP fixed set of service flags */ #define TCPIP_SERVICE_FLAGS (XP1_GUARANTEED_DELIVERY \ | XP1_GUARANTEED_ORDER \ @@ -290,15 +299,813 @@ static void test_getprotobynumber(void) } } +/* Tests used in both getaddrinfo and GetAddrInfoW */ +static const struct addr_hint_tests +{ + int family, socktype, protocol; + DWORD error; +} +hinttests[] = +{ + {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0}, + {AF_UNSPEC, SOCK_STREAM, IPPROTO_UDP, 0}, + {AF_UNSPEC, SOCK_STREAM, IPPROTO_IPV6,0}, + {AF_UNSPEC, SOCK_DGRAM, IPPROTO_TCP, 0}, + {AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, 0}, + {AF_UNSPEC, SOCK_DGRAM, IPPROTO_IPV6,0}, + {AF_INET, SOCK_STREAM, IPPROTO_TCP, 0}, + {AF_INET, SOCK_STREAM, IPPROTO_UDP, 0}, + {AF_INET, SOCK_STREAM, IPPROTO_IPV6,0}, + {AF_INET, SOCK_DGRAM, IPPROTO_TCP, 0}, + {AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0}, + {AF_INET, SOCK_DGRAM, IPPROTO_IPV6,0}, + {AF_UNSPEC, 0, IPPROTO_TCP, 0}, + {AF_UNSPEC, 0, IPPROTO_UDP, 0}, + {AF_UNSPEC, 0, IPPROTO_IPV6,0}, + {AF_UNSPEC, SOCK_STREAM, 0, 0}, + {AF_UNSPEC, SOCK_DGRAM, 0, 0}, + {AF_INET, 0, IPPROTO_TCP, 0}, + {AF_INET, 0, IPPROTO_UDP, 0}, + {AF_INET, 0, IPPROTO_IPV6,0}, + {AF_INET, SOCK_STREAM, 0, 0}, + {AF_INET, SOCK_DGRAM, 0, 0}, + {AF_UNSPEC, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT}, + {AF_UNSPEC, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT}, + {AF_UNSPEC, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT}, + {AF_INET, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT}, + {AF_INET, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT}, + {AF_INET, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT}, + {AF_UNSPEC, SOCK_STREAM, 999, 0}, + {AF_UNSPEC, SOCK_STREAM, 999, 0}, + {AF_INET, SOCK_DGRAM, 999, 0}, + {AF_INET, SOCK_DGRAM, 999, 0}, +}; + +static void compare_addrinfow(ADDRINFOW *a, ADDRINFOW *b) +{ + for (; a && b; a = a->ai_next, b = b->ai_next) + { + ok(a->ai_flags == b->ai_flags, + "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags); + ok(a->ai_family == b->ai_family, + "Wrong family %d != %d\n", a->ai_family, b->ai_family); + ok(a->ai_socktype == b->ai_socktype, + "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype); + ok(a->ai_protocol == b->ai_protocol, + "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol); + ok(a->ai_addrlen == b->ai_addrlen, + "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen); + ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)), + "Wrong address data\n"); + if (a->ai_canonname && b->ai_canonname) + { + ok(!lstrcmpW(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n", + wine_dbgstr_w(a->ai_canonname), wine_dbgstr_w(b->ai_canonname)); + } + else + ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n", + a->ai_canonname, b->ai_canonname); + } + ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b); +} + +static void test_GetAddrInfoW(void) +{ + static const WCHAR port[] = {'8','0',0}; + static const WCHAR empty[] = {0}; + static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0}; + static const WCHAR nxdomain[] = + {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0}; + static const WCHAR zero[] = {'0',0}; + int i, ret; + ADDRINFOW *result, *result2, *p, hint; + WCHAR name[256]; + DWORD size = ARRAY_SIZE(name); + /* te su to.winehq.org written in katakana */ + static const WCHAR idn_domain[] = + {0x30C6,0x30B9,0x30C8,'.','w','i','n','e','h','q','.','o','r','g',0}; + static const WCHAR idn_punycode[] = + {'x','n','-','-','z','c','k','z','a','h','.','w','i','n','e','h','q','.','o','r','g',0}; + + memset(&hint, 0, sizeof(ADDRINFOW)); + name[0] = 0; + GetComputerNameExW( ComputerNamePhysicalDnsHostname, name, &size ); + + result = (ADDRINFOW *)0xdeadbeef; + WSASetLastError(0xdeadbeef); + ret = GetAddrInfoW(NULL, NULL, NULL, &result); + ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); + ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); + ok(result == NULL, "got %p\n", result); + + result = NULL; + WSASetLastError(0xdeadbeef); + ret = GetAddrInfoW(empty, NULL, NULL, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); + FreeAddrInfoW(result); + + result = NULL; + ret = GetAddrInfoW(NULL, zero, NULL, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + + result2 = NULL; + ret = GetAddrInfoW(NULL, empty, NULL, &result2); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(result2 != NULL, "GetAddrInfoW failed\n"); + compare_addrinfow(result, result2); + FreeAddrInfoW(result); + FreeAddrInfoW(result2); + + result = NULL; + ret = GetAddrInfoW(empty, zero, NULL, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + + result2 = NULL; + ret = GetAddrInfoW(empty, empty, NULL, &result2); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(result2 != NULL, "GetAddrInfoW failed\n"); + compare_addrinfow(result, result2); + FreeAddrInfoW(result); + FreeAddrInfoW(result2); + + result = NULL; + ret = GetAddrInfoW(localhost, NULL, NULL, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + FreeAddrInfoW(result); + + result = NULL; + ret = GetAddrInfoW(localhost, empty, NULL, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + FreeAddrInfoW(result); + + result = NULL; + ret = GetAddrInfoW(localhost, zero, NULL, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + FreeAddrInfoW(result); + + result = NULL; + ret = GetAddrInfoW(localhost, port, NULL, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + FreeAddrInfoW(result); + + result = NULL; + ret = GetAddrInfoW(localhost, NULL, &hint, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + FreeAddrInfoW(result); + + result = NULL; + SetLastError(0xdeadbeef); + ret = GetAddrInfoW(localhost, port, &hint, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); + FreeAddrInfoW(result); + + /* try to get information from the computer name, result is the same + * as if requesting with an empty host name. */ + ret = GetAddrInfoW(name, NULL, NULL, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + + ret = GetAddrInfoW(empty, NULL, NULL, &result2); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + compare_addrinfow(result, result2); + FreeAddrInfoW(result); + FreeAddrInfoW(result2); + + ret = GetAddrInfoW(name, empty, NULL, &result); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + + ret = GetAddrInfoW(empty, empty, NULL, &result2); + ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + compare_addrinfow(result, result2); + FreeAddrInfoW(result); + FreeAddrInfoW(result2); + + result = (ADDRINFOW *)0xdeadbeef; + WSASetLastError(0xdeadbeef); + ret = GetAddrInfoW(NULL, NULL, NULL, &result); + if (ret == 0) + { + skip("nxdomain returned success. Broken ISP redirects?\n"); + return; + } + ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); + ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); + ok(result == NULL, "got %p\n", result); + + result = (ADDRINFOW *)0xdeadbeef; + WSASetLastError(0xdeadbeef); + ret = GetAddrInfoW(nxdomain, NULL, NULL, &result); + if (ret == 0) + { + skip("nxdomain returned success. Broken ISP redirects?\n"); + return; + } + ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); + ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); + ok(result == NULL, "got %p\n", result); + + for (i = 0; i < ARRAY_SIZE(hinttests); i++) + { + hint.ai_family = hinttests[i].family; + hint.ai_socktype = hinttests[i].socktype; + hint.ai_protocol = hinttests[i].protocol; + + result = NULL; + SetLastError(0xdeadbeef); + ret = GetAddrInfoW(localhost, NULL, &hint, &result); + todo_wine_if (hinttests[i].error) ok(ret == hinttests[i].error, "test %d: wrong ret %d\n", i, ret); + if (!ret) + { + for (p = result; p; p = p->ai_next) + { + /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */ + if (hinttests[i].family == AF_UNSPEC) + ok(p->ai_family == AF_INET || p->ai_family == AF_INET6, + "test %d: expected AF_INET or AF_INET6, got %d\n", + i, p->ai_family); + else + ok(p->ai_family == hinttests[i].family, + "test %d: expected family %d, got %d\n", + i, hinttests[i].family, p->ai_family); + + ok(p->ai_socktype == hinttests[i].socktype, + "test %d: expected type %d, got %d\n", + i, hinttests[i].socktype, p->ai_socktype); + ok(p->ai_protocol == hinttests[i].protocol, + "test %d: expected protocol %d, got %d\n", + i, hinttests[i].protocol, p->ai_protocol); + } + FreeAddrInfoW(result); + } + else + { + ok(WSAGetLastError() == hinttests[i].error, "test %d: wrong error %d\n", i, WSAGetLastError()); + } + } + + /* Test IDN resolution (Internationalized Domain Names) present since Windows 8 */ + result = NULL; + ret = GetAddrInfoW(idn_punycode, NULL, NULL, &result); + ok(!ret, "got %d expected success\n", ret); + ok(result != NULL, "got %p\n", result); + FreeAddrInfoW(result); + + hint.ai_family = AF_INET; + hint.ai_socktype = 0; + hint.ai_protocol = 0; + hint.ai_flags = 0; + + result = NULL; + ret = GetAddrInfoW(idn_punycode, NULL, &hint, &result); + ok(!ret, "got %d expected success\n", ret); + ok(result != NULL, "got %p\n", result); + + result2 = NULL; + ret = GetAddrInfoW(idn_domain, NULL, NULL, &result2); + if (broken(ret == WSAHOST_NOT_FOUND)) + { + FreeAddrInfoW(result); + win_skip("IDN resolution not supported in Win <= 7\n"); + return; + } + + ok(!ret, "got %d expected success\n", ret); + ok(result2 != NULL, "got %p\n", result2); + FreeAddrInfoW(result2); + + hint.ai_family = AF_INET; + hint.ai_socktype = 0; + hint.ai_protocol = 0; + hint.ai_flags = 0; + + result2 = NULL; + ret = GetAddrInfoW(idn_domain, NULL, &hint, &result2); + ok(!ret, "got %d expected success\n", ret); + ok(result2 != NULL, "got %p\n", result2); + + /* ensure manually resolved punycode and unicode hosts result in same data */ + compare_addrinfow(result, result2); + + FreeAddrInfoW(result); + FreeAddrInfoW(result2); + + hint.ai_family = AF_INET; + hint.ai_socktype = 0; + hint.ai_protocol = 0; + hint.ai_flags = 0; + + result2 = NULL; + ret = GetAddrInfoW(idn_domain, NULL, &hint, &result2); + ok(!ret, "got %d expected success\n", ret); + ok(result2 != NULL, "got %p\n", result2); + FreeAddrInfoW(result2); + + /* Disable IDN resolution and test again*/ + hint.ai_family = AF_INET; + hint.ai_socktype = 0; + hint.ai_protocol = 0; + hint.ai_flags = AI_DISABLE_IDN_ENCODING; + + SetLastError(0xdeadbeef); + result2 = NULL; + ret = GetAddrInfoW(idn_domain, NULL, &hint, &result2); + ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); + ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); + ok(result2 == NULL, "got %p\n", result2); +} + +static struct completion_routine_test +{ + WSAOVERLAPPED *overlapped; + DWORD error; + ADDRINFOEXW **result; + HANDLE event; + DWORD called; +} completion_routine_test; + +static void CALLBACK completion_routine(DWORD error, DWORD byte_count, WSAOVERLAPPED *overlapped) +{ + struct completion_routine_test *test = &completion_routine_test; + + ok(error == test->error, "got %u\n", error); + ok(!byte_count, "got %u\n", byte_count); + ok(overlapped == test->overlapped, "got %p\n", overlapped); + ok(overlapped->Internal == test->error, "got %lu\n", overlapped->Internal); + ok(overlapped->Pointer == test->result, "got %p\n", overlapped->Pointer); + ok(overlapped->hEvent == NULL, "got %p\n", overlapped->hEvent); + + test->called++; + SetEvent(test->event); +} + +static void test_GetAddrInfoExW(void) +{ + static const WCHAR empty[] = {0}; + static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0}; + static const WCHAR winehq[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0}; + static const WCHAR nxdomain[] = {'n','x','d','o','m','a','i','n','.','w','i','n','e','h','q','.','o','r','g',0}; + ADDRINFOEXW *result; + OVERLAPPED overlapped; + HANDLE event; + int ret; + + if (!pGetAddrInfoExW || !pGetAddrInfoExOverlappedResult) + { + win_skip("GetAddrInfoExW and/or GetAddrInfoExOverlappedResult not present\n"); + return; + } + + event = WSACreateEvent(); + + result = (ADDRINFOEXW *)0xdeadbeef; + WSASetLastError(0xdeadbeef); + ret = pGetAddrInfoExW(NULL, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL); + ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); + ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); + ok(result == NULL, "got %p\n", result); + + result = NULL; + WSASetLastError(0xdeadbeef); + ret = pGetAddrInfoExW(empty, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL); + ok(!ret, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); + pFreeAddrInfoExW(result); + + result = NULL; + ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL); + ok(!ret, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); + pFreeAddrInfoExW(result); + + result = (void *)0xdeadbeef; + memset(&overlapped, 0xcc, sizeof(overlapped)); + overlapped.hEvent = event; + ResetEvent(event); + ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL); + ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); + ok(!result, "result != NULL\n"); + ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n"); + ret = pGetAddrInfoExOverlappedResult(&overlapped); + ok(!ret, "overlapped result is %d\n", ret); + pFreeAddrInfoExW(result); + + result = (void *)0xdeadbeef; + memset(&overlapped, 0xcc, sizeof(overlapped)); + ResetEvent(event); + overlapped.hEvent = event; + WSASetLastError(0xdeadbeef); + ret = pGetAddrInfoExW(winehq, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL); + ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); + ok(WSAGetLastError() == ERROR_IO_PENDING, "expected 11001, got %d\n", WSAGetLastError()); + ret = overlapped.Internal; + ok(ret == WSAEINPROGRESS || ret == ERROR_SUCCESS, "overlapped.Internal = %u\n", ret); + ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n"); + ret = pGetAddrInfoExOverlappedResult(&overlapped); + ok(!ret, "overlapped result is %d\n", ret); + ok(overlapped.hEvent == event, "hEvent changed %p\n", overlapped.hEvent); + ok(overlapped.Internal == ERROR_SUCCESS, "overlapped.Internal = %lx\n", overlapped.Internal); + ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n"); + ok(result != NULL, "result == NULL\n"); + ok(!result->ai_blob, "ai_blob != NULL\n"); + ok(!result->ai_bloblen, "ai_bloblen != 0\n"); + ok(!result->ai_provider, "ai_provider = %s\n", wine_dbgstr_guid(result->ai_provider)); + pFreeAddrInfoExW(result); + + result = (void *)0xdeadbeef; + memset(&overlapped, 0xcc, sizeof(overlapped)); + ResetEvent(event); + overlapped.hEvent = event; + ret = pGetAddrInfoExW(NULL, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL); + todo_wine + ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); + todo_wine + ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); + ok(result == NULL, "got %p\n", result); + ret = WaitForSingleObject(event, 0); + todo_wine_if(ret != WAIT_TIMEOUT) /* Remove when abowe todo_wines are fixed */ + ok(ret == WAIT_TIMEOUT, "wait failed\n"); + + /* event + completion routine */ + result = (void *)0xdeadbeef; + memset(&overlapped, 0xcc, sizeof(overlapped)); + overlapped.hEvent = event; + ResetEvent(event); + ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL); + ok(ret == WSAEINVAL, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); + + /* completion routine, existing domain */ + result = (void *)0xdeadbeef; + overlapped.hEvent = NULL; + completion_routine_test.overlapped = &overlapped; + completion_routine_test.error = ERROR_SUCCESS; + completion_routine_test.result = &result; + completion_routine_test.event = event; + completion_routine_test.called = 0; + ResetEvent(event); + ret = pGetAddrInfoExW(winehq, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL); + ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); + ok(!result, "result != NULL\n"); + ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n"); + ret = pGetAddrInfoExOverlappedResult(&overlapped); + ok(!ret, "overlapped result is %d\n", ret); + ok(overlapped.hEvent == NULL, "hEvent changed %p\n", overlapped.hEvent); + ok(overlapped.Internal == ERROR_SUCCESS, "overlapped.Internal = %lx\n", overlapped.Internal); + ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n"); + ok(completion_routine_test.called == 1, "got %u\n", completion_routine_test.called); + pFreeAddrInfoExW(result); + + /* completion routine, non-existing domain */ + result = (void *)0xdeadbeef; + completion_routine_test.overlapped = &overlapped; + completion_routine_test.error = WSAHOST_NOT_FOUND; + completion_routine_test.called = 0; + ResetEvent(event); + ret = pGetAddrInfoExW(nxdomain, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL); + ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); + ok(!result, "result != NULL\n"); + ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n"); + ret = pGetAddrInfoExOverlappedResult(&overlapped); + ok(ret == WSAHOST_NOT_FOUND, "overlapped result is %d\n", ret); + ok(overlapped.hEvent == NULL, "hEvent changed %p\n", overlapped.hEvent); + ok(overlapped.Internal == WSAHOST_NOT_FOUND, "overlapped.Internal = %lx\n", overlapped.Internal); + ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n"); + ok(completion_routine_test.called == 1, "got %u\n", completion_routine_test.called); + ok(result == NULL, "got %p\n", result); + + WSACloseEvent(event); +} + +static void verify_ipv6_addrinfo(ADDRINFOA *result, const char *expect) +{ + SOCKADDR_IN6 *sockaddr6; + char buffer[256]; + const char *ret; + + ok(result->ai_family == AF_INET6, "ai_family == %d\n", result->ai_family); + ok(result->ai_addrlen >= sizeof(struct sockaddr_in6), "ai_addrlen == %d\n", (int)result->ai_addrlen); + ok(result->ai_addr != NULL, "ai_addr == NULL\n"); + + sockaddr6 = (SOCKADDR_IN6 *)result->ai_addr; + ok(sockaddr6->sin6_family == AF_INET6, "ai_addr->sin6_family == %d\n", sockaddr6->sin6_family); + ok(sockaddr6->sin6_port == 0, "ai_addr->sin6_port == %d\n", sockaddr6->sin6_port); + + memset(buffer, 0, sizeof(buffer)); + ret = p_inet_ntop(AF_INET6, &sockaddr6->sin6_addr, buffer, sizeof(buffer)); + ok(ret != NULL, "inet_ntop failed (%d)\n", WSAGetLastError()); + ok(!strcmp(buffer, expect), "ai_addr->sin6_addr == '%s' (expected '%s')\n", buffer, expect); +} + +static void compare_addrinfo(ADDRINFO *a, ADDRINFO *b) +{ + for (; a && b ; a = a->ai_next, b = b->ai_next) + { + ok(a->ai_flags == b->ai_flags, + "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags); + ok(a->ai_family == b->ai_family, + "Wrong family %d != %d\n", a->ai_family, b->ai_family); + ok(a->ai_socktype == b->ai_socktype, + "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype); + ok(a->ai_protocol == b->ai_protocol, + "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol); + ok(a->ai_addrlen == b->ai_addrlen, + "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen); + ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)), + "Wrong address data\n"); + if (a->ai_canonname && b->ai_canonname) + { + ok(!strcmp(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n", + a->ai_canonname, b->ai_canonname); + } + else + ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n", + a->ai_canonname, b->ai_canonname); + } + ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b); +} + +static void test_getaddrinfo(void) +{ + int i, ret; + ADDRINFOA *result, *result2, *p, hint; + SOCKADDR_IN *sockaddr; + CHAR name[256], *ip; + DWORD size = sizeof(name); + + memset(&hint, 0, sizeof(ADDRINFOA)); + GetComputerNameExA( ComputerNamePhysicalDnsHostname, name, &size ); + + result = (ADDRINFOA *)0xdeadbeef; + WSASetLastError(0xdeadbeef); + ret = getaddrinfo(NULL, NULL, NULL, &result); + ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); + ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); + ok(result == NULL, "got %p\n", result); + + result = NULL; + WSASetLastError(0xdeadbeef); + ret = getaddrinfo("", NULL, NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(result != NULL, "getaddrinfo failed\n"); + ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); + freeaddrinfo(result); + + result = NULL; + ret = getaddrinfo(NULL, "0", NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(result != NULL, "getaddrinfo failed\n"); + + result2 = NULL; + ret = getaddrinfo(NULL, "", NULL, &result2); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(result2 != NULL, "getaddrinfo failed\n"); + compare_addrinfo(result, result2); + freeaddrinfo(result); + freeaddrinfo(result2); + + result = NULL; + WSASetLastError(0xdeadbeef); + ret = getaddrinfo("", "0", NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); + ok(result != NULL, "getaddrinfo failed\n"); + + result2 = NULL; + ret = getaddrinfo("", "", NULL, &result2); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(result2 != NULL, "getaddrinfo failed\n"); + compare_addrinfo(result, result2); + freeaddrinfo(result); + freeaddrinfo(result2); + + result = NULL; + ret = getaddrinfo("localhost", NULL, NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + freeaddrinfo(result); + + result = NULL; + ret = getaddrinfo("localhost", "", NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + freeaddrinfo(result); + + result = NULL; + ret = getaddrinfo("localhost", "0", NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + freeaddrinfo(result); + + result = NULL; + ret = getaddrinfo("localhost", "80", NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + freeaddrinfo(result); + + result = NULL; + ret = getaddrinfo("localhost", NULL, &hint, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + freeaddrinfo(result); + + result = NULL; + WSASetLastError(0xdeadbeef); + ret = getaddrinfo("localhost", "80", &hint, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); + freeaddrinfo(result); + + hint.ai_flags = AI_NUMERICHOST; + result = (void *)0xdeadbeef; + ret = getaddrinfo("localhost", "80", &hint, &result); + ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected WSAHOST_NOT_FOUND, got %d\n", WSAGetLastError()); + ok(!result, "result = %p\n", result); + hint.ai_flags = 0; + + /* try to get information from the computer name, result is the same + * as if requesting with an empty host name. */ + ret = getaddrinfo(name, NULL, NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + + ret = getaddrinfo("", NULL, NULL, &result2); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + compare_addrinfo(result, result2); + freeaddrinfo(result); + freeaddrinfo(result2); + + ret = getaddrinfo(name, "", NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + + ret = getaddrinfo("", "", NULL, &result2); + ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); + ok(result != NULL, "GetAddrInfoW failed\n"); + compare_addrinfo(result, result2); + freeaddrinfo(result); + freeaddrinfo(result2); + + result = (ADDRINFOA *)0xdeadbeef; + WSASetLastError(0xdeadbeef); + ret = getaddrinfo("nxdomain.codeweavers.com", NULL, NULL, &result); + if (ret == 0) + { + skip("nxdomain returned success. Broken ISP redirects?\n"); + return; + } + ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); + ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); + ok(result == NULL, "got %p\n", result); + + /* Test IPv4 address conversion */ + result = NULL; + ret = getaddrinfo("192.168.1.253", NULL, NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", ret); + ok(result->ai_family == AF_INET, "ai_family == %d\n", result->ai_family); + ok(result->ai_addrlen >= sizeof(struct sockaddr_in), "ai_addrlen == %d\n", (int)result->ai_addrlen); + ok(result->ai_addr != NULL, "ai_addr == NULL\n"); + sockaddr = (SOCKADDR_IN *)result->ai_addr; + ok(sockaddr->sin_family == AF_INET, "ai_addr->sin_family == %d\n", sockaddr->sin_family); + ok(sockaddr->sin_port == 0, "ai_addr->sin_port == %d\n", sockaddr->sin_port); + + ip = inet_ntoa(sockaddr->sin_addr); + ok(strcmp(ip, "192.168.1.253") == 0, "sockaddr->ai_addr == '%s'\n", ip); + freeaddrinfo(result); + + /* Test IPv4 address conversion with port */ + result = NULL; + hint.ai_flags = AI_NUMERICHOST; + ret = getaddrinfo("192.168.1.253:1024", NULL, &hint, &result); + hint.ai_flags = 0; + ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo returned unexpected result: %d\n", ret); + ok(result == NULL, "expected NULL, got %p\n", result); + + /* Test IPv6 address conversion */ + result = NULL; + SetLastError(0xdeadbeef); + ret = getaddrinfo("2a00:2039:dead:beef:cafe::6666", NULL, NULL, &result); + + if (result != NULL) + { + ok(!ret, "getaddrinfo failed with %d\n", ret); + verify_ipv6_addrinfo(result, "2a00:2039:dead:beef:cafe::6666"); + freeaddrinfo(result); + + /* Test IPv6 address conversion with brackets */ + result = NULL; + ret = getaddrinfo("[beef::cafe]", NULL, NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", ret); + verify_ipv6_addrinfo(result, "beef::cafe"); + freeaddrinfo(result); + + /* Test IPv6 address conversion with brackets and hints */ + memset(&hint, 0, sizeof(ADDRINFOA)); + hint.ai_flags = AI_NUMERICHOST; + hint.ai_family = AF_INET6; + result = NULL; + ret = getaddrinfo("[beef::cafe]", NULL, &hint, &result); + ok(!ret, "getaddrinfo failed with %d\n", ret); + verify_ipv6_addrinfo(result, "beef::cafe"); + freeaddrinfo(result); + + memset(&hint, 0, sizeof(ADDRINFOA)); + hint.ai_flags = AI_NUMERICHOST; + hint.ai_family = AF_INET; + result = NULL; + ret = getaddrinfo("[beef::cafe]", NULL, &hint, &result); + ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret); + + /* Test IPv6 address conversion with brackets and port */ + result = NULL; + ret = getaddrinfo("[beef::cafe]:10239", NULL, NULL, &result); + ok(!ret, "getaddrinfo failed with %d\n", ret); + verify_ipv6_addrinfo(result, "beef::cafe"); + freeaddrinfo(result); + + /* Test IPv6 address conversion with unmatched brackets */ + result = NULL; + hint.ai_flags = AI_NUMERICHOST; + ret = getaddrinfo("[beef::cafe", NULL, &hint, &result); + ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret); + + ret = getaddrinfo("beef::cafe]", NULL, &hint, &result); + ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret); + } + else + { + ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret); + win_skip("getaddrinfo does not support IPV6\n"); + } + + hint.ai_flags = 0; + + for (i = 0; i < ARRAY_SIZE(hinttests); i++) + { + hint.ai_family = hinttests[i].family; + hint.ai_socktype = hinttests[i].socktype; + hint.ai_protocol = hinttests[i].protocol; + + result = NULL; + SetLastError(0xdeadbeef); + ret = getaddrinfo("localhost", NULL, &hint, &result); + todo_wine_if (hinttests[i].error) ok(ret == hinttests[i].error, "test %d: wrong ret %d\n", i, ret); + if (!ret) + { + for (p = result; p; p = p->ai_next) + { + /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */ + if (hinttests[i].family == AF_UNSPEC) + ok(p->ai_family == AF_INET || p->ai_family == AF_INET6, + "test %d: expected AF_INET or AF_INET6, got %d\n", + i, p->ai_family); + else + ok(p->ai_family == hinttests[i].family, + "test %d: expected family %d, got %d\n", + i, hinttests[i].family, p->ai_family); + + ok(p->ai_socktype == hinttests[i].socktype, + "test %d: expected type %d, got %d\n", + i, hinttests[i].socktype, p->ai_socktype); + ok(p->ai_protocol == hinttests[i].protocol, + "test %d: expected protocol %d, got %d\n", + i, hinttests[i].protocol, p->ai_protocol); + } + freeaddrinfo(result); + } + else + { + ok(WSAGetLastError() == hinttests[i].error, "test %d: wrong error %d\n", i, WSAGetLastError()); + } + } + + memset(&hint, 0, sizeof(hint)); + ret = getaddrinfo(NULL, "nonexistentservice", &hint, &result); + ok(ret == WSATYPE_NOT_FOUND, "got %d\n", ret); +} + START_TEST( protocol ) { WSADATA data; WORD version = MAKEWORD( 2, 2 ); - + + pFreeAddrInfoExW = (void *)GetProcAddress(GetModuleHandleA("ws2_32"), "FreeAddrInfoExW"); + pGetAddrInfoExOverlappedResult = (void *)GetProcAddress(GetModuleHandleA("ws2_32"), "GetAddrInfoExOverlappedResult"); + pGetAddrInfoExW = (void *)GetProcAddress(GetModuleHandleA("ws2_32"), "GetAddrInfoExW"); + p_inet_ntop = (void *)GetProcAddress(GetModuleHandleA("ws2_32"), "inet_ntop"); + if (WSAStartup( version, &data )) return; test_WSAEnumProtocolsA(); test_WSAEnumProtocolsW(); test_getprotobyname(); test_getprotobynumber(); + + test_GetAddrInfoW(); + test_GetAddrInfoExW(); + test_getaddrinfo(); } diff --git a/dlls/ws2_32/tests/sock.c b/dlls/ws2_32/tests/sock.c index 61af5b0183a..877c21377aa 100644 --- a/dlls/ws2_32/tests/sock.c +++ b/dlls/ws2_32/tests/sock.c @@ -65,12 +65,6 @@ k.keepaliveinterval = interval; /* Function pointers */ -static void (WINAPI *pFreeAddrInfoExW)(ADDRINFOEXW *ai); -static int (WINAPI *pGetAddrInfoExW)(const WCHAR *name, const WCHAR *servname, DWORD namespace, - GUID *namespace_id, const ADDRINFOEXW *hints, ADDRINFOEXW **result, - struct timeval *timeout, OVERLAPPED *overlapped, - LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine, HANDLE *handle); -static int (WINAPI *pGetAddrInfoExOverlappedResult)(OVERLAPPED *overlapped); static int (WINAPI *pGetHostNameW)(WCHAR *, int); static PCSTR (WINAPI *pInetNtop)(INT,LPVOID,LPSTR,ULONG); static PCWSTR(WINAPI *pInetNtopW)(INT,LPVOID,LPWSTR,ULONG); @@ -163,46 +157,6 @@ typedef struct select_thread_params BOOL ReadKilled; } select_thread_params; -/* Tests used in both getaddrinfo and GetAddrInfoW */ -static const struct addr_hint_tests -{ - int family, socktype, protocol; - DWORD error; -} hinttests[] = { - {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0 }, - {AF_UNSPEC, SOCK_STREAM, IPPROTO_UDP, 0 }, - {AF_UNSPEC, SOCK_STREAM, IPPROTO_IPV6,0 }, - {AF_UNSPEC, SOCK_DGRAM, IPPROTO_TCP, 0 }, - {AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, 0 }, - {AF_UNSPEC, SOCK_DGRAM, IPPROTO_IPV6,0 }, - {AF_INET, SOCK_STREAM, IPPROTO_TCP, 0 }, - {AF_INET, SOCK_STREAM, IPPROTO_UDP, 0 }, - {AF_INET, SOCK_STREAM, IPPROTO_IPV6,0 }, - {AF_INET, SOCK_DGRAM, IPPROTO_TCP, 0 }, - {AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0 }, - {AF_INET, SOCK_DGRAM, IPPROTO_IPV6,0 }, - {AF_UNSPEC, 0, IPPROTO_TCP, 0 }, - {AF_UNSPEC, 0, IPPROTO_UDP, 0 }, - {AF_UNSPEC, 0, IPPROTO_IPV6,0 }, - {AF_UNSPEC, SOCK_STREAM, 0, 0 }, - {AF_UNSPEC, SOCK_DGRAM, 0, 0 }, - {AF_INET, 0, IPPROTO_TCP, 0 }, - {AF_INET, 0, IPPROTO_UDP, 0 }, - {AF_INET, 0, IPPROTO_IPV6,0 }, - {AF_INET, SOCK_STREAM, 0, 0 }, - {AF_INET, SOCK_DGRAM, 0, 0 }, - {AF_UNSPEC, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT }, - {AF_UNSPEC, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT }, - {AF_UNSPEC, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT }, - {AF_INET, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT }, - {AF_INET, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT }, - {AF_INET, 999, IPPROTO_IPV6,WSAESOCKTNOSUPPORT }, - {AF_UNSPEC, SOCK_STREAM, 999, 0 }, - {AF_UNSPEC, SOCK_STREAM, 999, 0 }, - {AF_INET, SOCK_DGRAM, 999, 0 }, - {AF_INET, SOCK_DGRAM, 999, 0 }, -}; - /**************** Static variables ***************/ static DWORD tls; /* Thread local storage index */ @@ -390,62 +344,6 @@ static void check_so_opentype (void) ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp ); } -static void compare_addrinfo (ADDRINFO *a, ADDRINFO *b) -{ - for (; a && b ; a = a->ai_next, b = b->ai_next) - { - ok(a->ai_flags == b->ai_flags, - "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags); - ok(a->ai_family == b->ai_family, - "Wrong family %d != %d\n", a->ai_family, b->ai_family); - ok(a->ai_socktype == b->ai_socktype, - "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype); - ok(a->ai_protocol == b->ai_protocol, - "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol); - ok(a->ai_addrlen == b->ai_addrlen, - "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen); - ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)), - "Wrong address data\n"); - if (a->ai_canonname && b->ai_canonname) - { - ok(!strcmp(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n", - a->ai_canonname, b->ai_canonname); - } - else - ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n", - a->ai_canonname, b->ai_canonname); - } - ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b); -} - -static void compare_addrinfow (ADDRINFOW *a, ADDRINFOW *b) -{ - for (; a && b ; a = a->ai_next, b = b->ai_next) - { - ok(a->ai_flags == b->ai_flags, - "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags); - ok(a->ai_family == b->ai_family, - "Wrong family %d != %d\n", a->ai_family, b->ai_family); - ok(a->ai_socktype == b->ai_socktype, - "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype); - ok(a->ai_protocol == b->ai_protocol, - "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol); - ok(a->ai_addrlen == b->ai_addrlen, - "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen); - ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)), - "Wrong address data\n"); - if (a->ai_canonname && b->ai_canonname) - { - ok(!lstrcmpW(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n", - wine_dbgstr_w(a->ai_canonname), wine_dbgstr_w(b->ai_canonname)); - } - else - ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n", - a->ai_canonname, b->ai_canonname); - } - ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b); -} - /**************** Server utility functions ***************/ /* @@ -1201,9 +1099,6 @@ static void Init (void) WSADATA data; HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll"), ntdll; - pFreeAddrInfoExW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoExW"); - pGetAddrInfoExW = (void *)GetProcAddress(hws2_32, "GetAddrInfoExW"); - pGetAddrInfoExOverlappedResult = (void *)GetProcAddress(hws2_32, "GetAddrInfoExOverlappedResult"); pGetHostNameW = (void *)GetProcAddress(hws2_32, "GetHostNameW"); pInetNtop = (void *)GetProcAddress(hws2_32, "inet_ntop"); pInetNtopW = (void *)GetProcAddress(hws2_32, "InetNtopW"); @@ -6537,703 +6432,6 @@ todo_wine #undef POLL_ISSET #undef POLL_CLEAR -static void test_GetAddrInfoW(void) -{ - static const WCHAR port[] = {'8','0',0}; - static const WCHAR empty[] = {0}; - static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0}; - static const WCHAR nxdomain[] = - {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0}; - static const WCHAR zero[] = {'0',0}; - int i, ret; - ADDRINFOW *result, *result2, *p, hint; - WCHAR name[256]; - DWORD size = ARRAY_SIZE(name); - /* te su to.winehq.org written in katakana */ - static const WCHAR idn_domain[] = - {0x30C6,0x30B9,0x30C8,'.','w','i','n','e','h','q','.','o','r','g',0}; - static const WCHAR idn_punycode[] = - {'x','n','-','-','z','c','k','z','a','h','.','w','i','n','e','h','q','.','o','r','g',0}; - - memset(&hint, 0, sizeof(ADDRINFOW)); - name[0] = 0; - GetComputerNameExW( ComputerNamePhysicalDnsHostname, name, &size ); - - result = (ADDRINFOW *)0xdeadbeef; - WSASetLastError(0xdeadbeef); - ret = GetAddrInfoW(NULL, NULL, NULL, &result); - ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); - ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); - ok(result == NULL, "got %p\n", result); - - result = NULL; - WSASetLastError(0xdeadbeef); - ret = GetAddrInfoW(empty, NULL, NULL, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); - FreeAddrInfoW(result); - - result = NULL; - ret = GetAddrInfoW(NULL, zero, NULL, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - - result2 = NULL; - ret = GetAddrInfoW(NULL, empty, NULL, &result2); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(result2 != NULL, "GetAddrInfoW failed\n"); - compare_addrinfow(result, result2); - FreeAddrInfoW(result); - FreeAddrInfoW(result2); - - result = NULL; - ret = GetAddrInfoW(empty, zero, NULL, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - - result2 = NULL; - ret = GetAddrInfoW(empty, empty, NULL, &result2); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(result2 != NULL, "GetAddrInfoW failed\n"); - compare_addrinfow(result, result2); - FreeAddrInfoW(result); - FreeAddrInfoW(result2); - - result = NULL; - ret = GetAddrInfoW(localhost, NULL, NULL, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - FreeAddrInfoW(result); - - result = NULL; - ret = GetAddrInfoW(localhost, empty, NULL, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - FreeAddrInfoW(result); - - result = NULL; - ret = GetAddrInfoW(localhost, zero, NULL, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - FreeAddrInfoW(result); - - result = NULL; - ret = GetAddrInfoW(localhost, port, NULL, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - FreeAddrInfoW(result); - - result = NULL; - ret = GetAddrInfoW(localhost, NULL, &hint, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - FreeAddrInfoW(result); - - result = NULL; - SetLastError(0xdeadbeef); - ret = GetAddrInfoW(localhost, port, &hint, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); - FreeAddrInfoW(result); - - /* try to get information from the computer name, result is the same - * as if requesting with an empty host name. */ - ret = GetAddrInfoW(name, NULL, NULL, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - - ret = GetAddrInfoW(empty, NULL, NULL, &result2); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - compare_addrinfow(result, result2); - FreeAddrInfoW(result); - FreeAddrInfoW(result2); - - ret = GetAddrInfoW(name, empty, NULL, &result); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - - ret = GetAddrInfoW(empty, empty, NULL, &result2); - ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - compare_addrinfow(result, result2); - FreeAddrInfoW(result); - FreeAddrInfoW(result2); - - result = (ADDRINFOW *)0xdeadbeef; - WSASetLastError(0xdeadbeef); - ret = GetAddrInfoW(NULL, NULL, NULL, &result); - if(ret == 0) - { - skip("nxdomain returned success. Broken ISP redirects?\n"); - return; - } - ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); - ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); - ok(result == NULL, "got %p\n", result); - - result = (ADDRINFOW *)0xdeadbeef; - WSASetLastError(0xdeadbeef); - ret = GetAddrInfoW(nxdomain, NULL, NULL, &result); - if(ret == 0) - { - skip("nxdomain returned success. Broken ISP redirects?\n"); - return; - } - ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); - ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); - ok(result == NULL, "got %p\n", result); - - for (i = 0;i < (ARRAY_SIZE(hinttests));i++) - { - hint.ai_family = hinttests[i].family; - hint.ai_socktype = hinttests[i].socktype; - hint.ai_protocol = hinttests[i].protocol; - - result = NULL; - SetLastError(0xdeadbeef); - ret = GetAddrInfoW(localhost, NULL, &hint, &result); - todo_wine_if(hinttests[i].error) ok(ret == hinttests[i].error, "test %d: wrong ret %d\n", i, ret); - if(!ret) - { - for (p = result; p; p = p->ai_next) - { - /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */ - if (hinttests[i].family == AF_UNSPEC) - ok(p->ai_family == AF_INET || p->ai_family == AF_INET6, - "test %d: expected AF_INET or AF_INET6, got %d\n", - i, p->ai_family); - else - ok(p->ai_family == hinttests[i].family, - "test %d: expected family %d, got %d\n", - i, hinttests[i].family, p->ai_family); - - ok(p->ai_socktype == hinttests[i].socktype, - "test %d: expected type %d, got %d\n", - i, hinttests[i].socktype, p->ai_socktype); - ok(p->ai_protocol == hinttests[i].protocol, - "test %d: expected protocol %d, got %d\n", - i, hinttests[i].protocol, p->ai_protocol); - } - FreeAddrInfoW(result); - } - else - { - ok(WSAGetLastError() == hinttests[i].error, "test %d: wrong error %d\n", i, WSAGetLastError()); - } - } - - /* Test IDN resolution (Internationalized Domain Names) present since Windows 8 */ - result = NULL; - ret = GetAddrInfoW(idn_punycode, NULL, NULL, &result); - ok(!ret, "got %d expected success\n", ret); - ok(result != NULL, "got %p\n", result); - FreeAddrInfoW(result); - - hint.ai_family = AF_INET; - hint.ai_socktype = 0; - hint.ai_protocol = 0; - hint.ai_flags = 0; - - result = NULL; - ret = GetAddrInfoW(idn_punycode, NULL, &hint, &result); - ok(!ret, "got %d expected success\n", ret); - ok(result != NULL, "got %p\n", result); - - result2 = NULL; - ret = GetAddrInfoW(idn_domain, NULL, NULL, &result2); - if (broken(ret == WSAHOST_NOT_FOUND)) - { - FreeAddrInfoW(result); - win_skip("IDN resolution not supported in Win <= 7\n"); - return; - } - - ok(!ret, "got %d expected success\n", ret); - ok(result2 != NULL, "got %p\n", result2); - FreeAddrInfoW(result2); - - hint.ai_family = AF_INET; - hint.ai_socktype = 0; - hint.ai_protocol = 0; - hint.ai_flags = 0; - - result2 = NULL; - ret = GetAddrInfoW(idn_domain, NULL, &hint, &result2); - ok(!ret, "got %d expected success\n", ret); - ok(result2 != NULL, "got %p\n", result2); - - /* ensure manually resolved punycode and unicode hosts result in same data */ - compare_addrinfow(result, result2); - - FreeAddrInfoW(result); - FreeAddrInfoW(result2); - - hint.ai_family = AF_INET; - hint.ai_socktype = 0; - hint.ai_protocol = 0; - hint.ai_flags = 0; - - result2 = NULL; - ret = GetAddrInfoW(idn_domain, NULL, &hint, &result2); - ok(!ret, "got %d expected success\n", ret); - ok(result2 != NULL, "got %p\n", result2); - FreeAddrInfoW(result2); - - /* Disable IDN resolution and test again*/ - hint.ai_family = AF_INET; - hint.ai_socktype = 0; - hint.ai_protocol = 0; - hint.ai_flags = AI_DISABLE_IDN_ENCODING; - - SetLastError(0xdeadbeef); - result2 = NULL; - ret = GetAddrInfoW(idn_domain, NULL, &hint, &result2); - ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); - ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); - ok(result2 == NULL, "got %p\n", result2); -} - -static struct completion_routine_test -{ - WSAOVERLAPPED *overlapped; - DWORD error; - ADDRINFOEXW **result; - HANDLE event; - DWORD called; -} completion_routine_test; - -static void CALLBACK completion_routine(DWORD error, DWORD byte_count, WSAOVERLAPPED *overlapped) -{ - struct completion_routine_test *test = &completion_routine_test; - - ok(error == test->error, "got %u\n", error); - ok(!byte_count, "got %u\n", byte_count); - ok(overlapped == test->overlapped, "got %p\n", overlapped); - ok(overlapped->Internal == test->error, "got %lu\n", overlapped->Internal); - ok(overlapped->Pointer == test->result, "got %p\n", overlapped->Pointer); - ok(overlapped->hEvent == NULL, "got %p\n", overlapped->hEvent); - - test->called++; - SetEvent(test->event); -} - -static void test_GetAddrInfoExW(void) -{ - static const WCHAR empty[] = {0}; - static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0}; - static const WCHAR winehq[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0}; - static const WCHAR nxdomain[] = {'n','x','d','o','m','a','i','n','.','w','i','n','e','h','q','.','o','r','g',0}; - ADDRINFOEXW *result; - OVERLAPPED overlapped; - HANDLE event; - int ret; - - if (!pGetAddrInfoExW || !pGetAddrInfoExOverlappedResult) - { - win_skip("GetAddrInfoExW and/or GetAddrInfoExOverlappedResult not present\n"); - return; - } - - event = WSACreateEvent(); - - result = (ADDRINFOEXW *)0xdeadbeef; - WSASetLastError(0xdeadbeef); - ret = pGetAddrInfoExW(NULL, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL); - ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); - ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); - ok(result == NULL, "got %p\n", result); - - result = NULL; - WSASetLastError(0xdeadbeef); - ret = pGetAddrInfoExW(empty, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL); - ok(!ret, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); - pFreeAddrInfoExW(result); - - result = NULL; - ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, NULL, NULL, NULL); - ok(!ret, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); - pFreeAddrInfoExW(result); - - result = (void*)0xdeadbeef; - memset(&overlapped, 0xcc, sizeof(overlapped)); - overlapped.hEvent = event; - ResetEvent(event); - ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL); - ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); - ok(!result, "result != NULL\n"); - ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n"); - ret = pGetAddrInfoExOverlappedResult(&overlapped); - ok(!ret, "overlapped result is %d\n", ret); - pFreeAddrInfoExW(result); - - result = (void*)0xdeadbeef; - memset(&overlapped, 0xcc, sizeof(overlapped)); - ResetEvent(event); - overlapped.hEvent = event; - WSASetLastError(0xdeadbeef); - ret = pGetAddrInfoExW(winehq, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL); - ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); - ok(WSAGetLastError() == ERROR_IO_PENDING, "expected 11001, got %d\n", WSAGetLastError()); - ret = overlapped.Internal; - ok(ret == WSAEINPROGRESS || ret == ERROR_SUCCESS, "overlapped.Internal = %u\n", ret); - ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n"); - ret = pGetAddrInfoExOverlappedResult(&overlapped); - ok(!ret, "overlapped result is %d\n", ret); - ok(overlapped.hEvent == event, "hEvent changed %p\n", overlapped.hEvent); - ok(overlapped.Internal == ERROR_SUCCESS, "overlapped.Internal = %lx\n", overlapped.Internal); - ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n"); - ok(result != NULL, "result == NULL\n"); - if (result != NULL) - { - ok(!result->ai_blob, "ai_blob != NULL\n"); - ok(!result->ai_bloblen, "ai_bloblen != 0\n"); - ok(!result->ai_provider, "ai_provider = %s\n", wine_dbgstr_guid(result->ai_provider)); - pFreeAddrInfoExW(result); - } - - result = (void*)0xdeadbeef; - memset(&overlapped, 0xcc, sizeof(overlapped)); - ResetEvent(event); - overlapped.hEvent = event; - ret = pGetAddrInfoExW(NULL, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, NULL, NULL); - todo_wine - ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); - todo_wine - ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); - ok(result == NULL, "got %p\n", result); - ret = WaitForSingleObject(event, 0); - todo_wine_if(ret != WAIT_TIMEOUT) /* Remove when abowe todo_wines are fixed */ - ok(ret == WAIT_TIMEOUT, "wait failed\n"); - - /* event + completion routine */ - result = (void*)0xdeadbeef; - memset(&overlapped, 0xcc, sizeof(overlapped)); - overlapped.hEvent = event; - ResetEvent(event); - ret = pGetAddrInfoExW(localhost, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL); - ok(ret == WSAEINVAL, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); - - /* completion routine, existing domain */ - result = (void *)0xdeadbeef; - overlapped.hEvent = NULL; - completion_routine_test.overlapped = &overlapped; - completion_routine_test.error = ERROR_SUCCESS; - completion_routine_test.result = &result; - completion_routine_test.event = event; - completion_routine_test.called = 0; - ResetEvent(event); - ret = pGetAddrInfoExW(winehq, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL); - ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); - ok(!result, "result != NULL\n"); - ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n"); - ret = pGetAddrInfoExOverlappedResult(&overlapped); - ok(!ret, "overlapped result is %d\n", ret); - ok(overlapped.hEvent == NULL, "hEvent changed %p\n", overlapped.hEvent); - ok(overlapped.Internal == ERROR_SUCCESS, "overlapped.Internal = %lx\n", overlapped.Internal); - ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n"); - ok(completion_routine_test.called == 1, "got %u\n", completion_routine_test.called); - pFreeAddrInfoExW(result); - - /* completion routine, non-existing domain */ - result = (void *)0xdeadbeef; - completion_routine_test.overlapped = &overlapped; - completion_routine_test.error = WSAHOST_NOT_FOUND; - completion_routine_test.called = 0; - ResetEvent(event); - ret = pGetAddrInfoExW(nxdomain, NULL, NS_DNS, NULL, NULL, &result, NULL, &overlapped, completion_routine, NULL); - ok(ret == ERROR_IO_PENDING, "GetAddrInfoExW failed with %d\n", WSAGetLastError()); - ok(!result, "result != NULL\n"); - ok(WaitForSingleObject(event, 1000) == WAIT_OBJECT_0, "wait failed\n"); - ret = pGetAddrInfoExOverlappedResult(&overlapped); - ok(ret == WSAHOST_NOT_FOUND, "overlapped result is %d\n", ret); - ok(overlapped.hEvent == NULL, "hEvent changed %p\n", overlapped.hEvent); - ok(overlapped.Internal == WSAHOST_NOT_FOUND, "overlapped.Internal = %lx\n", overlapped.Internal); - ok(overlapped.Pointer == &result, "overlapped.Pointer != &result\n"); - ok(completion_routine_test.called == 1, "got %u\n", completion_routine_test.called); - ok(result == NULL, "got %p\n", result); - - WSACloseEvent(event); -} - -static void verify_ipv6_addrinfo(ADDRINFOA *result, const char *expectedIp) -{ - SOCKADDR_IN6 *sockaddr6; - char ipBuffer[256]; - const char *ret; - - ok(result->ai_family == AF_INET6, "ai_family == %d\n", result->ai_family); - ok(result->ai_addrlen >= sizeof(struct sockaddr_in6), "ai_addrlen == %d\n", (int)result->ai_addrlen); - ok(result->ai_addr != NULL, "ai_addr == NULL\n"); - - if (result->ai_addr != NULL) - { - sockaddr6 = (SOCKADDR_IN6 *)result->ai_addr; - ok(sockaddr6->sin6_family == AF_INET6, "ai_addr->sin6_family == %d\n", sockaddr6->sin6_family); - ok(sockaddr6->sin6_port == 0, "ai_addr->sin6_port == %d\n", sockaddr6->sin6_port); - - ZeroMemory(ipBuffer, sizeof(ipBuffer)); - ret = pInetNtop(AF_INET6, &sockaddr6->sin6_addr, ipBuffer, sizeof(ipBuffer)); - ok(ret != NULL, "inet_ntop failed (%d)\n", WSAGetLastError()); - ok(strcmp(ipBuffer, expectedIp) == 0, "ai_addr->sin6_addr == '%s' (expected '%s')\n", ipBuffer, expectedIp); - } -} - -static void test_getaddrinfo(void) -{ - int i, ret; - ADDRINFOA *result, *result2, *p, hint; - SOCKADDR_IN *sockaddr; - CHAR name[256], *ip; - DWORD size = sizeof(name); - - memset(&hint, 0, sizeof(ADDRINFOA)); - GetComputerNameExA( ComputerNamePhysicalDnsHostname, name, &size ); - - result = (ADDRINFOA *)0xdeadbeef; - WSASetLastError(0xdeadbeef); - ret = getaddrinfo(NULL, NULL, NULL, &result); - ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); - ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); - ok(result == NULL, "got %p\n", result); - - result = NULL; - WSASetLastError(0xdeadbeef); - ret = getaddrinfo("", NULL, NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(result != NULL, "getaddrinfo failed\n"); - ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); - freeaddrinfo(result); - - result = NULL; - ret = getaddrinfo(NULL, "0", NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(result != NULL, "getaddrinfo failed\n"); - - result2 = NULL; - ret = getaddrinfo(NULL, "", NULL, &result2); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(result2 != NULL, "getaddrinfo failed\n"); - compare_addrinfo(result, result2); - freeaddrinfo(result); - freeaddrinfo(result2); - - result = NULL; - WSASetLastError(0xdeadbeef); - ret = getaddrinfo("", "0", NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); - ok(result != NULL, "getaddrinfo failed\n"); - - result2 = NULL; - ret = getaddrinfo("", "", NULL, &result2); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(result2 != NULL, "getaddrinfo failed\n"); - compare_addrinfo(result, result2); - freeaddrinfo(result); - freeaddrinfo(result2); - - result = NULL; - ret = getaddrinfo("localhost", NULL, NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - freeaddrinfo(result); - - result = NULL; - ret = getaddrinfo("localhost", "", NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - freeaddrinfo(result); - - result = NULL; - ret = getaddrinfo("localhost", "0", NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - freeaddrinfo(result); - - result = NULL; - ret = getaddrinfo("localhost", "80", NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - freeaddrinfo(result); - - result = NULL; - ret = getaddrinfo("localhost", NULL, &hint, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - freeaddrinfo(result); - - result = NULL; - WSASetLastError(0xdeadbeef); - ret = getaddrinfo("localhost", "80", &hint, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError()); - freeaddrinfo(result); - - hint.ai_flags = AI_NUMERICHOST; - result = (void*)0xdeadbeef; - ret = getaddrinfo("localhost", "80", &hint, &result); - ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected WSAHOST_NOT_FOUND, got %d\n", WSAGetLastError()); - ok(!result, "result = %p\n", result); - hint.ai_flags = 0; - - /* try to get information from the computer name, result is the same - * as if requesting with an empty host name. */ - ret = getaddrinfo(name, NULL, NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - - ret = getaddrinfo("", NULL, NULL, &result2); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - compare_addrinfo(result, result2); - freeaddrinfo(result); - freeaddrinfo(result2); - - ret = getaddrinfo(name, "", NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - - ret = getaddrinfo("", "", NULL, &result2); - ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError()); - ok(result != NULL, "GetAddrInfoW failed\n"); - compare_addrinfo(result, result2); - freeaddrinfo(result); - freeaddrinfo(result2); - - result = (ADDRINFOA *)0xdeadbeef; - WSASetLastError(0xdeadbeef); - ret = getaddrinfo("nxdomain.codeweavers.com", NULL, NULL, &result); - if(ret == 0) - { - skip("nxdomain returned success. Broken ISP redirects?\n"); - return; - } - ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret); - ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError()); - ok(result == NULL, "got %p\n", result); - - /* Test IPv4 address conversion */ - result = NULL; - ret = getaddrinfo("192.168.1.253", NULL, NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", ret); - ok(result->ai_family == AF_INET, "ai_family == %d\n", result->ai_family); - ok(result->ai_addrlen >= sizeof(struct sockaddr_in), "ai_addrlen == %d\n", (int)result->ai_addrlen); - ok(result->ai_addr != NULL, "ai_addr == NULL\n"); - sockaddr = (SOCKADDR_IN *)result->ai_addr; - ok(sockaddr->sin_family == AF_INET, "ai_addr->sin_family == %d\n", sockaddr->sin_family); - ok(sockaddr->sin_port == 0, "ai_addr->sin_port == %d\n", sockaddr->sin_port); - - ip = inet_ntoa(sockaddr->sin_addr); - ok(strcmp(ip, "192.168.1.253") == 0, "sockaddr->ai_addr == '%s'\n", ip); - freeaddrinfo(result); - - /* Test IPv4 address conversion with port */ - result = NULL; - hint.ai_flags = AI_NUMERICHOST; - ret = getaddrinfo("192.168.1.253:1024", NULL, &hint, &result); - hint.ai_flags = 0; - ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo returned unexpected result: %d\n", ret); - ok(result == NULL, "expected NULL, got %p\n", result); - - /* Test IPv6 address conversion */ - result = NULL; - SetLastError(0xdeadbeef); - ret = getaddrinfo("2a00:2039:dead:beef:cafe::6666", NULL, NULL, &result); - - if (result != NULL) - { - ok(!ret, "getaddrinfo failed with %d\n", ret); - verify_ipv6_addrinfo(result, "2a00:2039:dead:beef:cafe::6666"); - freeaddrinfo(result); - - /* Test IPv6 address conversion with brackets */ - result = NULL; - ret = getaddrinfo("[beef::cafe]", NULL, NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", ret); - verify_ipv6_addrinfo(result, "beef::cafe"); - freeaddrinfo(result); - - /* Test IPv6 address conversion with brackets and hints */ - memset(&hint, 0, sizeof(ADDRINFOA)); - hint.ai_flags = AI_NUMERICHOST; - hint.ai_family = AF_INET6; - result = NULL; - ret = getaddrinfo("[beef::cafe]", NULL, &hint, &result); - ok(!ret, "getaddrinfo failed with %d\n", ret); - verify_ipv6_addrinfo(result, "beef::cafe"); - freeaddrinfo(result); - - memset(&hint, 0, sizeof(ADDRINFOA)); - hint.ai_flags = AI_NUMERICHOST; - hint.ai_family = AF_INET; - result = NULL; - ret = getaddrinfo("[beef::cafe]", NULL, &hint, &result); - ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret); - - /* Test IPv6 address conversion with brackets and port */ - result = NULL; - ret = getaddrinfo("[beef::cafe]:10239", NULL, NULL, &result); - ok(!ret, "getaddrinfo failed with %d\n", ret); - verify_ipv6_addrinfo(result, "beef::cafe"); - freeaddrinfo(result); - - /* Test IPv6 address conversion with unmatched brackets */ - result = NULL; - hint.ai_flags = AI_NUMERICHOST; - ret = getaddrinfo("[beef::cafe", NULL, &hint, &result); - ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret); - - ret = getaddrinfo("beef::cafe]", NULL, &hint, &result); - ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret); - } - else - { - ok(ret == WSAHOST_NOT_FOUND, "getaddrinfo failed with %d\n", ret); - win_skip("getaddrinfo does not support IPV6\n"); - } - - hint.ai_flags = 0; - - for (i = 0;i < (ARRAY_SIZE(hinttests));i++) - { - hint.ai_family = hinttests[i].family; - hint.ai_socktype = hinttests[i].socktype; - hint.ai_protocol = hinttests[i].protocol; - - result = NULL; - SetLastError(0xdeadbeef); - ret = getaddrinfo("localhost", NULL, &hint, &result); - todo_wine_if(hinttests[i].error) ok(ret == hinttests[i].error, "test %d: wrong ret %d\n", i, ret); - if(!ret) - { - for (p = result; p; p = p->ai_next) - { - /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */ - if (hinttests[i].family == AF_UNSPEC) - ok(p->ai_family == AF_INET || p->ai_family == AF_INET6, - "test %d: expected AF_INET or AF_INET6, got %d\n", - i, p->ai_family); - else - ok(p->ai_family == hinttests[i].family, - "test %d: expected family %d, got %d\n", - i, hinttests[i].family, p->ai_family); - - ok(p->ai_socktype == hinttests[i].socktype, - "test %d: expected type %d, got %d\n", - i, hinttests[i].socktype, p->ai_socktype); - ok(p->ai_protocol == hinttests[i].protocol, - "test %d: expected protocol %d, got %d\n", - i, hinttests[i].protocol, p->ai_protocol); - } - freeaddrinfo(result); - } - else - { - ok(WSAGetLastError() == hinttests[i].error, "test %d: wrong error %d\n", i, WSAGetLastError()); - } - } - - memset(&hint, 0, sizeof(hint)); - ret = getaddrinfo(NULL, "nonexistentservice", &hint, &result); - ok(ret == WSATYPE_NOT_FOUND, "got %d\n", ret); -} - static void test_ConnectEx(void) { SOCKET listener = INVALID_SOCKET; @@ -10680,9 +9878,6 @@ START_TEST( sock ) test_ipv6only(); test_TransmitFile(); - test_GetAddrInfoW(); - test_GetAddrInfoExW(); - test_getaddrinfo(); test_AcceptEx(); test_ConnectEx(); test_DisconnectEx(); -- 2.30.2

2 7

[PATCH] wscript: return TRUE for /d and /u stub switches
by Dmitry Kislyuk 28 Apr '21

28 Apr '21

Patch by Robert Wilhelm from bug https://bugs.winehq.org/show_bug.cgi?id=49905

1 0

[PATCH 3/3] msvcrt: Import y0 implementation from musl.
by Piotr Caban 28 Apr '21

28 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 54 ++++++++++++++++++++++++++++++++++--------- dlls/msvcrt/unixlib.c | 14 ----------- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 43 insertions(+), 27 deletions(-)

1 0

[PATCH 2/3] msvcrt: Import j0 implementation from musl.
by Piotr Caban 28 Apr '21

28 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 1 - dlls/msvcrt/math.c | 238 +++++++++++++++++++++++++++++++++++++++++- dlls/msvcrt/unixlib.c | 14 --- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 235 insertions(+), 19 deletions(-)

1 0

[PATCH 1/3] msvcrt: Fix typo in asin error handling.
by Piotr Caban 28 Apr '21

28 Apr '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/math.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

1 0

[PATCH] kernel32: Add stub for SetThreadSelectedCpuSets().
by Paul Gofman 28 Apr '21

28 Apr '21

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- Used by Forza Horizon 4. .../api-ms-win-core-processthreads-l1-1-3.spec | 2 +- dlls/kernel32/kernel32.spec | 1 + dlls/kernelbase/kernelbase.spec | 2 +- dlls/kernelbase/memory.c | 11 +++++++++++ 4 files changed, 14 insertions(+), 2 deletions(-) diff --git a/dlls/api-ms-win-core-processthreads-l1-1-3/api-ms-win-core-processthreads-l1-1-3.spec b/dlls/api-ms-win-core-processthreads-l1-1-3/api-ms-win-core-processthreads-l1-1-3.spec index 8f2daaefe74..77893f24225 100644 --- a/dlls/api-ms-win-core-processthreads-l1-1-3/api-ms-win-core-processthreads-l1-1-3.spec +++ b/dlls/api-ms-win-core-processthreads-l1-1-3/api-ms-win-core-processthreads-l1-1-3.spec @@ -7,4 +7,4 @@ @ stub SetProcessInformation @ stdcall SetThreadDescription(ptr wstr) kernel32.SetThreadDescription @ stdcall SetThreadIdealProcessor(long long) kernel32.SetThreadIdealProcessor -@ stub SetThreadSelectedCpuSets +@ stdcall SetThreadSelectedCpuSets(ptr ptr long) kernel32.SetThreadSelectedCpuSets diff --git a/dlls/kernel32/kernel32.spec b/dlls/kernel32/kernel32.spec index 6948ba45fce..87e67d3743d 100644 --- a/dlls/kernel32/kernel32.spec +++ b/dlls/kernel32/kernel32.spec @@ -1471,6 +1471,7 @@ @ stdcall -import SetThreadPreferredUILanguages(long ptr ptr) @ stdcall -import SetThreadPriority(long long) @ stdcall -import SetThreadPriorityBoost(long long) +@ stdcall -import SetThreadSelectedCpuSets(ptr ptr long) @ stdcall -import SetThreadStackGuarantee(ptr) # @ stub SetThreadToken @ stdcall -import SetThreadUILanguage(long) diff --git a/dlls/kernelbase/kernelbase.spec b/dlls/kernelbase/kernelbase.spec index 28cfd842223..9a66c5c2ac0 100644 --- a/dlls/kernelbase/kernelbase.spec +++ b/dlls/kernelbase/kernelbase.spec @@ -1494,7 +1494,7 @@ @ stdcall SetThreadPreferredUILanguages(long ptr ptr) @ stdcall SetThreadPriority(long long) @ stdcall SetThreadPriorityBoost(long long) -# @ stub SetThreadSelectedCpuSets +@ stdcall SetThreadSelectedCpuSets(ptr ptr long) @ stdcall SetThreadStackGuarantee(ptr) @ stdcall SetThreadToken(ptr ptr) @ stdcall SetThreadUILanguage(long) diff --git a/dlls/kernelbase/memory.c b/dlls/kernelbase/memory.c index 4b71c0cc6ec..fb5f5100399 100644 --- a/dlls/kernelbase/memory.c +++ b/dlls/kernelbase/memory.c @@ -1168,6 +1168,17 @@ BOOL WINAPI GetSystemCpuSetInformation(SYSTEM_CPU_SET_INFORMATION *info, ULONG b } +/*********************************************************************** + * SetThreadSelectedCpuSets (kernelbase.@) + */ +BOOL WINAPI SetThreadSelectedCpuSets(HANDLE thread, const ULONG *cpu_set_ids, ULONG count) +{ + FIXME( "thread %p, cpu_set_ids %p, count %u stub.\n", thread, cpu_set_ids, count ); + + return TRUE; +} + + /********************************************************************** * GetNumaHighestNodeNumber (kernelbase.@) */ -- 2.31.1

1 0

[PATCH v2] ntdll: Implement NtGetNextThread().
by Paul Gofman 28 Apr '21

28 Apr '21

Largely based on a patch by Nikolay Sivov for NtGetNextProcess(). Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- v2: - stop searching for thread even if handle allocation failed; - do not zero reply handle in server; - set output handle to NULL in case of error (also add tests supporting that); - move return handle assignment outside of SERVER_START_REQ() scope. dlls/ntdll/ntdll.spec | 1 + dlls/ntdll/tests/om.c | 93 ++++++++++++++++++++++++++++++++++++++++ dlls/ntdll/unix/thread.c | 29 +++++++++++++ server/protocol.def | 12 ++++++ server/thread.c | 50 +++++++++++++++++++++ 5 files changed, 185 insertions(+) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index a93fa08c406..cade83da4b1 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -223,6 +223,7 @@ @ stdcall -norelay -syscall NtGetContextThread(long ptr) @ stdcall -syscall NtGetCurrentProcessorNumber() # @ stub NtGetDevicePowerState +@ stdcall -syscall NtGetNextThread(ptr ptr long long long ptr) @ stdcall -syscall NtGetNlsSectionPtr(long long long ptr ptr) @ stub NtGetPlugPlayEvent @ stdcall NtGetTickCount() diff --git a/dlls/ntdll/tests/om.c b/dlls/ntdll/tests/om.c index e0988769c9c..7d9ca47be12 100644 --- a/dlls/ntdll/tests/om.c +++ b/dlls/ntdll/tests/om.c @@ -78,6 +78,8 @@ static void (WINAPI *pRtlWakeAddressAll)( const void * ); static void (WINAPI *pRtlWakeAddressSingle)( const void * ); static NTSTATUS (WINAPI *pNtOpenProcess)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, const CLIENT_ID * ); static NTSTATUS (WINAPI *pNtCreateDebugObject)( HANDLE *, ACCESS_MASK, OBJECT_ATTRIBUTES *, ULONG ); +static NTSTATUS (WINAPI *pNtGetNextThread)(HANDLE process, HANDLE thread, ACCESS_MASK access, ULONG attributes, + ULONG flags, HANDLE *handle); #define KEYEDEVENT_WAIT 0x0001 #define KEYEDEVENT_WAKE 0x0002 @@ -2564,6 +2566,95 @@ static void test_object_types(void) } } +static DWORD WINAPI test_get_next_thread_proc( void *arg ) +{ + HANDLE event = (HANDLE)arg; + + WaitForSingleObject(event, INFINITE); + return 0; +} + +static void test_get_next_thread(void) +{ + HANDLE hprocess = GetCurrentProcess(); + HANDLE handle, thread, event, prev; + NTSTATUS status; + DWORD thread_id; + BOOL found; + + if (!pNtGetNextThread) + { + win_skip("NtGetNextThread is not available.\n"); + return; + } + + event = CreateEventA(NULL, FALSE, FALSE, NULL); + + thread = CreateThread( NULL, 0, test_get_next_thread_proc, event, 0, &thread_id ); + + status = pNtGetNextThread(hprocess, NULL, THREAD_QUERY_LIMITED_INFORMATION, OBJ_INHERIT, 0, NULL); + ok(status == STATUS_ACCESS_VIOLATION, "Got unexected status %#x.\n", status); + + found = FALSE; + prev = NULL; + while (!(status = pNtGetNextThread(hprocess, prev, THREAD_QUERY_LIMITED_INFORMATION, OBJ_INHERIT, 0, &handle))) + { + if (prev) + { + if (GetThreadId(handle) == thread_id) + found = TRUE; + pNtClose(prev); + } + else + { + ok(GetThreadId(handle) == GetCurrentThreadId(), "Got unexpected thread id %04x, current %04x.\n", + GetThreadId(handle), GetCurrentThreadId()); + } + prev = handle; + handle = (HANDLE)0xdeadbeef; + } + pNtClose(prev); + ok(!handle, "Got unexpected handle %p.\n", handle); + ok(status == STATUS_NO_MORE_ENTRIES, "Unexpected status %#x.\n", status); + ok(found, "Thread not found.\n"); + + handle = (HANDLE)0xdeadbeef; + status = pNtGetNextThread((void *)0xdeadbeef, 0, PROCESS_QUERY_LIMITED_INFORMATION, OBJ_INHERIT, 0, &handle); + ok(status == STATUS_INVALID_HANDLE, "Unexpected status %#x.\n", status); + ok(!handle, "Got unexpected handle %p.\n", handle); + handle = (HANDLE)0xdeadbeef; + status = pNtGetNextThread(hprocess, (void *)0xdeadbeef, PROCESS_QUERY_LIMITED_INFORMATION, OBJ_INHERIT, 0, &handle); + ok(status == STATUS_INVALID_HANDLE, "Unexpected status %#x.\n", status); + ok(!handle, "Got unexpected handle %p.\n", handle); + + /* Reversed search is only supported on recent enough Win10. */ + status = pNtGetNextThread(hprocess, 0, PROCESS_QUERY_LIMITED_INFORMATION, OBJ_INHERIT, 1, &handle); + ok(!status || broken(status == STATUS_INVALID_PARAMETER), "Unexpected status %#x.\n", status); + if (!status) + pNtClose(handle); + + status = pNtGetNextThread(hprocess, 0, PROCESS_QUERY_LIMITED_INFORMATION, OBJ_INHERIT, 2, &handle); + ok(status == STATUS_INVALID_PARAMETER, "Unexpected status %#x.\n", status); + + SetEvent(event); + WaitForSingleObject(thread, INFINITE); + + found = FALSE; + prev = NULL; + while (!(status = pNtGetNextThread(hprocess, prev, THREAD_QUERY_LIMITED_INFORMATION, OBJ_INHERIT, 0, &handle))) + { + if (prev) + pNtClose(prev); + if (GetThreadId(handle) == thread_id) + found = TRUE; + prev = handle; + } + pNtClose(prev); + ok(found, "Thread not found.\n"); + + CloseHandle(thread); +} + START_TEST(om) { HMODULE hntdll = GetModuleHandleA("ntdll.dll"); @@ -2615,6 +2706,7 @@ START_TEST(om) pRtlWakeAddressSingle = (void *)GetProcAddress(hntdll, "RtlWakeAddressSingle"); pNtOpenProcess = (void *)GetProcAddress(hntdll, "NtOpenProcess"); pNtCreateDebugObject = (void *)GetProcAddress(hntdll, "NtCreateDebugObject"); + pNtGetNextThread = (void *)GetProcAddress(hntdll, "NtGetNextThread"); test_case_sensitive(); test_namespace_pipe(); @@ -2632,4 +2724,5 @@ START_TEST(om) test_wait_on_address(); test_process(); test_object_types(); + test_get_next_thread(); } diff --git a/dlls/ntdll/unix/thread.c b/dlls/ntdll/unix/thread.c index 274fae24873..36f90372611 100644 --- a/dlls/ntdll/unix/thread.c +++ b/dlls/ntdll/unix/thread.c @@ -1382,3 +1382,32 @@ ULONG WINAPI NtGetCurrentProcessorNumber(void) /* fallback to the first processor */ return 0; } + + +/****************************************************************************** + * NtGetNextThread (NTDLL.@) + */ +NTSTATUS WINAPI NtGetNextThread(HANDLE hprocess, HANDLE hthread, ACCESS_MASK access, ULONG attributes, + ULONG flags, HANDLE *handle) +{ + HANDLE ret_handle; + NTSTATUS ret; + + TRACE( "hprocess %p, hthread %p, access %#x, attributes %#x, flags %#x, handle %p.\n", + hprocess, hthread, access, attributes, flags, handle ); + + SERVER_START_REQ( get_next_thread ) + { + req->process = wine_server_obj_handle( hprocess ); + req->last = wine_server_obj_handle( hthread ); + req->access = access; + req->attributes = attributes; + req->flags = flags; + ret = wine_server_call( req ); + ret_handle = ret ? NULL : wine_server_ptr_handle( reply->handle ); + } + SERVER_END_REQ; + + *handle = ret_handle; + return ret; +} diff --git a/server/protocol.def b/server/protocol.def index d061fca7073..9361933d47c 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -3687,3 +3687,15 @@ struct handle_info @REQ(resume_process) obj_handle_t handle; /* process handle */ @END + + +/* Iterate thread list for process */ +@REQ(get_next_thread) + obj_handle_t process; /* process handle */ + obj_handle_t last; /* thread handle to start with */ + unsigned int access; /* desired access for returned handle */ + unsigned int attributes; /* returned handle attributes */ + unsigned int flags; /* controls iteration direction */ +@REPLY + obj_handle_t handle; /* next thread handle */ +@END diff --git a/server/thread.c b/server/thread.c index 48f793b6a74..fc8362e2ca0 100644 --- a/server/thread.c +++ b/server/thread.c @@ -1925,3 +1925,53 @@ DECL_HANDLER(get_selector_entry) release_object( thread ); } } + +/* Iterate thread list for process. Use global thread list to also + * return terminated but not yet destroyed threads. */ +DECL_HANDLER(get_next_thread) +{ + struct thread *thread, *next; + struct process *process; + struct list *ptr; + + if ( req->flags > 1 ) + { + set_error( STATUS_INVALID_PARAMETER ); + return; + } + + if (!(process = get_process_from_handle( req->process, PROCESS_QUERY_INFORMATION ))) + return; + + if (!req->last) + { + ptr = req->flags ? list_tail( &thread_list ) : list_head( &thread_list ); + } + else if ((thread = get_thread_from_handle( req->last, 0 ))) + { + ptr = req->flags ? list_prev( &thread_list, &thread->entry ) : + list_next( &thread_list, &thread->entry ); + release_object( thread ); + } + else + { + release_object( process ); + return; + } + + while (ptr) + { + next = LIST_ENTRY( ptr, struct thread, entry ); + if (next->process == process) + { + reply->handle = alloc_handle( current->process, next, req->access, req->attributes ); + release_object( process ); + return; + } + ptr = req->flags ? list_prev( &thread_list, &next->entry ) + : list_next( &thread_list, &next->entry ); + } + + set_error( STATUS_NO_MORE_ENTRIES ); + release_object( process ); +} -- 2.31.1

1 0

[PATCH] reg/tests: Verify that only the (Default) value is overwritten when neither /v nor /ve is specified
by Hugh McMaster 28 Apr '21

28 Apr '21

Signed-off-by: Hugh McMaster <hugh.mcmaster(a)outlook.com> --- programs/reg/tests/add.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/programs/reg/tests/add.c b/programs/reg/tests/add.c index 6973eefd892..fdd09c885bc 100644 --- a/programs/reg/tests/add.c +++ b/programs/reg/tests/add.c @@ -384,6 +384,15 @@ static void test_add(void) verify_reg(hkey, "Test2", REG_DWORD, &dword, sizeof(dword), 0); todo_wine verify_reg(hkey, NULL, REG_SZ, "", 1, 0); + run_reg_exe("reg add HKCU\\" KEY_BASE " /t REG_NONE /d Test /f", &r); + ok(r == REG_EXIT_SUCCESS, "got exit code %d, expected 0\n", r); + + verify_key(HKEY_CURRENT_USER, KEY_BASE); + verify_key(hkey, "Subkey"); + verify_reg(hkey, "Test1", REG_SZ, "Value1", 7, 0); + verify_reg(hkey, "Test2", REG_DWORD, &dword, sizeof(dword), 0); + verify_reg(hkey, NULL, REG_NONE, "T\0e\0s\0t\0\0", 10, 0); + close_key(hkey); delete_tree(HKEY_CURRENT_USER, KEY_BASE); } -- 2.31.1

1 0

[PATCH] rtworkq/tests: Load CoGetApartmentType() dynamically.
by Francois Gouget 28 Apr '21

28 Apr '21

The main goal is to get WineTest reports to state that the test was skipped because rtworkq.dll is missing rather than because of a possibly unrelated API. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- Restating differently, currently looking at a WineTest report (or test.winehq.org) I see that the test was skipped on Vista because of a missing API and I am left to guess whether rtworkq.dll was available at all. This patch takes out the guessing part even if nothing can be tested (so far). --- dlls/rtworkq/tests/rtworkq.c | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/dlls/rtworkq/tests/rtworkq.c b/dlls/rtworkq/tests/rtworkq.c index 627e024d761..6337eb35f3d 100644 --- a/dlls/rtworkq/tests/rtworkq.c +++ b/dlls/rtworkq/tests/rtworkq.c @@ -25,6 +25,9 @@ #include "wine/test.h" +/* functions that are not present on all versions of Windows */ +static HRESULT (WINAPI * pCoGetApartmentType)(APTTYPE *type, APTTYPEQUALIFIER *qualifier); + static void test_platform_init(void) { APTTYPEQUALIFIER qualifier; @@ -32,13 +35,13 @@ static void test_platform_init(void) HRESULT hr; /* Startup initializes MTA. */ - hr = CoGetApartmentType(&apttype, &qualifier); + hr = pCoGetApartmentType(&apttype, &qualifier); ok(hr == CO_E_NOTINITIALIZED, "Unexpected hr %#x.\n", hr); hr = RtwqStartup(); ok(hr == S_OK, "Failed to start up, hr %#x.\n", hr); - hr = CoGetApartmentType(&apttype, &qualifier); + hr = pCoGetApartmentType(&apttype, &qualifier); ok(hr == S_OK || broken(FAILED(hr)) /* Win8 */, "Unexpected hr %#x.\n", hr); if (SUCCEEDED(hr)) ok(apttype == APTTYPE_MTA && qualifier == APTTYPEQUALIFIER_IMPLICIT_MTA, @@ -47,14 +50,14 @@ static void test_platform_init(void) hr = RtwqShutdown(); ok(hr == S_OK, "Failed to shut down, hr %#x.\n", hr); - hr = CoGetApartmentType(&apttype, &qualifier); + hr = pCoGetApartmentType(&apttype, &qualifier); ok(hr == CO_E_NOTINITIALIZED, "Unexpected hr %#x.\n", hr); /* Try with STA initialized before startup. */ hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); ok(hr == S_OK, "Failed to initialize, hr %#x.\n", hr); - hr = CoGetApartmentType(&apttype, &qualifier); + hr = pCoGetApartmentType(&apttype, &qualifier); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); ok(apttype == APTTYPE_MAINSTA && qualifier == APTTYPEQUALIFIER_NONE, "Unexpected apartment type %d, qualifier %d.\n", apttype, qualifier); @@ -62,7 +65,7 @@ static void test_platform_init(void) hr = RtwqStartup(); ok(hr == S_OK, "Failed to start up, hr %#x.\n", hr); - hr = CoGetApartmentType(&apttype, &qualifier); + hr = pCoGetApartmentType(&apttype, &qualifier); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); ok(apttype == APTTYPE_MAINSTA && qualifier == APTTYPEQUALIFIER_NONE, "Unexpected apartment type %d, qualifier %d.\n", apttype, qualifier); @@ -76,7 +79,7 @@ static void test_platform_init(void) hr = RtwqStartup(); ok(hr == S_OK, "Failed to start up, hr %#x.\n", hr); - hr = CoGetApartmentType(&apttype, &qualifier); + hr = pCoGetApartmentType(&apttype, &qualifier); ok(hr == S_OK || broken(FAILED(hr)) /* Win8 */, "Unexpected hr %#x.\n", hr); if (SUCCEEDED(hr)) ok(apttype == APTTYPE_MTA && qualifier == APTTYPEQUALIFIER_IMPLICIT_MTA, @@ -85,14 +88,14 @@ static void test_platform_init(void) hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); ok(hr == S_OK, "Failed to initialize, hr %#x.\n", hr); - hr = CoGetApartmentType(&apttype, &qualifier); + hr = pCoGetApartmentType(&apttype, &qualifier); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); ok(apttype == APTTYPE_MAINSTA && qualifier == APTTYPEQUALIFIER_NONE, "Unexpected apartment type %d, qualifier %d.\n", apttype, qualifier); CoUninitialize(); - hr = CoGetApartmentType(&apttype, &qualifier); + hr = pCoGetApartmentType(&apttype, &qualifier); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); ok(apttype == APTTYPE_MTA && qualifier == APTTYPEQUALIFIER_IMPLICIT_MTA, "Unexpected apartment type %d, qualifier %d.\n", apttype, qualifier); @@ -103,5 +106,13 @@ static void test_platform_init(void) START_TEST(rtworkq) { + HMODULE hOle32 = GetModuleHandleA("ole32"); + pCoGetApartmentType = (void*)GetProcAddress(hOle32, "CoGetApartmentType"); + if (!pCoGetApartmentType) + { + win_skip("CoGetApartmentType() is missing\n"); + return; + } + test_platform_init(); } -- 2.20.1

2 2

[tools 1/2] winetest/build-patterns: Use color gradients for the failures.
by Francois Gouget 28 Apr '21

28 Apr '21

This makes it possible to identify when the failure count changes, such as when a patch adds two new failures to a test that already had five, or when the failure count depending on the test configuration. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- The pattern page will automatically be updated when the next report arrives. Maybe there's a way to tweak the gradients to get more contrasting colors. In particular the blue / green yellow are sometimes hard to distinguish. But I'm not much of a color guy so I'll leave that to someone else. Of course another approach is to have fewer failure modes ;-) --- winetest/build-patterns | 116 +++++++++++++++++++++++++++++++--------- winetest/report.css | 4 +- 2 files changed, 93 insertions(+), 27 deletions(-) diff --git a/winetest/build-patterns b/winetest/build-patterns index f470c266f..9dc25816f 100755 --- a/winetest/build-patterns +++ b/winetest/build-patterns @@ -247,6 +247,9 @@ my %reports; # - name # The uniquely identifying test name in the form 'module:unit'. # +# - colors +# A hashtable of colors indexed by failure count. +# # - testreports # A hashtable mapping report directory names to objects storing the results # for that test and report combination. Each testreport object has the @@ -421,44 +424,101 @@ foreach my $testname (keys %tests) } +# +# Compute color gradients +# + +sub color2html($) +{ + my ($c) = @_; + return sprintf "#%02x%02x%02x", $c->[0], $c->[1], $c->[2]; +} + +sub blend($$$) +{ + my ($p, $start, $end) = @_; + my $r = [int($start->[0] * (1 - $p) + $end->[0] * $p + 0.5), + int($start->[1] * (1 - $p) + $end->[1] * $p + 0.5), + int($start->[2] * (1 - $p) + $end->[2] * $p + 0.5)]; + return $r; +} + +my @keycolors = ([0, 255, 255], # cyan + [0, 255, 0], # green + [255, 255, 0], # yellow + [255, 0, 0], # red +); + +# Use colors to differentiate the set values. Each unique value is assigned +# a color (in HTML format) picked along a series of gradients passing by the +# colors defined in @keycolors. +sub compute_set_colors($) +{ + my ($set) = @_; + my @values = sort { $a <=> $b } keys %$set; + my $count = @values; + if ($count == 1) + { + $set->{$values[0]} = color2html($keycolors[0]); + } + else + { + my $k = 0; + my ($start, $end) = (-1, 0); + for (0..$count-1) + { + while (!$end or $_ > $end) + { + $k++; + $start = $end; + $end = ($count-1) * $k / (@keycolors-1); + } + $set->{$values[$_]} = color2html(blend(($_-$start)/($end-$start), + $keycolors[$k-1], + $keycolors[$k])); + } + } +} + + # # Write the failure patterns page for the given set of reports # my %status2html = ( # Dll information status values - # <status> => [ <symbol>, <class-char>, <title>, <link> ] - "missing" => ["n", "n", "not run for an unknown reason", "report"], - "missingdll" => ["m", "m", "missing dll", "version"], - "missingentrypoint" => ["e", "e", "missing entry point", "version"], - "missingordinal" => ["o", "o", "missing ordinal", "version"], - "missingsxs" => ["v", "v", "missing side-by-side dll version", "version"], - "stub" => ["u", "u", "stub Windows dll", "version"], - "native" => ["N", "N", "native Windows dll", "version"], - "loaderror258" => ["I", "I", "timed out while getting the test list", "version"], + # <status> => [ <symbol>, <class-char>, <title>, <link>, <attrs> ] + "missing" => ["n", "n", "not run for an unknown reason", "report", ""], + "missingdll" => ["m", "m", "missing dll", "version", ""], + "missingentrypoint" => ["e", "e", "missing entry point", "version", ""], + "missingordinal" => ["o", "o", "missing ordinal", "version", ""], + "missingsxs" => ["v", "v", "missing side-by-side dll version", "version", ""], + "stub" => ["u", "u", "stub Windows dll", "version", ""], + "native" => ["N", "N", "native Windows dll", "version", ""], + "loaderror258" => ["I", "I", "timed out while getting the test list", "version", ""], # Other status values - "skipped" => ["-", "s", "skipped by user request", ""], - "crash" => ["C", "C", "crash", "t"], - "258" => ["T", "T", "timeout", "t"], + "skipped" => ["-", "s", "skipped by user request", "", ""], + "crash" => ["C", "C", "crash", "t", ""], + "258" => ["T", "T", "timeout", "t", ""], ); -# Returns a tuple containing the symbol, CSS class, title and link type -# for the specified status. -sub get_status_html($) +# Returns a tuple containing the symbol, CSS class, title, link type and +# HTML attributes for the specified status. +sub get_status_html($$) { - my ($status) = @_; + my ($status, $failcolors) = @_; return @{$status2html{$status}} if ($status2html{$status}); if ($status =~ /^[0-9]+$/) { - return ("F", "F", "$status failures", "t"); + return ("F", "F", "$status failures", "t", " style='background-color: $failcolors->{$status}'"); } if ($status =~ /^loaderror(.*)$/) { - return ("L", "L", "got error $1 while getting the test list", "version"); + return ("L", "L", "got error $1 while getting the test list", "version", ""); } - return ("?", "", "unknown status $status", "report"); + return ("?", "", "unknown status $status", "report", ""); } sub write_patterns_list($$) @@ -481,6 +541,8 @@ sub write_patterns_list($$) print $html "</div></div>\n"; + compute_set_colors($test->{colors}); + print $html "<div class='test'>\n"; foreach my $reportdir (@sortedreports) { @@ -519,7 +581,7 @@ sub write_patterns_list($$) } else { - ($symbol, $class, $title, my $link) = get_status_html($status); + ($symbol, $class, $title, my $link, $attrs) = get_status_html($status, $test->{colors}); if ($link eq "t") { $tag = "a"; @@ -606,17 +668,23 @@ EOF # Build a list of test units that will appear on this page so we can # link them to each other. my $testnames = []; - unit: foreach my $testname (sort keys %tests) + foreach my $testname (sort keys %tests) { my $test = $tests{$testname}; + my $addtest; foreach my $testreport (values %{$test->{testreports}}) { - if ($testreport->{failed}) + next if (!$testreport->{failed}); + $addtest = 1; + + foreach my $status (values %{$testreport->{status}}) { - push @$testnames, $testname; - next unit; + next if ($status !~ /^[0-9]+$/); + next if ($status eq "258"); # timeouts have their own color + $test->{colors}->{$status} = undef; } } + push @$testnames, $testname if ($addtest); } print $html "<h2>$title</h2>\n"; diff --git a/winetest/report.css b/winetest/report.css index cca1ba986..2cc466304 100644 --- a/winetest/report.css +++ b/winetest/report.css @@ -89,9 +89,7 @@ div.pattern :hover { color: black; text-decoration: underline; } .patC { /* crash */ background-color: #ff5555; } -.patF { /* failure(s) */ - background-color: #ff0000; -} +/* .patF failure(s) */ /* .patn not run for an unknown reason */ /* .patm missing dll */ .pate { /* missing entrypoint */ -- 2.20.1

1 1

[PATCH] reg/tests: Rework syntax tests for the 'copy' operation
by Hugh McMaster 28 Apr '21

28 Apr '21

Signed-off-by: Hugh McMaster <hugh.mcmaster(a)outlook.com> --- programs/reg/tests/copy.c | 32 +++++++++++++++----------------- 1 file changed, 15 insertions(+), 17 deletions(-) diff --git a/programs/reg/tests/copy.c b/programs/reg/tests/copy.c index a8956d7e9a0..31223a3d314 100644 --- a/programs/reg/tests/copy.c +++ b/programs/reg/tests/copy.c @@ -18,15 +18,12 @@ #include "reg_test.h" -#define COPY_DEST KEY_WINE "\\reg_copy" +#define COPY_SRC KEY_WINE "\\reg_copy" -static void test_copy(void) +static void test_command_syntax(void) { DWORD r; - delete_tree(HKEY_CURRENT_USER, KEY_BASE); - verify_key_nonexist(HKEY_CURRENT_USER, KEY_BASE); - run_reg_exe("reg copy", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); @@ -63,37 +60,38 @@ static void test_copy(void) run_reg_exe("reg copy /f /s", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy HKEY_CURRENT_USER\\" KEY_BASE " /f", &r); + run_reg_exe("reg copy HKCU\\" COPY_SRC " /f", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy HKEY_CURRENT_USER\\" KEY_BASE " foo /f", &r); + run_reg_exe("reg copy HKCU\\" COPY_SRC " foo /f", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy /f HKEY_CURRENT_USER\\" KEY_BASE " HKEY_CURRENT_USER\\" KEY_BASE, &r); + run_reg_exe("reg copy /f HKCU\\" COPY_SRC " HKCU\\" KEY_BASE, &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy /f HKEY_CURRENT_USER\\" KEY_BASE " HKEY_CURRENT_USER\\" COPY_DEST, &r); + run_reg_exe("reg copy HKCU\\" COPY_SRC " /f HKCU\\" KEY_BASE, &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy HKEY_CURRENT_USER\\" KEY_BASE " /f HKEY_CURRENT_USER\\" COPY_DEST, &r); + run_reg_exe("reg copy HKCU\\" COPY_SRC " /s HKCU\\" KEY_BASE, &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy HKEY_CURRENT_USER\\" KEY_BASE " /s HKEY_CURRENT_USER\\" COPY_DEST, &r); + run_reg_exe("reg copy HKCU\\" COPY_SRC " HKCU\\" KEY_BASE " /a", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy HKEY_CURRENT_USER\\" KEY_BASE " HKEY_CURRENT_USER\\" COPY_DEST " /a", &r); + run_reg_exe("reg copy HKCU\\" COPY_SRC " HKCU\\" KEY_BASE " /f /a", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy HKEY_CURRENT_USER\\" KEY_BASE " HKEY_CURRENT_USER\\" COPY_DEST " /f /a", &r); + run_reg_exe("reg copy HKCU\\" COPY_SRC " HKCU\\", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy HKEY_CURRENT_USER\\" KEY_BASE " HKEY_CURRENT_USER\\" KEY_BASE, &r); + /* Source and destination keys are the same */ + run_reg_exe("reg copy HKCU\\" COPY_SRC " HKCU\\" COPY_SRC, &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy HKEY_CURRENT_USER\\" KEY_BASE " HKEY_CURRENT_USER\\" KEY_BASE " /f", &r); + run_reg_exe("reg copy HKCU\\" COPY_SRC " HKCU\\" COPY_SRC " /f", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); - run_reg_exe("reg copy HKEY_CURRENT_USER\\" KEY_BASE " HKEY_CURRENT_USER\\" KEY_BASE " /s /f", &r); + run_reg_exe("reg copy HKCU\\" COPY_SRC " HKCU\\" COPY_SRC " /s /f", &r); ok(r == REG_EXIT_FAILURE, "got exit code %d, expected 1\n", r); } @@ -106,5 +104,5 @@ START_TEST(copy) return; } - test_copy(); + test_command_syntax(); } -- 2.31.1

1 0

[tools] winetest/build-index: Link the test unit pages to the failure patterns.
by Francois Gouget 28 Apr '21

28 Apr '21

Only for the test units that have failures in any of the buids / platforms since there is no pattern in case of success. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- The test pages will automatically be updated when the next report arrives. --- winetest/build-index | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/winetest/build-index b/winetest/build-index index 7eacb87f9..6a3356a25 100755 --- a/winetest/build-index +++ b/winetest/build-index @@ -259,6 +259,7 @@ foreach my $build (@too_old) # my %alltests = (); +my %haspattern = (); foreach my $build (@builds) { @@ -268,6 +269,10 @@ foreach my $build (@builds) chomp; my ($test, $group, $cell) = split / +/, $_, 3; $alltests{$test}->{$build->{name}}->{$group} = $cell; + if (!$haspattern{$test} and $cell =~ /result (?:fail|mixed)/) + { + $haspattern{$test} = 1; + } } close SUM; } @@ -294,6 +299,8 @@ foreach my $test (keys %alltests) { my $filename = "data/tests/$test.html"; open OUT, ">", "$filename.new" or die "could not open '$filename.new' for writing: $!"; + + my $title_link = $haspattern{$test} ? " | <a href=\"/data/patterns.html#$test\">failure patterns</a>" : ""; print OUT <<EOF; <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> @@ -312,7 +319,7 @@ EOF | <a href="..">index</a> </div> <div class="main"> -<h2>$test test runs</h2> +<h2>$test test runs$title_link</h2> <table class="report"> <thead> <tr><th class="test">Build</th><th class="test">Date</th> -- 2.20.1

1 0

[PATCH 1/5] reg: Consistently use 'hkey' for HKEY variables
by Hugh McMaster 28 Apr '21

28 Apr '21

Signed-off-by: Hugh McMaster <hugh.mcmaster(a)outlook.com> --- programs/reg/add.c | 18 +++++++++--------- programs/reg/delete.c | 16 ++++++++-------- programs/reg/export.c | 8 ++++---- programs/reg/query.c | 26 +++++++++++++------------- 4 files changed, 34 insertions(+), 34 deletions(-) diff --git a/programs/reg/add.c b/programs/reg/add.c index de22874b901..ff209bfc0ff 100644 --- a/programs/reg/add.c +++ b/programs/reg/add.c @@ -152,10 +152,10 @@ static LPBYTE get_regdata(const WCHAR *data, DWORD reg_type, WCHAR separator, DW static int run_add(HKEY root, WCHAR *path, WCHAR *value_name, BOOL value_empty, WCHAR *type, WCHAR separator, WCHAR *data, BOOL force) { - HKEY key; + HKEY hkey; if (RegCreateKeyExW(root, path, 0, NULL, REG_OPTION_NON_VOLATILE, - KEY_READ|KEY_WRITE, NULL, &key, NULL)) + KEY_READ|KEY_WRITE, NULL, &hkey, NULL)) { output_message(STRING_INVALID_KEY); return 1; @@ -169,11 +169,11 @@ static int run_add(HKEY root, WCHAR *path, WCHAR *value_name, BOOL value_empty, if (!force) { - if (RegQueryValueExW(key, value_name, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) + if (RegQueryValueExW(hkey, value_name, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) { if (!ask_confirm(STRING_OVERWRITE_VALUE, value_name)) { - RegCloseKey(key); + RegCloseKey(hkey); output_message(STRING_CANCELLED); return 0; } @@ -183,28 +183,28 @@ static int run_add(HKEY root, WCHAR *path, WCHAR *value_name, BOOL value_empty, reg_type = wchar_get_type(type); if (reg_type == ~0u) { - RegCloseKey(key); + RegCloseKey(hkey); output_message(STRING_UNSUPPORTED_TYPE, type); return 1; } if ((reg_type == REG_DWORD || reg_type == REG_DWORD_BIG_ENDIAN) && !data) { - RegCloseKey(key); + RegCloseKey(hkey); output_message(STRING_INVALID_CMDLINE); return 1; } if (!(reg_data = get_regdata(data, reg_type, separator, &reg_count))) { - RegCloseKey(key); + RegCloseKey(hkey); return 1; } - RegSetValueExW(key, value_name, 0, reg_type, reg_data, reg_count); + RegSetValueExW(hkey, value_name, 0, reg_type, reg_data, reg_count); free(reg_data); } - RegCloseKey(key); + RegCloseKey(hkey); output_message(STRING_SUCCESS); return 0; diff --git a/programs/reg/delete.c b/programs/reg/delete.c index db1ed0f5337..f8e62e490b9 100644 --- a/programs/reg/delete.c +++ b/programs/reg/delete.c @@ -21,7 +21,7 @@ static int run_delete(HKEY root, WCHAR *path, WCHAR *key_name, WCHAR *value_name, BOOL value_empty, BOOL value_all, BOOL force) { - HKEY key; + HKEY hkey; if (!force) { @@ -53,7 +53,7 @@ static int run_delete(HKEY root, WCHAR *path, WCHAR *key_name, WCHAR *value_name return 0; } - if (RegOpenKeyExW(root, path, 0, KEY_READ|KEY_SET_VALUE, &key)) + if (RegOpenKeyExW(root, path, 0, KEY_READ|KEY_SET_VALUE, &hkey)) { output_message(STRING_KEY_NONEXIST); return 1; @@ -70,14 +70,14 @@ static int run_delete(HKEY root, WCHAR *path, WCHAR *key_name, WCHAR *value_name while (1) { value_len = max_value_len; - rc = RegEnumValueW(key, 0, value_name, &value_len, NULL, NULL, NULL, NULL); + rc = RegEnumValueW(hkey, 0, value_name, &value_len, NULL, NULL, NULL, NULL); if (rc == ERROR_SUCCESS) { - rc = RegDeleteValueW(key, value_name); + rc = RegDeleteValueW(hkey, value_name); if (rc != ERROR_SUCCESS) { free(value_name); - RegCloseKey(key); + RegCloseKey(hkey); output_message(STRING_VALUEALL_FAILED, key_name); return 1; } @@ -93,15 +93,15 @@ static int run_delete(HKEY root, WCHAR *path, WCHAR *key_name, WCHAR *value_name } else if (value_name || value_empty) { - if (RegDeleteValueW(key, value_name)) + if (RegDeleteValueW(hkey, value_name)) { - RegCloseKey(key); + RegCloseKey(hkey); output_message(STRING_VALUE_NONEXIST); return 1; } } - RegCloseKey(key); + RegCloseKey(hkey); output_message(STRING_SUCCESS); return 0; } diff --git a/programs/reg/export.c b/programs/reg/export.c index 78331498406..79f6997ce35 100644 --- a/programs/reg/export.c +++ b/programs/reg/export.c @@ -225,7 +225,7 @@ static void export_key_name(HANDLE hFile, WCHAR *name) free(buf); } -static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path) +static int export_registry_data(HANDLE hFile, HKEY hkey, WCHAR *path) { LONG rc; DWORD max_value_len = 256, value_len; @@ -246,7 +246,7 @@ static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path) { value_len = max_value_len; data_size = max_data_bytes; - rc = RegEnumValueW(key, i, value_name, &value_len, NULL, &type, data, &data_size); + rc = RegEnumValueW(hkey, i, value_name, &value_len, NULL, &type, data, &data_size); if (rc == ERROR_SUCCESS) { @@ -280,11 +280,11 @@ static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path) for (;;) { subkey_len = MAX_SUBKEY_LEN; - rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL); + rc = RegEnumKeyExW(hkey, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL); if (rc == ERROR_SUCCESS) { subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len); - if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey)) + if (!RegOpenKeyExW(hkey, subkey_name, 0, KEY_READ, &subkey)) { export_registry_data(hFile, subkey, subkey_path); RegCloseKey(subkey); diff --git a/programs/reg/query.c b/programs/reg/query.c index 9d840c8947d..6485d36db6f 100644 --- a/programs/reg/query.c +++ b/programs/reg/query.c @@ -133,7 +133,7 @@ static void output_value(const WCHAR *value_name, DWORD type, BYTE *data, DWORD static unsigned int num_values_found = 0; -static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse) +static int query_value(HKEY hkey, WCHAR *value_name, WCHAR *path, BOOL recurse) { LONG rc; DWORD max_data_bytes = 2048, data_size; @@ -149,7 +149,7 @@ static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse) for (;;) { data_size = max_data_bytes; - rc = RegQueryValueExW(key, value_name, NULL, &type, data, &data_size); + rc = RegQueryValueExW(hkey, value_name, NULL, &type, data, &data_size); if (rc == ERROR_MORE_DATA) { max_data_bytes = data_size; @@ -191,11 +191,11 @@ static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse) for (;;) { subkey_len = MAX_SUBKEY_LEN; - rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL); + rc = RegEnumKeyExW(hkey, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL); if (rc == ERROR_SUCCESS) { subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len); - if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey)) + if (!RegOpenKeyExW(hkey, subkey_name, 0, KEY_READ, &subkey)) { query_value(subkey, value_name, subkey_path, recurse); RegCloseKey(subkey); @@ -210,7 +210,7 @@ static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse) return 0; } -static int query_all(HKEY key, WCHAR *path, BOOL recurse) +static int query_all(HKEY hkey, WCHAR *path, BOOL recurse) { LONG rc; DWORD max_value_len = 256, value_len; @@ -231,7 +231,7 @@ static int query_all(HKEY key, WCHAR *path, BOOL recurse) { value_len = max_value_len; data_size = max_data_bytes; - rc = RegEnumValueW(key, i, value_name, &value_len, NULL, &type, data, &data_size); + rc = RegEnumValueW(hkey, i, value_name, &value_len, NULL, &type, data, &data_size); if (rc == ERROR_SUCCESS) { output_value(value_name, type, data, data_size); @@ -267,13 +267,13 @@ static int query_all(HKEY key, WCHAR *path, BOOL recurse) for (;;) { subkey_len = MAX_SUBKEY_LEN; - rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL); + rc = RegEnumKeyExW(hkey, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL); if (rc == ERROR_SUCCESS) { if (recurse) { subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len); - if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey)) + if (!RegOpenKeyExW(hkey, subkey_name, 0, KEY_READ, &subkey)) { query_all(subkey, subkey_path, recurse); RegCloseKey(subkey); @@ -297,10 +297,10 @@ static int query_all(HKEY key, WCHAR *path, BOOL recurse) static int run_query(HKEY root, WCHAR *path, WCHAR *key_name, WCHAR *value_name, BOOL value_empty, BOOL recurse) { - HKEY key; + HKEY hkey; int ret; - if (RegOpenKeyExW(root, path, 0, KEY_READ, &key) != ERROR_SUCCESS) + if (RegOpenKeyExW(root, path, 0, KEY_READ, &hkey) != ERROR_SUCCESS) { output_message(STRING_KEY_NONEXIST); return 1; @@ -310,14 +310,14 @@ static int run_query(HKEY root, WCHAR *path, WCHAR *key_name, WCHAR *value_name, if (value_name || value_empty) { - ret = query_value(key, value_name, key_name, recurse); + ret = query_value(hkey, value_name, key_name, recurse); if (recurse) output_message(STRING_MATCHES_FOUND, num_values_found); } else - ret = query_all(key, key_name, recurse); + ret = query_all(hkey, key_name, recurse); - RegCloseKey(key); + RegCloseKey(hkey); return ret; } -- 2.31.1

1 4

[PATCH] po: Update Lithuanian translation
by Aurimas Fišeras 28 Apr '21

28 Apr '21

1 0

[PATCH 3/3] d3d10core/tests: Add a test for unbound input streams.
by Henri Verbeet 27 Apr '21

27 Apr '21

From: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d3d10core/tests/d3d10core.c | 86 ++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/dlls/d3d10core/tests/d3d10core.c b/dlls/d3d10core/tests/d3d10core.c index 927d79d90e9..ccddb401aed 100644 --- a/dlls/d3d10core/tests/d3d10core.c +++ b/dlls/d3d10core/tests/d3d10core.c @@ -18822,6 +18822,91 @@ static void test_dual_source_blend(void) release_test_context(&test_context); } +static void test_unbound_streams(void) +{ + struct d3d10core_test_context test_context; + ID3D10PixelShader *ps; + ID3D10Device *device; + HRESULT hr; + + static const DWORD vs_code[] = + { +#if 0 + struct vs_ps + { + float4 position : SV_POSITION; + float4 color : COLOR0; + }; + + vs_ps vs_main(float4 position : POSITION, float4 color : COLOR0) + { + vs_ps result; + result.position = position; + result.color = color; + result.color.w = 1.0; + return result; + } +#endif + 0x43425844, 0x4a9efaec, 0xe2c6cdf5, 0x15dd28a7, 0xae68e320, 0x00000001, 0x00000154, 0x00000003, + 0x0000002c, 0x0000007c, 0x000000d0, 0x4e475349, 0x00000048, 0x00000002, 0x00000008, 0x00000038, + 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x00000041, 0x00000000, 0x00000000, + 0x00000003, 0x00000001, 0x0000070f, 0x49534f50, 0x4e4f4954, 0x4c4f4300, 0xab00524f, 0x4e47534f, + 0x0000004c, 0x00000002, 0x00000008, 0x00000038, 0x00000000, 0x00000001, 0x00000003, 0x00000000, + 0x0000000f, 0x00000044, 0x00000000, 0x00000000, 0x00000003, 0x00000001, 0x0000000f, 0x505f5653, + 0x5449534f, 0x004e4f49, 0x4f4c4f43, 0xabab0052, 0x52444853, 0x0000007c, 0x00010040, 0x0000001f, + 0x0300005f, 0x001010f2, 0x00000000, 0x0300005f, 0x00101072, 0x00000001, 0x04000067, 0x001020f2, + 0x00000000, 0x00000001, 0x03000065, 0x001020f2, 0x00000001, 0x05000036, 0x001020f2, 0x00000000, + 0x00101e46, 0x00000000, 0x05000036, 0x00102072, 0x00000001, 0x00101246, 0x00000001, 0x05000036, + 0x00102082, 0x00000001, 0x00004001, 0x3f800000, 0x0100003e, + }; + + static const DWORD ps_code[] = + { +#if 0 + float4 ps_main(vs_ps input) : SV_TARGET + { + return input.color; + } +#endif + 0x43425844, 0xe2087fa6, 0xa35fbd95, 0x8e585b3f, 0x67890f54, 0x00000001, 0x000000f4, 0x00000003, + 0x0000002c, 0x00000080, 0x000000b4, 0x4e475349, 0x0000004c, 0x00000002, 0x00000008, 0x00000038, + 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000000f, 0x00000044, 0x00000000, 0x00000000, + 0x00000003, 0x00000001, 0x00000f0f, 0x505f5653, 0x5449534f, 0x004e4f49, 0x4f4c4f43, 0xabab0052, + 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, + 0x00000000, 0x0000000f, 0x545f5653, 0x45475241, 0xabab0054, 0x52444853, 0x00000038, 0x00000040, + 0x0000000e, 0x03001062, 0x001010f2, 0x00000001, 0x03000065, 0x001020f2, 0x00000000, 0x05000036, + 0x001020f2, 0x00000000, 0x00101e46, 0x00000001, 0x0100003e, + }; + + static const float white[4] = {1.0f, 1.0f, 1.0f, 1.0f}; + + static const D3D10_INPUT_ELEMENT_DESC layout_desc[] = + { + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 16, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }; + + if (!init_test_context(&test_context)) + return; + + device = test_context.device; + + hr = ID3D10Device_CreatePixelShader(device, ps_code, sizeof(ps_code), &ps); + ok(SUCCEEDED(hr), "Failed to create pixel shader, hr %#x.\n", hr); + + hr = ID3D10Device_CreateInputLayout(device, layout_desc, ARRAY_SIZE(layout_desc), + vs_code, sizeof(vs_code), &test_context.input_layout); + ok(SUCCEEDED(hr), "Failed to create input layout, hr %#x.\n", hr); + + ID3D10Device_PSSetShader(device, ps); + ID3D10Device_ClearRenderTargetView(device, test_context.backbuffer_rtv, white); + draw_quad_vs(&test_context, vs_code, sizeof(vs_code)); + check_texture_color(test_context.backbuffer, 0xff000000, 1); + + ID3D10PixelShader_Release(ps); + release_test_context(&test_context); +} + START_TEST(d3d10core) { unsigned int argc, i; @@ -18946,6 +19031,7 @@ START_TEST(d3d10core) queue_test(test_color_mask); queue_test(test_independent_blend); queue_test(test_dual_source_blend); + queue_test(test_unbound_streams); run_queued_tests(); -- 2.20.1

2 1

[PATCH 2/3] d3d11/tests: Add a test for unbound input streams.
by Henri Verbeet 27 Apr '21

27 Apr '21

From: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d3d11/tests/d3d11.c | 88 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index bf8837ab52c..ca60170d080 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -17157,6 +17157,93 @@ static void test_shader_stage_input_output_matching(void) release_test_context(&test_context); } +static void test_unbound_streams(void) +{ + struct d3d11_test_context test_context; + ID3D11DeviceContext *context; + ID3D11PixelShader *ps; + ID3D11Device *device; + HRESULT hr; + + static const DWORD vs_code[] = + { +#if 0 + struct vs_ps + { + float4 position : SV_POSITION; + float4 color : COLOR0; + }; + + vs_ps vs_main(float4 position : POSITION, float4 color : COLOR0) + { + vs_ps result; + result.position = position; + result.color = color; + result.color.w = 1.0; + return result; + } +#endif + 0x43425844, 0x4a9efaec, 0xe2c6cdf5, 0x15dd28a7, 0xae68e320, 0x00000001, 0x00000154, 0x00000003, + 0x0000002c, 0x0000007c, 0x000000d0, 0x4e475349, 0x00000048, 0x00000002, 0x00000008, 0x00000038, + 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x00000041, 0x00000000, 0x00000000, + 0x00000003, 0x00000001, 0x0000070f, 0x49534f50, 0x4e4f4954, 0x4c4f4300, 0xab00524f, 0x4e47534f, + 0x0000004c, 0x00000002, 0x00000008, 0x00000038, 0x00000000, 0x00000001, 0x00000003, 0x00000000, + 0x0000000f, 0x00000044, 0x00000000, 0x00000000, 0x00000003, 0x00000001, 0x0000000f, 0x505f5653, + 0x5449534f, 0x004e4f49, 0x4f4c4f43, 0xabab0052, 0x52444853, 0x0000007c, 0x00010040, 0x0000001f, + 0x0300005f, 0x001010f2, 0x00000000, 0x0300005f, 0x00101072, 0x00000001, 0x04000067, 0x001020f2, + 0x00000000, 0x00000001, 0x03000065, 0x001020f2, 0x00000001, 0x05000036, 0x001020f2, 0x00000000, + 0x00101e46, 0x00000000, 0x05000036, 0x00102072, 0x00000001, 0x00101246, 0x00000001, 0x05000036, + 0x00102082, 0x00000001, 0x00004001, 0x3f800000, 0x0100003e, + }; + + static const DWORD ps_code[] = + { +#if 0 + float4 ps_main(vs_ps input) : SV_TARGET + { + return input.color; + } +#endif + 0x43425844, 0xe2087fa6, 0xa35fbd95, 0x8e585b3f, 0x67890f54, 0x00000001, 0x000000f4, 0x00000003, + 0x0000002c, 0x00000080, 0x000000b4, 0x4e475349, 0x0000004c, 0x00000002, 0x00000008, 0x00000038, + 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000000f, 0x00000044, 0x00000000, 0x00000000, + 0x00000003, 0x00000001, 0x00000f0f, 0x505f5653, 0x5449534f, 0x004e4f49, 0x4f4c4f43, 0xabab0052, + 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, + 0x00000000, 0x0000000f, 0x545f5653, 0x45475241, 0xabab0054, 0x52444853, 0x00000038, 0x00000040, + 0x0000000e, 0x03001062, 0x001010f2, 0x00000001, 0x03000065, 0x001020f2, 0x00000000, 0x05000036, + 0x001020f2, 0x00000000, 0x00101e46, 0x00000001, 0x0100003e, + }; + + static const float white[4] = {1.0f, 1.0f, 1.0f, 1.0f}; + + static const D3D11_INPUT_ELEMENT_DESC layout_desc[] = + { + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 16, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }; + + if (!init_test_context(&test_context, NULL)) + return; + + device = test_context.device; + context = test_context.immediate_context; + + hr = ID3D11Device_CreatePixelShader(device, ps_code, sizeof(ps_code), NULL, &ps); + ok(SUCCEEDED(hr), "Failed to create pixel shader, hr %#x.\n", hr); + + hr = ID3D11Device_CreateInputLayout(device, layout_desc, ARRAY_SIZE(layout_desc), + vs_code, sizeof(vs_code), &test_context.input_layout); + ok(SUCCEEDED(hr), "Failed to create input layout, hr %#x.\n", hr); + + ID3D11DeviceContext_PSSetShader(context, ps, NULL, 0); + ID3D11DeviceContext_ClearRenderTargetView(context, test_context.backbuffer_rtv, white); + draw_quad_vs(&test_context, vs_code, sizeof(vs_code)); + check_texture_color(test_context.backbuffer, 0xff000000, 1); + + ID3D11PixelShader_Release(ps); + release_test_context(&test_context); +} + static void test_shader_interstage_interface(void) { struct d3d11_test_context test_context; @@ -32520,6 +32607,7 @@ START_TEST(d3d11) queue_test(test_deferred_context_state); queue_test(test_deferred_context_swap_state); queue_test(test_deferred_context_rendering); + queue_test(test_unbound_streams); run_queued_tests(); } -- 2.20.1

2 1

[PATCH 1/3] wined3d: Create null vertex bindings and attributes for unbound shader inputs.
by Henri Verbeet 27 Apr '21

27 Apr '21

From: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- Changes: - Use unsigned bit-masks. - Squash the first two patches in the series into this one. - Minor style changes. dlls/wined3d/context_vk.c | 84 ++++++++++++++++++++++++++++++++++++--- dlls/wined3d/device.c | 2 +- 2 files changed, 80 insertions(+), 6 deletions(-) diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index 8719d54644b..fbc1e294fcd 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -2004,19 +2004,36 @@ static void wined3d_context_vk_update_blend_state(const struct wined3d_context_v } } +static VkFormat vk_format_from_component_type(enum wined3d_component_type component_type) +{ + switch (component_type) + { + case WINED3D_TYPE_UINT: + return VK_FORMAT_R32G32B32A32_UINT; + case WINED3D_TYPE_INT: + return VK_FORMAT_R32G32B32A32_SINT; + case WINED3D_TYPE_UNKNOWN: + case WINED3D_TYPE_FLOAT: + return VK_FORMAT_R32G32B32A32_SFLOAT; + } + return VK_FORMAT_UNDEFINED; +} + static bool wined3d_context_vk_update_graphics_pipeline_key(struct wined3d_context_vk *context_vk, - const struct wined3d_state *state, VkPipelineLayout vk_pipeline_layout) + const struct wined3d_state *state, VkPipelineLayout vk_pipeline_layout, uint32_t *null_buffer_binding) { unsigned int i, attribute_count, binding_count, divisor_count, stage_count; const struct wined3d_d3d_info *d3d_info = context_vk->c.d3d_info; struct wined3d_graphics_pipeline_key_vk *key; VkPipelineShaderStageCreateInfo *stage; struct wined3d_stream_info stream_info; + struct wined3d_shader *vertex_shader; VkPrimitiveTopology vk_topology; VkShaderModule module; bool update = false; uint32_t mask; + *null_buffer_binding = ~0u; key = &context_vk->graphics.pipeline_key_vk; if (context_vk->c.shader_update_mask & ~(1u << WINED3D_SHADER_TYPE_COMPUTE)) @@ -2041,14 +2058,15 @@ static bool wined3d_context_vk_update_graphics_pipeline_key(struct wined3d_conte || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_STREAMSRC) || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX))) { + VkVertexInputAttributeDescription *a; + VkVertexInputBindingDescription *b; + wined3d_stream_info_from_declaration(&stream_info, state, d3d_info); divisor_count = 0; for (i = 0, mask = 0, attribute_count = 0, binding_count = 0; i < ARRAY_SIZE(stream_info.elements); ++i) { VkVertexInputBindingDivisorDescriptionEXT *d; struct wined3d_stream_info_element *e; - VkVertexInputAttributeDescription *a; - VkVertexInputBindingDescription *b; uint32_t binding; if (!(stream_info.use_map & (1u << i))) @@ -2080,6 +2098,55 @@ static bool wined3d_context_vk_update_graphics_pipeline_key(struct wined3d_conte } } + vertex_shader = state->shader[WINED3D_SHADER_TYPE_VERTEX]; + if (vertex_shader && (mask = ~stream_info.use_map & vertex_shader->reg_maps.input_registers)) + { + struct wined3d_shader_signature_element *element; + struct wined3d_shader_signature *signature; + uint32_t null_binding, location; + + for (i = 0; i < ARRAY_SIZE(state->streams); ++i) + { + if (!state->streams[i].buffer) + { + null_binding = i; + break; + } + } + + if (i == ARRAY_SIZE(state->streams)) + { + ERR("No streams left for a null buffer binding.\n"); + } + else + { + signature = &vertex_shader->input_signature; + for (i = 0; i < signature->element_count; ++i) + { + element = &signature->elements[i]; + location = element->register_idx; + + if (!(mask & (1u << location)) || element->sysval_semantic) + continue; + mask &= ~(1u << location); + + a = &key->attributes[attribute_count++]; + a->location = location; + a->binding = null_binding; + a->format = vk_format_from_component_type(element->component_type); + a->offset = 0; + } + + if (mask != (~stream_info.use_map & vertex_shader->reg_maps.input_registers)) + { + b = &key->bindings[binding_count++]; + *null_buffer_binding = b->binding = null_binding; + b->stride = 0; + b->inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + } + } + } + key->input_desc.pNext = NULL; key->input_desc.vertexBindingDescriptionCount = binding_count; key->input_desc.vertexAttributeDescriptionCount = attribute_count; @@ -2991,6 +3058,7 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c VkSampleCountFlagBits sample_count; VkCommandBuffer vk_command_buffer; struct wined3d_buffer *buffer; + uint32_t null_buffer_binding; unsigned int i; if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL)) @@ -3120,8 +3188,8 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c return VK_NULL_HANDLE; } - if (wined3d_context_vk_update_graphics_pipeline_key(context_vk, state, context_vk->graphics.vk_pipeline_layout) - || !context_vk->graphics.vk_pipeline) + if (wined3d_context_vk_update_graphics_pipeline_key(context_vk, state, context_vk->graphics.vk_pipeline_layout, + &null_buffer_binding) || !context_vk->graphics.vk_pipeline) { if (!(context_vk->graphics.vk_pipeline = wined3d_context_vk_get_graphics_pipeline(context_vk))) { @@ -3131,6 +3199,12 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c VK_CALL(vkCmdBindPipeline(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, context_vk->graphics.vk_pipeline)); + if (null_buffer_binding != ~0u) + { + VkDeviceSize offset = 0; + VK_CALL(vkCmdBindVertexBuffers(vk_command_buffer, null_buffer_binding, 1, + &device_vk->null_resources_vk.buffer_info.buffer, &offset)); + } } if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_STENCIL_REF) && dsv) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index bf4c37756a7..f3d7cff74bf 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -652,7 +652,7 @@ bool wined3d_device_vk_create_null_resources(struct wined3d_device_vk *device_vk vk_info = context_vk->vk_info; usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT - | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; + | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; memory_type = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; if (!wined3d_context_vk_create_bo(context_vk, 16, usage, memory_type, &r->bo)) return false; -- 2.20.1

1 0

[PATCH 1/5] include: Do not include winsock.h in winsock2.h.
by Zebediah Figura 27 Apr '21

27 Apr '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ws2_32/socket.c | 2 +- include/winsock.h | 139 +++---------- include/winsock2.h | 480 ++++++++++++++++++++++++++++++++++++++++++- include/ws2def.h | 160 +++++++++++++++ server/sock.c | 28 +-- 5 files changed, 661 insertions(+), 148 deletions(-) diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c index 262171ebab0..29464fb94c9 100644 --- a/dlls/ws2_32/socket.c +++ b/dlls/ws2_32/socket.c @@ -905,7 +905,7 @@ static const int ws_proto_map[][2] = MAP_OPTION( IPPROTO_ICMP ), MAP_OPTION( IPPROTO_IGMP ), MAP_OPTION( IPPROTO_RAW ), - MAP_OPTION( IPPROTO_IPIP ), + {WS_IPPROTO_IPV4, IPPROTO_IPIP}, {FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO}, }; diff --git a/include/winsock.h b/include/winsock.h index cafac1a1723..b8a7a4ec400 100644 --- a/include/winsock.h +++ b/include/winsock.h @@ -21,9 +21,7 @@ */ #ifdef __WINESRC__ -# ifndef __WINE_WINSOCK2__ -# error Please use Winsock2 in Wine -# endif +# error Please use winsock2 in Wine #endif #ifndef __WINE_WINSOCKAPI_STDLIB_H @@ -168,12 +166,7 @@ extern "C" { #define AF_FIREFOX 19 #define AF_UNKNOWN1 20 #define AF_BAN 21 -#define AF_ATM 22 -#define AF_INET6 23 -#define AF_CLUSTER 24 -#define AF_12844 25 -#define AF_IRDA 26 -#define AF_MAX 27 +#define AF_MAX 22 #define PF_UNSPEC AF_UNSPEC #define PF_UNIX AF_UNIX #define PF_INET AF_INET @@ -223,12 +216,7 @@ extern "C" { #define WS_AF_FIREFOX 19 #define WS_AF_UNKNOWN1 20 #define WS_AF_BAN 21 -#define WS_AF_ATM 22 -#define WS_AF_INET6 23 -#define WS_AF_CLUSTER 24 -#define WS_AF_12844 25 -#define WS_AF_IRDA 26 -#define WS_AF_MAX 27 +#define WS_AF_MAX 22 #endif /* USE_WS_PREFIX */ /* @@ -257,12 +245,9 @@ extern "C" { #define IPPROTO_ICMP 1 #define IPPROTO_IGMP 2 #define IPPROTO_GGP 3 -#define IPPROTO_IPIP 4 #define IPPROTO_TCP 6 #define IPPROTO_UDP 17 #define IPPROTO_IDP 22 -#define IPPROTO_IPV6 41 -#define IPPROTO_ICMPV6 58 #define IPPROTO_ND 77 #define IPPROTO_RAW 255 #define IPPROTO_MAX 256 @@ -271,12 +256,9 @@ extern "C" { #define WS_IPPROTO_ICMP 1 #define WS_IPPROTO_IGMP 2 #define WS_IPPROTO_GGP 3 -#define WS_IPPROTO_IPIP 4 #define WS_IPPROTO_TCP 6 #define WS_IPPROTO_UDP 17 #define WS_IPPROTO_IDP 22 -#define WS_IPPROTO_IPV6 41 -#define WS_IPPROTO_ICMPV6 58 #define WS_IPPROTO_ND 77 #define WS_IPPROTO_RAW 255 #define WS_IPPROTO_MAX 256 @@ -468,32 +450,11 @@ typedef struct WS(timeval) } \ } \ } while(0) -#define __WS_FD_SET1(fd, set, cast) do { \ + +#define __WS_FD_SET(fd, set, cast) do { \ if (((cast*)(set))->fd_count < FD_SETSIZE) \ ((cast*)(set))->fd_array[((cast*)(set))->fd_count++]=(fd); \ } while(0) -/* This version checks if the filedesc is already in the list, and appends it - * only if it's not the case - */ -#define __WS_FD_SET2(fd, set, cast) do { \ - unsigned int __i; \ - for (__i = 0; __i < ((cast*)(set))->fd_count ; __i++) \ - { \ - if (((cast*)(set))->fd_array[__i]==(fd)) \ - break; \ - } \ - if (__i == ((cast*)(set))->fd_count && ((cast*)(set))->fd_count < FD_SETSIZE) \ - { \ - ((cast*)(set))->fd_count++; \ - ((cast*)(set))->fd_array[__i]=(fd);\ - } \ -} while(0) - -#ifndef __WINE_WINSOCK2__ -#define __WS_FD_SET(fd, set, cast) __WS_FD_SET1((fd),(set), cast) -#else -#define __WS_FD_SET(fd, set, cast) __WS_FD_SET2((fd),(set), cast) -#endif #ifndef USE_WS_PREFIX #define FD_CLR(fd, set) __WS_FD_CLR((fd),(set), fd_set) @@ -613,13 +574,11 @@ typedef struct WS(sockaddr_in) * Multicast group information */ -#if !defined(__WINE_WINSOCK2__) struct WS(ip_mreq) { struct WS(in_addr) imr_multiaddr; struct WS(in_addr) imr_interface; }; -#endif /* * WSAStartup @@ -672,12 +631,6 @@ typedef struct WS(WSAData) #define SO_RCVTIMEO 0x1006 #define SO_ERROR 0x1007 #define SO_TYPE 0x1008 -#define SO_BSP_STATE 0x1009 - -#define SO_RANDOMIZE_PORT 0x3005 -#define SO_PORT_SCALABILITY 0x3006 -#define SO_REUSE_UNICASTPORT 0x3007 -#define SO_REUSE_MULTICASTPORT 0x3008 #define IOCPARM_MASK 0x7f #define IOC_VOID 0x20000000 @@ -711,12 +664,6 @@ typedef struct WS(WSAData) #define WS_SO_RCVTIMEO 0x1006 #define WS_SO_ERROR 0x1007 #define WS_SO_TYPE 0x1008 -#define WS_SO_BSP_STATE 0x1009 - -#define WS_SO_RANDOMIZE_PORT 0x3005 -#define WS_SO_PORT_SCALABILITY 0x3006 -#define WS_SO_REUSE_UNICASTPORT 0x3007 -#define WS_SO_REUSE_MULTICASTPORT 0x3008 #define WS_IOCPARM_MASK 0x7f #define WS_IOC_VOID 0x20000000 @@ -737,31 +684,26 @@ typedef struct WS(WSAData) #define WS_TCP_NODELAY 1 #endif -/* IPPROTO_IP options */ -#ifndef __WINE_WINSOCK2__ /* WinSock2 has different values for the IP_ constants */ -# ifndef USE_WS_PREFIX -# define IP_OPTIONS 1 -# define IP_MULTICAST_IF 2 -# define IP_MULTICAST_TTL 3 -# define IP_MULTICAST_LOOP 4 -# define IP_ADD_MEMBERSHIP 5 -# define IP_DROP_MEMBERSHIP 6 -# define IP_TTL 7 -# define IP_TOS 8 -# define IP_DONTFRAGMENT 9 -# define IP_RECEIVE_BROADCAST 22 -# else -# define WS_IP_OPTIONS 1 -# define WS_IP_MULTICAST_IF 2 -# define WS_IP_MULTICAST_TTL 3 -# define WS_IP_MULTICAST_LOOP 4 -# define WS_IP_ADD_MEMBERSHIP 5 -# define WS_IP_DROP_MEMBERSHIP 6 -# define WS_IP_TTL 7 -# define WS_IP_TOS 8 -# define WS_IP_DONTFRAGMENT 9 -# define WS_IP_RECEIVE_BROADCAST 22 -# endif +#ifndef USE_WS_PREFIX +# define IP_OPTIONS 1 +# define IP_MULTICAST_IF 2 +# define IP_MULTICAST_TTL 3 +# define IP_MULTICAST_LOOP 4 +# define IP_ADD_MEMBERSHIP 5 +# define IP_DROP_MEMBERSHIP 6 +# define IP_TTL 7 +# define IP_TOS 8 +# define IP_DONTFRAGMENT 9 +#else +# define WS_IP_OPTIONS 1 +# define WS_IP_MULTICAST_IF 2 +# define WS_IP_MULTICAST_TTL 3 +# define WS_IP_MULTICAST_LOOP 4 +# define WS_IP_ADD_MEMBERSHIP 5 +# define WS_IP_DROP_MEMBERSHIP 6 +# define WS_IP_TTL 7 +# define WS_IP_TOS 8 +# define WS_IP_DONTFRAGMENT 9 #endif @@ -797,8 +739,6 @@ typedef struct WS(WSAData) #define MSG_OOB 0x0001 #define MSG_PEEK 0x0002 #define MSG_DONTROUTE 0x0004 -#define MSG_WAITALL 0x0008 -#define MSG_INTERRUPT 0x0010 #define MSG_PARTIAL 0x8000 #define MSG_MAXIOVLEN 16 #else /* USE_WS_PREFIX */ @@ -807,8 +747,6 @@ typedef struct WS(WSAData) #define WS_MSG_OOB 0x0001 #define WS_MSG_PEEK 0x0002 #define WS_MSG_DONTROUTE 0x0004 -#define WS_MSG_WAITALL 0x0008 -#define WS_MSG_INTERRUPT 0x0010 #define WS_MSG_PARTIAL 0x8000 #define WS_MSG_MAXIOVLEN 16 #endif /* USE_WS_PREFIX */ @@ -833,15 +771,6 @@ typedef struct WS(WSAData) #define FD_CONNECT 0x00000010 #define FD_CLOSE 0x00000020 -/* internal per-socket flags */ -#ifdef __WINESRC__ -#define FD_WINE_LISTENING 0x10000000 -#define FD_WINE_NONBLOCKING 0x20000000 -#define FD_WINE_CONNECTED 0x40000000 -#define FD_WINE_RAW 0x80000000 -#define FD_WINE_INTERNAL 0xFFFF0000 -#endif - /* * All Windows Sockets error constants are biased by WSABASEERR from * the "normal". They are also defined in winerror.h. @@ -905,17 +834,6 @@ typedef struct WS(WSAData) #define WSAVERNOTSUPPORTED (WSABASEERR+92) #define WSANOTINITIALISED (WSABASEERR+93) #define WSAEDISCON (WSABASEERR+101) -#define WSAENOMORE (WSABASEERR+102) -#define WSAECANCELLED (WSABASEERR+103) -#define WSAEINVALIDPROCTABLE (WSABASEERR+104) -#define WSAEINVALIDPROVIDER (WSABASEERR+105) -#define WSAEPROVIDERFAILEDINIT (WSABASEERR+106) -#define WSASYSCALLFAILURE (WSABASEERR+107) -#define WSASERVICE_NOT_FOUND (WSABASEERR+108) -#define WSATYPE_NOT_FOUND (WSABASEERR+109) -#define WSA_E_NO_MORE (WSABASEERR+110) -#define WSA_E_CANCELLED (WSABASEERR+111) -#define WSAEREFUSED (WSABASEERR+112) /* * Error return codes from gethostbyname() and gethostbyaddr() @@ -1007,7 +925,6 @@ typedef struct WS(WSAData) * Remember to keep this section in sync with the * "Winsock Function Typedefs" section in winsock2.h. */ -#if !defined(__WINE_WINSOCK2__) || WS_API_PROTOTYPES HANDLE WINAPI WSAAsyncGetHostByAddr(HWND,WS(u_int),const char*,int,int,char*,int); HANDLE WINAPI WSAAsyncGetHostByName(HWND,WS(u_int),const char*,char*,int); HANDLE WINAPI WSAAsyncGetProtoByName(HWND,WS(u_int),const char*,char*,int); @@ -1058,16 +975,10 @@ SOCKET WINAPI WS(socket)(int,int,int); int WINAPI WS(gethostname)(char*,int); #endif -#endif /* !defined(__WINE_WINSOCK2__) || WS_API_PROTOTYPES */ - #ifdef __cplusplus } #endif -#ifndef __WINE_WINSOCK2__ #undef WS -#undef WS_API_PROTOTYPES -#undef WS_API_TYPEDEFS -#endif #endif /* _WINSOCKAPI_ */ diff --git a/include/winsock2.h b/include/winsock2.h index 1935c99ad40..8739cedcbc6 100644 --- a/include/winsock2.h +++ b/include/winsock2.h @@ -17,13 +17,118 @@ * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - * - * FIXME: Still missing required Winsock 2 definitions. */ +#ifndef __WINE_WINSOCKAPI_STDLIB_H +#define __WINE_WINSOCKAPI_STDLIB_H + +/* + * This section defines the items that conflict with the Unix headers. + */ +#ifndef USE_WS_PREFIX +/* We are not using the WS_ prefix we risk getting conflicts for + * everything related to select. + */ +# ifdef FD_CLR +/* Too late, the Unix version of stdlib.h was included before winsock.h. + * This means select and all the related stuff is already defined and we + * cannot override types and function prototypes. + * All we can do is disable all these symbols so that they are not used + * inadvertently. + */ +# include <sys/types.h> +# undef FD_SETSIZE +# undef FD_CLR +# undef FD_SET +# undef FD_ZERO +# undef FD_ISSET + +# define FD_SETSIZE Include_winsock_h_before_stdlib_h_or_use_the_MSVCRT_library +# define FD_CLR Include_winsock_h_before_stdlib_h_or_use_the_MSVCRT_library +# define FD_SET Include_winsock_h_before_stdlib_h_or_use_the_MSVCRT_library +# define FD_ZERO Include_winsock_h_before_stdlib_h_or_use_the_MSVCRT_library +# define FD_ISSET Include_winsock_h_before_stdlib_h_or_use_the_MSVCRT_library +# define fd_set Include_winsock_h_before_stdlib_h_or_use_the_MSVCRT_library +# define select Include_winsock_h_before_stdlib_h_or_use_the_MSVCRT_library +# elif defined(RLIM_INFINITY) +/* On Darwin stdlib.h includes sys/resource.h which defines timeval but not the fd_set macros */ +# define fd_set unix_fd_set +# include <sys/types.h> +# include <time.h> +# include <stdlib.h> +# undef fd_set +# undef FD_SETSIZE +# undef FD_CLR +# undef FD_SET +# undef FD_ZERO +# undef FD_ISSET +# define select Include_winsock_h_before_sys_types_h_or_use_the_MSVCRT_library +# define timeval Include_winsock_h_before_sys_types_h_or_use_the_MSVCRT_library +# else /* FD_CLR */ +/* stdlib.h has not been included yet so it's not too late. Include it now + * making sure that none of the select symbols is affected. Then we can + * define them with our own values. + */ +# define fd_set unix_fd_set +# define timeval unix_timeval +# define select unix_select +# define socklen_t unix_socklen_t +# define u_long unix_u_long +# include <sys/types.h> +# include <time.h> +# include <stdlib.h> +# undef fd_set +# undef timeval +# undef select +# undef socklen_t +# undef u_long +# undef FD_SETSIZE +# undef FD_CLR +# undef FD_SET +# undef FD_ZERO +# undef FD_ISSET +# undef _TIMEVAL_DEFINED + +# define WS_DEFINE_SELECT +# endif /* FD_CLR */ + +#else +# define WS_DEFINE_SELECT +# include <sys/types.h> +# include <stdlib.h> +#endif /* !USE_WS_PREFIX */ + +#endif /* __WINE_WINSOCKAPI_STDLIB_H */ + #ifndef _WINSOCK2API_ #define _WINSOCK2API_ +#include <windows.h> + +#ifdef USE_WS_PREFIX +# define WS(x) WS_##x +#else +# define WS(x) x +#endif + +#ifdef USE_WS_PREFIX +typedef unsigned char WS_u_char; +typedef unsigned short WS_u_short; +typedef unsigned int WS_u_int; +typedef ULONG WS_u_long; +#elif (defined(_MSC_VER) || defined(__MINGW32__) || defined(__WATCOMC__)) && !defined(_BSDTYPES_DEFINED) +/* MinGW doesn't define the u_xxx types */ +typedef unsigned char u_char; +typedef unsigned short u_short; +typedef unsigned int u_int; +typedef ULONG u_long; +#define _BSDTYPES_DEFINED +#else +#define u_long ULONG /* make sure we don't use the system u_long */ +#endif + +typedef UINT_PTR SOCKET; + /* * Setup phase */ @@ -43,18 +148,36 @@ #define WS_API_TYPEDEFS INCL_WINSOCK_API_TYPEDEFS #endif -#define __WINE_WINSOCK2__ -#include <winsock.h> -#undef __WINE_WINSOCK2__ - #include <ws2def.h> #ifdef __cplusplus extern "C" { #endif /* defined(__cplusplus) */ +#define INVALID_SOCKET (SOCKET)(~0) +#define SOCKET_ERROR (-1) #ifndef USE_WS_PREFIX +#define SOL_SOCKET 0xffff +#define SO_DEBUG 0x0001 +#define SO_ACCEPTCONN 0x0002 +#define SO_REUSEADDR 0x0004 +#define SO_EXCLUSIVEADDRUSE ((u_int)(~SO_REUSEADDR)) +#define SO_KEEPALIVE 0x0008 +#define SO_DONTROUTE 0x0010 +#define SO_BROADCAST 0x0020 +#define SO_USELOOPBACK 0x0040 +#define SO_LINGER 0x0080 +#define SO_OOBINLINE 0x0100 +#define SO_DONTLINGER ((u_int)(~SO_LINGER)) +#define SO_SNDBUF 0x1001 +#define SO_RCVBUF 0x1002 +#define SO_SNDLOWAT 0x1003 +#define SO_RCVLOWAT 0x1004 +#define SO_SNDTIMEO 0x1005 +#define SO_RCVTIMEO 0x1006 +#define SO_ERROR 0x1007 +#define SO_TYPE 0x1008 #define SO_GROUP_ID 0x2001 #define SO_GROUP_PRIORITY 0x2002 #define SO_MAX_MSG_SIZE 0x2003 @@ -64,6 +187,26 @@ extern "C" { #define PVD_CONFIG 0x3001 #define SO_CONDITIONAL_ACCEPT 0x3002 #else +#define WS_SOL_SOCKET 0xffff +#define WS_SO_DEBUG 0x0001 +#define WS_SO_ACCEPTCONN 0x0002 +#define WS_SO_REUSEADDR 0x0004 +#define WS_SO_EXCLUSIVEADDRUSE ((WS_u_int)(~WS_SO_REUSEADDR)) +#define WS_SO_KEEPALIVE 0x0008 +#define WS_SO_DONTROUTE 0x0010 +#define WS_SO_BROADCAST 0x0020 +#define WS_SO_USELOOPBACK 0x0040 +#define WS_SO_LINGER 0x0080 +#define WS_SO_OOBINLINE 0x0100 +#define WS_SO_DONTLINGER ((WS_u_int)(~WS_SO_LINGER)) +#define WS_SO_SNDBUF 0x1001 +#define WS_SO_RCVBUF 0x1002 +#define WS_SO_SNDLOWAT 0x1003 +#define WS_SO_RCVLOWAT 0x1004 +#define WS_SO_SNDTIMEO 0x1005 +#define WS_SO_RCVTIMEO 0x1006 +#define WS_SO_ERROR 0x1007 +#define WS_SO_TYPE 0x1008 #define WS_SO_GROUP_ID 0x2001 #define WS_SO_GROUP_PRIORITY 0x2002 #define WS_SO_MAX_MSG_SIZE 0x2003 @@ -95,7 +238,31 @@ extern "C" { /* protocol families */ #ifndef USE_WS_PREFIX +#define PF_APPLETALK AF_APPLETALK +#define PF_BAN AF_BAN +#define PF_CCITT AF_CCITT +#define PF_CHAOS AF_CHAOS +#define PF_DATAKIT AF_DATAKIT +#define PF_DECnet AF_DECnet +#define PF_DLI AF_DLI +#define PF_ECMA AF_ECMA +#define PF_FIREFOX AF_FIREFOX +#define PF_HYLINK AF_HYLINK +#define PF_IMPLINK AF_IMPLINK +#define PF_INET AF_INET #define PF_INET6 AF_INET6 +#define PF_IPX AF_IPX +#define PF_ISO AF_ISO +#define PF_LAT AF_LAT +#define PF_MAX AF_MAX +#define PF_NS AF_NS +#define PF_OSI AF_OSI +#define PF_PUP AF_PUP +#define PF_SNA AF_SNA +#define PF_UNIX AF_UNIX +#define PF_UNKNOWN1 AF_UNKNOWN1 +#define PF_UNSPEC AF_UNSPEC +#define PF_VOICEVIEW AF_VOICEVIEW #endif /* option flags per socket */ @@ -112,11 +279,23 @@ extern "C" { #define FD_ROUTING_INTERFACE_CHANGE_BIT 8 #define FD_ADDRESS_LIST_CHANGE_BIT 9 +#define FD_READ 0x00000001 +#define FD_WRITE 0x00000002 +#define FD_OOB 0x00000004 +#define FD_ACCEPT 0x00000008 +#define FD_CONNECT 0x00000010 +#define FD_CLOSE 0x00000020 #define FD_QOS 0x00000040 #define FD_GROUP_QOS 0x00000080 #define FD_ROUTING_INTERFACE_CHANGE 0x00000100 #define FD_ADDRESS_LIST_CHANGE 0x00000200 +#ifdef __WINESRC__ +#define FD_WINE_LISTENING 0x10000000 +#define FD_WINE_NONBLOCKING 0x20000000 +#define FD_WINE_CONNECTED 0x40000000 +#endif + /* Constants for LPCONDITIONPROC */ #define CF_ACCEPT 0x0000 #define CF_REJECT 0x0001 @@ -164,10 +343,22 @@ extern "C" { #define WS_IOC_OUT 0x40000000 #define WS_IOC_IN 0x80000000 #define WS_IOC_INOUT (WS_IOC_IN|WS_IOC_OUT) +#define WS_IOCPARM_MASK 0x7f +#define WS__IO(x,y) (WS_IOC_VOID | ((x) << 8) | (y)) +#define WS__IOR(x,y,t) (WS_IOC_OUT | (((UINT)sizeof(t) & WS_IOCPARM_MASK) << 16) | ((x) << 8) | (y)) +#define WS__IOW(x,y,t) (WS_IOC_IN | (((UINT)sizeof(t) & WS_IOCPARM_MASK) << 16) | ((x) << 8) | (y)) #define _WSAIO(x,y) (WS_IOC_VOID|(x)|(y)) #define _WSAIOR(x,y) (WS_IOC_OUT|(x)|(y)) #define _WSAIOW(x,y) (WS_IOC_IN|(x)|(y)) #define _WSAIORW(x,y) (WS_IOC_INOUT|(x)|(y)) +#define WS_FIONREAD WS__IOR('f', 127, ULONG) +#define WS_FIONBIO WS__IOW('f', 126, ULONG) +#define WS_FIOASYNC WS__IOW('f', 125, ULONG) +#define WS_SIOCSHIWAT WS__IOW('s', 0, ULONG) +#define WS_SIOCGHIWAT WS__IOR('s', 1, ULONG) +#define WS_SIOCSLOWAT WS__IOW('s', 2, ULONG) +#define WS_SIOCGLOWAT WS__IOR('s', 3, ULONG) +#define WS_SIOCATMARK WS__IOR('s', 7, ULONG) #define WS_SIO_ASSOCIATE_HANDLE _WSAIOW(WS_IOC_WS2,1) #define WS_SIO_ENABLE_CIRCULAR_QUEUEING _WSAIO(WS_IOC_WS2,2) #define WS_SIO_FIND_ROUTE _WSAIOR(WS_IOC_WS2,3) @@ -200,10 +391,22 @@ extern "C" { #define IOC_OUT 0x40000000 #define IOC_IN 0x80000000 #define IOC_INOUT (IOC_IN|IOC_OUT) +#define IOCPARM_MASK 0x7f +#define _IO(x,y) (IOC_VOID | ((x) << 8) | (y)) +#define _IOR(x,y,t) (IOC_OUT | (((UINT)sizeof(t) & IOCPARM_MASK) << 16) | ((x) << 8) | (y)) +#define _IOW(x,y,t) (IOC_IN | (((UINT)sizeof(t) & IOCPARM_MASK) << 16) | ((x) << 8) | (y)) #define _WSAIO(x,y) (IOC_VOID|(x)|(y)) #define _WSAIOR(x,y) (IOC_OUT|(x)|(y)) #define _WSAIOW(x,y) (IOC_IN|(x)|(y)) #define _WSAIORW(x,y) (IOC_INOUT|(x)|(y)) +#define FIONREAD _IOR('f', 127, ULONG) +#define FIONBIO _IOW('f', 126, ULONG) +#define FIOASYNC _IOW('f', 125, ULONG) +#define SIOCSHIWAT _IOW('s', 0, ULONG) +#define SIOCGHIWAT _IOR('s', 1, ULONG) +#define SIOCSLOWAT _IOW('s', 2, ULONG) +#define SIOCGLOWAT _IOR('s', 3, ULONG) +#define SIOCATMARK _IOR('s', 7, ULONG) #define SIO_ASSOCIATE_HANDLE _WSAIOW(IOC_WS2,1) #define SIO_ENABLE_CIRCULAR_QUEUEING _WSAIO(IOC_WS2,2) #define SIO_FIND_ROUTE _WSAIOR(IOC_WS2,3) @@ -225,6 +428,28 @@ extern "C" { #define SIO_GET_INTERFACE_LIST _IOR ('t', 127, ULONG) #endif /* USE_WS_PREFIX */ +#ifndef USE_WS_PREFIX +#define SOMAXCONN 0x7fffffff + +#define MSG_OOB 0x0001 +#define MSG_PEEK 0x0002 +#define MSG_DONTROUTE 0x0004 +#define MSG_WAITALL 0x0008 +#define MSG_INTERRUPT 0x0010 +#define MSG_PARTIAL 0x8000 +#define MSG_MAXIOVLEN 16 +#else /* USE_WS_PREFIX */ +#define WS_SOMAXCONN 0x7fffffff + +#define WS_MSG_OOB 0x0001 +#define WS_MSG_PEEK 0x0002 +#define WS_MSG_DONTROUTE 0x0004 +#define WS_MSG_WAITALL 0x0008 +#define WS_MSG_INTERRUPT 0x0010 +#define WS_MSG_PARTIAL 0x8000 +#define WS_MSG_MAXIOVLEN 16 +#endif /* USE_WS_PREFIX */ + /* Constants for WSAIoctl() */ #define WSA_FLAG_OVERLAPPED 0x0001 #define WSA_FLAG_MULTIPOINT_C_ROOT 0x0002 @@ -284,6 +509,8 @@ extern "C" { #include <guiddef.h> #endif +#define MAXGETHOSTSTRUCT 1024 + #define MAX_PROTOCOL_CHAIN 7 #define BASE_PROTOCOL 1 #define LAYERED_PROTOCOL 0 @@ -328,6 +555,81 @@ typedef struct _WSAPROTOCOLCHAIN #define SECURITY_PROTOCOL_NONE 0x0000 +#ifndef _TIMEVAL_DEFINED +#define _TIMEVAL_DEFINED +typedef struct WS(timeval) +{ + LONG tv_sec; + LONG tv_usec; +} TIMEVAL, *PTIMEVAL, *LPTIMEVAL; +#endif + +#ifdef WS_DEFINE_SELECT + +#define __WS_FD_CLR(fd, set, cast) do { \ + unsigned int __i; \ + for (__i = 0; __i < ((cast*)(set))->fd_count; __i++) \ + { \ + if (((cast*)(set))->fd_array[__i] == fd) \ + { \ + while (__i < ((cast*)(set))->fd_count-1) \ + { \ + ((cast*)(set))->fd_array[__i] = \ + ((cast*)(set))->fd_array[__i+1]; \ + __i++; \ + } \ + ((cast*)(set))->fd_count--; \ + break; \ + } \ + } \ +} while (0) + +#define __WS_FD_SET(fd, set, cast) do { \ + unsigned int __i; \ + for (__i = 0; __i < ((cast*)(set))->fd_count; __i++) \ + { \ + if (((cast*)(set))->fd_array[__i] == (fd)) \ + break; \ + } \ + if (__i == ((cast*)(set))->fd_count && ((cast*)(set))->fd_count < FD_SETSIZE) \ + { \ + ((cast*)(set))->fd_count++; \ + ((cast*)(set))->fd_array[__i]=(fd);\ + } \ +} while (0) + +#ifndef USE_WS_PREFIX + +# ifndef FD_SETSIZE +# define FD_SETSIZE 64 +# endif + +# define FD_CLR(fd, set) __WS_FD_CLR((fd), (set), fd_set) +# define FD_SET(fd, set) __WS_FD_SET((fd), (set), fd_set) +# define FD_ZERO(set) (((fd_set*)(set))->fd_count=0) +# define FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (fd_set*)(set)) + +#else + +# ifndef WS_FD_SETSIZE +# define WS_FD_SETSIZE 64 +# endif + +# define WS_FD_CLR(fd, set) __WS_FD_CLR((fd), (set), WS_fd_set) +# define WS_FD_SET(fd, set) __WS_FD_SET((fd), (set), WS_fd_set) +# define WS_FD_ZERO(set) (((WS_fd_set*)(set))->fd_count=0) +# define WS_FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (WS_fd_set*)(set)) + +#endif + +typedef struct WS(fd_set) +{ + WS(u_int) fd_count; + SOCKET fd_array[WS(FD_SETSIZE)]; +} WS(fd_set), FD_SET, *PFD_SET, *LPFD_SET; + +#endif + typedef struct /*WS(pollfd)*/ { SOCKET fd; @@ -335,6 +637,42 @@ typedef struct /*WS(pollfd)*/ SHORT revents; } WSAPOLLFD; +typedef struct WS(hostent) +{ + char *h_name; + char **h_aliases; + short h_addrtype; + short h_length; + char **h_addr_list; +#define h_addr h_addr_list[0] +} HOSTENT, *PHOSTENT, *LPHOSTENT; + +typedef struct WS(servent) +{ + char *s_name; + char **s_aliases; +#ifdef _WIN64 + char *s_proto; + short s_port; +#else + short s_port; + char *s_proto; +#endif +} SERVENT, *PSERVENT, *LPSERVENT; + +typedef struct WS(protoent) +{ + char *p_name; + char **p_aliases; + short p_proto; +} PROTOENT, *PPROTOENT, *LPPROTOENT; + +typedef struct WS(linger) +{ + WS(u_short) l_onoff; + WS(u_short) l_linger; +} LINGER, *PLINGER, *LPLINGER; + #define WSAPROTOCOL_LEN 255 typedef struct _WSAPROTOCOL_INFOA { @@ -441,6 +779,17 @@ DECL_WINELIB_TYPE_AW(LPWSASERVICECLASSINFO) #define WSAOVERLAPPED OVERLAPPED typedef struct _OVERLAPPED* LPWSAOVERLAPPED; +#ifndef USE_WS_PREFIX +#define h_errno WSAGetLastError() +#else +#define WS_h_errno WSAGetLastError() +#endif + +#define WSAHOST_NOT_FOUND (WSABASEERR + 1001) +#define WSATRY_AGAIN (WSABASEERR + 1002) +#define WSANO_RECOVERY (WSABASEERR + 1003) +#define WSANO_DATA (WSABASEERR + 1004) + #define WSA_IO_PENDING (ERROR_IO_PENDING) #define WSA_IO_INCOMPLETE (ERROR_IO_INCOMPLETE) #define WSA_INVALID_HANDLE (ERROR_INVALID_HANDLE) @@ -628,6 +977,75 @@ typedef struct _WSACOMPLETION { } Parameters; } WSACOMPLETION, *PWSACOMPLETION, *LPWSACOMPLETION; +#define WSADESCRIPTION_LEN 256 +#define WSASYS_STATUS_LEN 128 + +typedef struct WSAData +{ + WORD wVersion; + WORD wHighVersion; +#ifdef _WIN64 + WORD iMaxSockets; + WORD iMaxUdpDg; + char *lpVendorInfo; + char szDescription[WSADESCRIPTION_LEN+1]; + char szSystemStatus[WSASYS_STATUS_LEN+1]; +#else + char szDescription[WSADESCRIPTION_LEN+1]; + char szSystemStatus[WSASYS_STATUS_LEN+1]; + WORD iMaxSockets; + WORD iMaxUdpDg; + char *lpVendorInfo; +#endif +} WSADATA, *LPWSADATA; + +#ifndef USE_WS_PREFIX + +#undef htonl +#undef htons +#undef ntohl +#undef ntohs + +#ifdef WORDS_BIGENDIAN + +static inline u_short __wine_ushort_noop(u_short s) +{ + return s; +} +static inline ULONG __wine_ulong_noop(ULONG l) +{ + return l; +} +#define htonl __wine_ulong_noop +#define htons __wine_ushort_noop +#define ntohl __wine_ulong_noop +#define ntohs __wine_ushort_noop + +#else /* WORDS_BIGENDIAN */ + +static inline u_short __wine_ushort_swap(u_short s) +{ + return (s >> 8) | (s << 8); +} +static inline ULONG __wine_ulong_swap(ULONG l) +{ + return ((ULONG)__wine_ushort_swap((u_short)l) << 16) | __wine_ushort_swap((u_short)(l >> 16)); +} +#define htonl __wine_ulong_swap +#define htons __wine_ushort_swap +#define ntohl __wine_ulong_swap +#define ntohs __wine_ushort_swap + +#endif /* WORDS_BIGENDIAN */ +#endif /* USE_WS_PREFIX */ + +#define WSAMAKEASYNCREPLY(size, error) MAKELONG(size, error) +#define WSAMAKESELECTREPLY(flags, error) MAKELONG(flags, error) +#define WSAGETASYNCBUFLEN(x) LOWORD(x) +#define WSAGETASYNCERROR(x) HIWORD(x) +#define WSAGETSELECTEVENT(x) LOWORD(x) +#define WSAGETSELECTERROR(x) HIWORD(x) + /* * Winsock Function Typedefs * @@ -695,11 +1113,55 @@ typedef SOCKET (WINAPI *LPFN_SOCKET)(int,int,int); * "Winsock2 Function Typedefs" section below. */ #if WS_API_PROTOTYPES +int WINAPI __WSAFDIsSet(SOCKET, WS(fd_set) *); + +SOCKET WINAPI WS(accept)(SOCKET, struct WS(sockaddr) *, int *); +int WINAPI WS(bind)(SOCKET, const struct WS(sockaddr) *, int); +int WINAPI WS(closesocket)(SOCKET); +int WINAPI WS(connect)(SOCKET, const struct WS(sockaddr) *, int); +struct WS(hostent) * WINAPI WS(gethostbyaddr)(const char *, int, int); +struct WS(hostent) * WINAPI WS(gethostbyname)(const char *); +#if defined(__MINGW32__) || defined(_MSC_VER) || defined(__WINE_USE_MSVCRT) +/* gethostname is defined in unistd.h */ +int WINAPI WS(gethostname)(char *, int); +#endif +int WINAPI WS(getpeername)(SOCKET, struct WS(sockaddr) *, int *); +struct WS(protoent) * WINAPI WS(getprotobyname)(const char *); +struct WS(protoent) * WINAPI WS(getprotobynumber)(int); +struct WS(servent) * WINAPI WS(getservbyname)(const char *, const char *); +struct WS(servent) * WINAPI WS(getservbyport)(int, const char *); +int WINAPI WS(getsockname)(SOCKET, struct WS(sockaddr) *, int *); +int WINAPI WS(getsockopt)(SOCKET, int, int, char *, int *); +ULONG WINAPI WS(inet_addr)(const char *); +char * WINAPI WS(inet_ntoa)(struct WS(in_addr)); +int WINAPI WS(ioctlsocket)(SOCKET, LONG, WS(u_long) *); +int WINAPI WS(listen)(SOCKET, int); +int WINAPI WS(recv)(SOCKET, char *, int, int); +int WINAPI WS(recvfrom)(SOCKET, char *, int, int, struct WS(sockaddr) *, int *); +#ifdef WS_DEFINE_SELECT +int WINAPI WS(select)(int, WS(fd_set) *, WS(fd_set) *, WS(fd_set) *, const struct WS(timeval) *); +#endif +int WINAPI WS(send)(SOCKET, const char *, int, int); +int WINAPI WS(sendto)(SOCKET, const char *, int, int, const struct WS(sockaddr) *, int); +int WINAPI WS(setsockopt)(SOCKET, int, int, const char *, int); +int WINAPI WS(shutdown)(SOCKET, int); +SOCKET WINAPI WS(socket)(int, int, int); + int WINAPI GetHostNameW(WCHAR *, int); SOCKET WINAPI WSAAccept(SOCKET,struct WS(sockaddr)*,LPINT,LPCONDITIONPROC,DWORD_PTR); INT WINAPI WSAAddressToStringA(LPSOCKADDR,DWORD,LPWSAPROTOCOL_INFOA,LPSTR,LPDWORD); INT WINAPI WSAAddressToStringW(LPSOCKADDR,DWORD,LPWSAPROTOCOL_INFOW,LPWSTR,LPDWORD); #define WSAAddressToString WINELIB_NAME_AW(WSAAddressToString) +HANDLE WINAPI WSAAsyncGetHostByAddr(HWND, WS(u_int), const char *, int, int, char *, int); +HANDLE WINAPI WSAAsyncGetHostByName(HWND, WS(u_int), const char *, char *, int); +HANDLE WINAPI WSAAsyncGetProtoByName(HWND, WS(u_int), const char *, char *, int); +HANDLE WINAPI WSAAsyncGetProtoByNumber(HWND, WS(u_int), int, char *, int); +HANDLE WINAPI WSAAsyncGetServByName(HWND, WS(u_int), const char *, const char *, char *, int); +HANDLE WINAPI WSAAsyncGetServByPort(HWND, WS(u_int), int, const char *, char *, int); +int WINAPI WSAAsyncSelect(SOCKET, HWND, WS(u_int), LONG); +int WINAPI WSACancelAsyncRequest(HANDLE); +int WINAPI WSACancelBlockingCall(void); +int WINAPI WSACleanup(void); BOOL WINAPI WSACloseEvent(WSAEVENT); int WINAPI WSAConnect(SOCKET,const struct WS(sockaddr)*,int,LPWSABUF,LPWSABUF,LPQOS,LPQOS); WSAEVENT WINAPI WSACreateEvent(void); @@ -714,6 +1176,7 @@ int WINAPI WSAEnumProtocolsA(LPINT,LPWSAPROTOCOL_INFOA,LPDWORD); int WINAPI WSAEnumProtocolsW(LPINT,LPWSAPROTOCOL_INFOW,LPDWORD); #define WSAEnumProtocols WINELIB_NAME_AW(WSAEnumProtocols) int WINAPI WSAEventSelect(SOCKET,WSAEVENT,LONG); +int WINAPI WSAGetLastError(void); BOOL WINAPI WSAGetOverlappedResult(SOCKET,LPWSAOVERLAPPED,LPDWORD,BOOL,LPDWORD); BOOL WINAPI WSAGetQOSByName(SOCKET,LPWSABUF,LPQOS); INT WINAPI WSAGetServiceClassInfoA(LPGUID,LPGUID,LPDWORD,LPWSASERVICECLASSINFOA); @@ -728,6 +1191,7 @@ int WINAPI WSAInstallServiceClassA(LPWSASERVICECLASSINFOA); int WINAPI WSAInstallServiceClassW(LPWSASERVICECLASSINFOW); #define WSAInstallServiceClass WINELIB_NAME_AW(WSAInstallServiceClass) int WINAPI WSAIoctl(SOCKET,DWORD,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE); +BOOL WINAPI WSAIsBlocking(void); SOCKET WINAPI WSAJoinLeaf(SOCKET,const struct WS(sockaddr)*,int,LPWSABUF,LPWSABUF,LPQOS,LPQOS,DWORD); INT WINAPI WSALookupServiceBeginA(LPWSAQUERYSETA,DWORD,LPHANDLE); INT WINAPI WSALookupServiceBeginW(LPWSAQUERYSETW,DWORD,LPHANDLE); @@ -749,16 +1213,20 @@ BOOL WINAPI WSAResetEvent(WSAEVENT); int WINAPI WSASend(SOCKET,LPWSABUF,DWORD,LPDWORD,DWORD,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE); int WINAPI WSASendDisconnect(SOCKET,LPWSABUF); int WINAPI WSASendTo(SOCKET,LPWSABUF,DWORD,LPDWORD,DWORD,const struct WS(sockaddr)*,int,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE); +FARPROC WINAPI WSASetBlockingHook(FARPROC); BOOL WINAPI WSASetEvent(WSAEVENT); +void WINAPI WSASetLastError(int); INT WINAPI WSASetServiceA(LPWSAQUERYSETA,WSAESETSERVICEOP,DWORD); INT WINAPI WSASetServiceW(LPWSAQUERYSETW,WSAESETSERVICEOP,DWORD); #define WSASetService WINELIB_NAME_AW(WSASetService) SOCKET WINAPI WSASocketA(int,int,int,LPWSAPROTOCOL_INFOA,GROUP,DWORD); SOCKET WINAPI WSASocketW(int,int,int,LPWSAPROTOCOL_INFOW,GROUP,DWORD); #define WSASocket WINELIB_NAME_AW(WSASocket) +int WINAPI WSAStartup(WORD,WSADATA*); INT WINAPI WSAStringToAddressA(LPSTR,INT,LPWSAPROTOCOL_INFOA,LPSOCKADDR,LPINT); INT WINAPI WSAStringToAddressW(LPWSTR,INT,LPWSAPROTOCOL_INFOW,LPSOCKADDR,LPINT); #define WSAStringToAddress WINELIB_NAME_AW(WSAStringToAddress) +int WINAPI WSAUnhookBlockingHook(void); DWORD WINAPI WSAWaitForMultipleEvents(DWORD,const WSAEVENT*,BOOL,DWORD,BOOL); #endif /* WS_API_PROTOTYPES */ diff --git a/include/ws2def.h b/include/ws2def.h index b92bf68bae8..9ddfa031633 100644 --- a/include/ws2def.h +++ b/include/ws2def.h @@ -29,6 +29,166 @@ typedef USHORT ADDRESS_FAMILY; +typedef struct WS(sockaddr) +{ + unsigned short sa_family; + char sa_data[14]; +} SOCKADDR, *PSOCKADDR, *LPSOCKADDR; + +#ifndef USE_WS_PREFIX +#define AF_UNSPEC 0 +#define AF_UNIX 1 +#define AF_INET 2 +#define AF_IMPLINK 3 +#define AF_PUP 4 +#define AF_CHAOS 5 +#define AF_NS 6 +#define AF_IPX AF_NS +#define AF_ISO 7 +#define AF_OSI AF_ISO +#define AF_ECMA 8 +#define AF_DATAKIT 9 +#define AF_CCITT 10 +#define AF_SNA 11 +#define AF_DECnet 12 +#define AF_DLI 13 +#define AF_LAT 14 +#define AF_HYLINK 15 +#define AF_APPLETALK 16 +#define AF_NETBIOS 17 +#define AF_VOICEVIEW 18 +#define AF_FIREFOX 19 +#define AF_UNKNOWN1 20 +#define AF_BAN 21 +#define AF_ATM 22 +#define AF_INET6 23 +#define AF_CLUSTER 24 +#define AF_12844 25 +#define AF_IRDA 26 +#define AF_MAX 27 +#else /* USE_WS_PREFIX */ +#define WS_AF_UNSPEC 0 +#define WS_AF_UNIX 1 +#define WS_AF_INET 2 +#define WS_AF_IMPLINK 3 +#define WS_AF_PUP 4 +#define WS_AF_CHAOS 5 +#define WS_AF_NS 6 +#define WS_AF_IPX WS_AF_NS +#define WS_AF_ISO 7 +#define WS_AF_OSI WS_AF_ISO +#define WS_AF_ECMA 8 +#define WS_AF_DATAKIT 9 +#define WS_AF_CCITT 10 +#define WS_AF_SNA 11 +#define WS_AF_DECnet 12 +#define WS_AF_DLI 13 +#define WS_AF_LAT 14 +#define WS_AF_HYLINK 15 +#define WS_AF_APPLETALK 16 +#define WS_AF_NETBIOS 17 +#define WS_AF_VOICEVIEW 18 +#define WS_AF_FIREFOX 19 +#define WS_AF_UNKNOWN1 20 +#define WS_AF_BAN 21 +#define WS_AF_ATM 22 +#define WS_AF_INET6 23 +#define WS_AF_CLUSTER 24 +#define WS_AF_12844 25 +#define WS_AF_IRDA 26 +#define WS_AF_MAX 27 +#endif /* USE_WS_PREFIX */ + +#ifndef USE_WS_PREFIX +#define IPPROTO_IP 0 +#else +#define WS_IPPROTO_IP 0 +#endif + +typedef enum +{ + WS(IPPROTO_ICMP) = 1, + WS(IPPROTO_IGMP) = 2, + WS(IPPROTO_GGP) = 3, + WS(IPPROTO_IPV4) = 4, + WS(IPPROTO_TCP) = 6, + WS(IPPROTO_UDP) = 17, + WS(IPPROTO_IDP) = 22, + WS(IPPROTO_IPV6) = 41, + WS(IPPROTO_ICMPV6) = 58, + WS(IPPROTO_ND) = 77, + WS(IPPROTO_RAW) = 255, + WS(IPPROTO_MAX) = 256, +} IPPROTO; + +#ifndef USE_WS_PREFIX +#define INADDR_ANY ((ULONG)0x00000000) +#define INADDR_LOOPBACK 0x7f000001 +#define INADDR_BROADCAST ((ULONG)0xffffffff) +#define INADDR_NONE 0xffffffff +#else +#define WS_INADDR_ANY ((ULONG)0x00000000) +#define WS_INADDR_LOOPBACK 0x7f000001 +#define WS_INADDR_BROADCAST ((ULONG)0xffffffff) +#define WS_INADDR_NONE 0xffffffff +#endif + +#ifndef USE_WS_PREFIX +#define IN_CLASSA_NSHIFT 24 +#define IN_CLASSA_MAX 128 +#define IN_CLASSA_NET 0xff000000 +#define IN_CLASSA_HOST 0x00ffffff +#define IN_CLASSA(i) (((LONG)(i) & 0x80000000) == 0) +#define IN_CLASSB_NSHIFT 16 +#define IN_CLASSB_MAX 65536 +#define IN_CLASSB_NET 0xffff0000 +#define IN_CLASSB_HOST 0x0000ffff +#define IN_CLASSB(i) (((LONG)(i) & 0xc0000000) == 0x80000000) +#define IN_CLASSC_NSHIFT 8 +#define IN_CLASSC_NET 0xffffff00 +#define IN_CLASSC_HOST 0x000000ff +#define IN_CLASSC(i) (((LONG)(i) & 0xe0000000) == 0xc0000000) +#else +#define WS_IN_CLASSA_NSHIFT 24 +#define WS_IN_CLASSA_MAX 128 +#define WS_IN_CLASSA_NET 0xff000000 +#define WS_IN_CLASSA_HOST 0x00ffffff +#define WS_IN_CLASSA(i) (((LONG)(i) & 0x80000000) == 0) +#define WS_IN_CLASSB_NSHIFT 16 +#define WS_IN_CLASSB_MAX 65536 +#define WS_IN_CLASSB_NET 0xffff0000 +#define WS_IN_CLASSB_HOST 0x0000ffff +#define WS_IN_CLASSB(i) (((LONG)(i) & 0xc0000000) == 0x80000000) +#define WS_IN_CLASSC_NSHIFT 8 +#define WS_IN_CLASSC_NET 0xffffff00 +#define WS_IN_CLASSC_HOST 0x000000ff +#define WS_IN_CLASSC(i) (((LONG)(i) & 0xe0000000) == 0xc0000000) +#endif /* USE_WS_PREFIX */ + +#ifndef USE_WS_PREFIX +#define SO_BSP_STATE 0x1009 +#define SO_RANDOMIZE_PORT 0x3005 +#define SO_PORT_SCALABILITY 0x3006 +#define SO_REUSE_UNICASTPORT 0x3007 +#define SO_REUSE_MULTICASTPORT 0x3008 +#define TCP_NODELAY 0x0001 +#else +#define WS_SO_BSP_STATE 0x1009 +#define WS_SO_RANDOMIZE_PORT 0x3005 +#define WS_SO_PORT_SCALABILITY 0x3006 +#define WS_SO_REUSE_UNICASTPORT 0x3007 +#define WS_SO_REUSE_MULTICASTPORT 0x3008 +#define WS_TCP_NODELAY 0x0001 +#endif + +typedef struct WS(sockaddr_in) +{ + short sin_family; + unsigned short sin_port; + struct WS(in_addr) sin_addr; + char sin_zero[8]; +} SOCKADDR_IN, *PSOCKADDR_IN, *LPSOCKADDR_IN; + #ifndef __CSADDR_DEFINED__ #define __CSADDR_DEFINED__ diff --git a/server/sock.c b/server/sock.c index 00d5b0b9044..39f02036da8 100644 --- a/server/sock.c +++ b/server/sock.c @@ -96,32 +96,6 @@ #include "request.h" #include "user.h" -/* From winsock.h */ -#define FD_MAX_EVENTS 10 -#define FD_READ_BIT 0 -#define FD_WRITE_BIT 1 -#define FD_OOB_BIT 2 -#define FD_ACCEPT_BIT 3 -#define FD_CONNECT_BIT 4 -#define FD_CLOSE_BIT 5 - -/* - * Define flags to be used with the WSAAsyncSelect() call. - */ -#define FD_READ 0x00000001 -#define FD_WRITE 0x00000002 -#define FD_OOB 0x00000004 -#define FD_ACCEPT 0x00000008 -#define FD_CONNECT 0x00000010 -#define FD_CLOSE 0x00000020 - -/* internal per-socket flags */ -#define FD_WINE_LISTENING 0x10000000 -#define FD_WINE_NONBLOCKING 0x20000000 -#define FD_WINE_CONNECTED 0x40000000 -#define FD_WINE_RAW 0x80000000 -#define FD_WINE_INTERNAL 0xFFFF0000 - struct accept_req { struct list entry; @@ -988,7 +962,7 @@ static int get_unix_protocol( int protocol ) case WS_IPPROTO_ICMP: return IPPROTO_ICMP; case WS_IPPROTO_IGMP: return IPPROTO_IGMP; case WS_IPPROTO_IP: return IPPROTO_IP; - case WS_IPPROTO_IPIP: return IPPROTO_IPIP; + case WS_IPPROTO_IPV4: return IPPROTO_IPIP; case WS_IPPROTO_IPV6: return IPPROTO_IPV6; case WS_IPPROTO_RAW: return IPPROTO_RAW; case WS_IPPROTO_TCP: return IPPROTO_TCP; -- 2.30.2

2 5

[PATCH 9/9] mshtml/tests: Add Map object tests.
by Jacek Caban 27 Apr '21

27 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/mshtml/tests/documentmode.js | 110 +++++++++++++++++++++++++++++- 1 file changed, 109 insertions(+), 1 deletion(-)

2 1

[PATCH 1/9] jscript: Add Map object stub implementation.
by Jacek Caban 27 Apr '21

27 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/jscript.c | 5 ++ dlls/jscript/jscript.h | 2 + dlls/jscript/object.c | 1 + dlls/jscript/set.c | 120 ++++++++++++++++++++++++++++++ dlls/mshtml/tests/documentmode.js | 24 ++++++ 5 files changed, 152 insertions(+)

2 1

[PATCH 8/9] jscript: Add Map.prototype.forEach implementation.
by Jacek Caban 27 Apr '21

27 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/set.c | 38 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 36 insertions(+), 2 deletions(-)

1 0

[PATCH 7/9] jscript: Add Map.size property implementation.
by Jacek Caban 27 Apr '21

27 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/set.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-)

1 0

[PATCH 6/9] jscript: Add Map.prototype.has implementation.
by Jacek Caban 27 Apr '21

27 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/set.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-)

1 0

[PATCH 5/9] jscript: Add Map.prototype.delete implementation.
by Jacek Caban 27 Apr '21

27 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/set.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-)

1 0

[PATCH 4/9] jscript: Add Map.prototype.clear implementation.
by Jacek Caban 27 Apr '21

27 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/set.c | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-)

1 0

[PATCH 3/9] jscript: Add Map.prototype.get implementation.
by Jacek Caban 27 Apr '21

27 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/set.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)

1 0

[PATCH 2/9] jscript: Add Map.prototype.set implementation.
by Jacek Caban 27 Apr '21

27 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/jscript.h | 1 + dlls/jscript/jscript.rc | 1 + dlls/jscript/resource.h | 1 + dlls/jscript/set.c | 142 +++++++++++++++++++++++++++++++++++++++- 4 files changed, 142 insertions(+), 3 deletions(-)

1 0

[PATCH v2 1/3] user32: Move ToUnicodeEx from wineandroid.drv to user32.
by Rémi Bernon 27 Apr '21

27 Apr '21

As a default implementation for en_US keyboard layout, calling the driver implementation next so that it can override the result. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- v2: * Use the english keyboard layout for the default impl, let the driver override the result if they can. * Only copy default buffer to user buffer in nulldrv, to leave user buffer untouched for drivers. ToUnicodeEx is not re-entrant when dealing with dead keys (although I don't think Wine uses that). * Use lstrcpynW instead of wcscpy. * Don't call debugstr_wn if len is < 0. * Drop controversial (Un)LoadKeyboardLayoutW patch for now. Supersedes: 204512, 204513, 204518, 204519 dlls/user32/driver.c | 11 ++- dlls/user32/input.c | 80 ++++++++++++++++++- dlls/user32/user_private.h | 2 +- dlls/wineandroid.drv/keyboard.c | 94 ----------------------- dlls/wineandroid.drv/wineandroid.drv.spec | 1 - dlls/winemac.drv/keyboard.c | 3 +- dlls/winemac.drv/winemac.drv.spec | 2 +- dlls/winex11.drv/keyboard.c | 3 +- dlls/winex11.drv/winex11.drv.spec | 2 +- 9 files changed, 90 insertions(+), 108 deletions(-) diff --git a/dlls/user32/driver.c b/dlls/user32/driver.c index 7ac77141696..c385ce0599c 100644 --- a/dlls/user32/driver.c +++ b/dlls/user32/driver.c @@ -284,9 +284,11 @@ static BOOL CDECL nulldrv_RegisterHotKey( HWND hwnd, UINT modifiers, UINT vk ) } static INT CDECL nulldrv_ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, LPWSTR str, - int size, UINT flags, HKL layout ) + int size, UINT flags, HKL layout, + const WCHAR *default_buf, INT default_len ) { - return 0; + lstrcpynW( str, default_buf, size ); + return default_len; } static BOOL CDECL nulldrv_UnloadKeyboardLayout( HKL layout ) @@ -592,9 +594,10 @@ static BOOL CDECL loaderdrv_RegisterHotKey( HWND hwnd, UINT modifiers, UINT vk ) } static INT CDECL loaderdrv_ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, LPWSTR str, - int size, UINT flags, HKL layout ) + int size, UINT flags, HKL layout, + const WCHAR *default_buf, INT default_len ) { - return load_driver()->pToUnicodeEx( virt, scan, state, str, size, flags, layout ); + return load_driver()->pToUnicodeEx( virt, scan, state, str, size, flags, layout, default_buf, default_len ); } static BOOL CDECL loaderdrv_UnloadKeyboardLayout( HKL layout ) diff --git a/dlls/user32/input.c b/dlls/user32/input.c index 805bfe3e9de..51a08d0786b 100644 --- a/dlls/user32/input.c +++ b/dlls/user32/input.c @@ -877,11 +877,83 @@ INT WINAPI ToUnicode(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, /**************************************************************************** * ToUnicodeEx (USER32.@) */ -INT WINAPI ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, - LPWSTR lpwStr, int size, UINT flags, HKL hkl) +INT WINAPI ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, + WCHAR *str, int size, UINT flags, HKL layout ) { - if (!lpKeyState) return 0; - return USER_Driver->pToUnicodeEx(virtKey, scanCode, lpKeyState, lpwStr, size, flags, hkl); + BOOL shift, ctrl, numlock; + WCHAR buffer[2]; + INT len; + + TRACE_(keyboard)( "virt %u, scan %u, state %p, str %p, size %d, flags %x, layout %p.\n", + virt, scan, state, str, size, flags, layout ); + + if (!state) return 0; + + shift = state[VK_SHIFT] & 0x80; + ctrl = state[VK_CONTROL] & 0x80; + numlock = state[VK_NUMLOCK] & 0x01; + + /* FIXME: English keyboard layout specific */ + + if (scan & 0x8000) buffer[0] = 0; /* key up */ + else if (!ctrl) + { + switch (virt) + { + case VK_BACK: buffer[0] = '\b'; break; + case VK_OEM_1: buffer[0] = shift ? ':' : ';'; break; + case VK_OEM_2: buffer[0] = shift ? '?' : '/'; break; + case VK_OEM_3: buffer[0] = shift ? '~' : '`'; break; + case VK_OEM_4: buffer[0] = shift ? '{' : '['; break; + case VK_OEM_5: buffer[0] = shift ? '|' : '\\'; break; + case VK_OEM_6: buffer[0] = shift ? '}' : ']'; break; + case VK_OEM_7: buffer[0] = shift ? '"' : '\''; break; + case VK_OEM_COMMA: buffer[0] = shift ? '<' : ','; break; + case VK_OEM_MINUS: buffer[0] = shift ? '_' : '-'; break; + case VK_OEM_PERIOD: buffer[0] = shift ? '>' : '.'; break; + case VK_OEM_PLUS: buffer[0] = shift ? '+' : '='; break; + case VK_RETURN: buffer[0] = '\r'; break; + case VK_SPACE: buffer[0] = ' '; break; + case VK_TAB: buffer[0] = '\t'; break; + case VK_MULTIPLY: buffer[0] = '*'; break; + case VK_ADD: buffer[0] = '+'; break; + case VK_SUBTRACT: buffer[0] = '-'; break; + case VK_DIVIDE: buffer[0] = '/'; break; + default: + if (virt >= '0' && virt <= '9') + buffer[0] = shift ? ")!@#$%^&*("[virt - '0'] : virt; + else if (virt >= 'A' && virt <= 'Z') + buffer[0] = shift || (state[VK_CAPITAL] & 0x01) ? virt : virt + 'a' - 'A'; + else if (virt >= VK_NUMPAD0 && virt <= VK_NUMPAD9 && numlock && !shift) + buffer[0] = '0' + virt - VK_NUMPAD0; + else if (virt == VK_DECIMAL && numlock && !shift) + buffer[0] = '.'; + else + buffer[0] = 0; + break; + } + } + else /* Control codes */ + { + switch (virt) + { + case VK_OEM_4: buffer[0] = 0x1b; break; + case VK_OEM_5: buffer[0] = 0x1c; break; + case VK_OEM_6: buffer[0] = 0x1d; break; + case VK_SUBTRACT: buffer[0] = 0x1e; break; + default: + if (virt >= 'A' && virt <= 'Z') buffer[0] = virt - 'A' + 1; + else buffer[0] = 0; + break; + } + } + buffer[1] = 0; + len = wcslen( buffer ); + + len = USER_Driver->pToUnicodeEx( virt, scan, state, str, size, flags, layout, buffer, len ); + + TRACE_(keyboard)( "ret %d, str %s.\n", len, len < 0 ? "" : debugstr_wn(str, len) ); + return len; } /**************************************************************************** diff --git a/dlls/user32/user_private.h b/dlls/user32/user_private.h index 5f8059a12a0..8f9841ec48b 100644 --- a/dlls/user32/user_private.h +++ b/dlls/user32/user_private.h @@ -71,7 +71,7 @@ typedef struct tagUSER_DRIVER { HKL (CDECL *pLoadKeyboardLayout)(LPCWSTR, UINT); UINT (CDECL *pMapVirtualKeyEx)(UINT, UINT, HKL); BOOL (CDECL *pRegisterHotKey)(HWND, UINT, UINT); - INT (CDECL *pToUnicodeEx)(UINT, UINT, const BYTE *, LPWSTR, int, UINT, HKL); + INT (CDECL *pToUnicodeEx)(UINT, UINT, const BYTE *, LPWSTR, int, UINT, HKL, const WCHAR *, INT); BOOL (CDECL *pUnloadKeyboardLayout)(HKL); void (CDECL *pUnregisterHotKey)(HWND, UINT, UINT); SHORT (CDECL *pVkKeyScanEx)(WCHAR, HKL); diff --git a/dlls/wineandroid.drv/keyboard.c b/dlls/wineandroid.drv/keyboard.c index 0a6ede0ec5f..04565c3fad8 100644 --- a/dlls/wineandroid.drv/keyboard.c +++ b/dlls/wineandroid.drv/keyboard.c @@ -750,100 +750,6 @@ jboolean keyboard_event( JNIEnv *env, jobject obj, jint win, jint action, jint k } -/*********************************************************************** - * ANDROID_ToUnicodeEx - */ -INT CDECL ANDROID_ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, - LPWSTR buf, int size, UINT flags, HKL hkl ) -{ - WCHAR buffer[2]; - BOOL shift = state[VK_SHIFT] & 0x80; - BOOL ctrl = state[VK_CONTROL] & 0x80; - BOOL numlock = state[VK_NUMLOCK] & 0x01; - - buffer[0] = buffer[1] = 0; - - if (scan & 0x8000) return 0; /* key up */ - - /* FIXME: hardcoded layout */ - - if (!ctrl) - { - switch (virt) - { - case VK_BACK: buffer[0] = '\b'; break; - case VK_OEM_1: buffer[0] = shift ? ':' : ';'; break; - case VK_OEM_2: buffer[0] = shift ? '?' : '/'; break; - case VK_OEM_3: buffer[0] = shift ? '~' : '`'; break; - case VK_OEM_4: buffer[0] = shift ? '{' : '['; break; - case VK_OEM_5: buffer[0] = shift ? '|' : '\\'; break; - case VK_OEM_6: buffer[0] = shift ? '}' : ']'; break; - case VK_OEM_7: buffer[0] = shift ? '"' : '\''; break; - case VK_OEM_COMMA: buffer[0] = shift ? '<' : ','; break; - case VK_OEM_MINUS: buffer[0] = shift ? '_' : '-'; break; - case VK_OEM_PERIOD: buffer[0] = shift ? '>' : '.'; break; - case VK_OEM_PLUS: buffer[0] = shift ? '+' : '='; break; - case VK_RETURN: buffer[0] = '\r'; break; - case VK_SPACE: buffer[0] = ' '; break; - case VK_TAB: buffer[0] = '\t'; break; - case VK_MULTIPLY: buffer[0] = '*'; break; - case VK_ADD: buffer[0] = '+'; break; - case VK_SUBTRACT: buffer[0] = '-'; break; - case VK_DIVIDE: buffer[0] = '/'; break; - default: - if (virt >= '0' && virt <= '9') - { - buffer[0] = shift ? ")!@#$%^&*("[virt - '0'] : virt; - break; - } - if (virt >= 'A' && virt <= 'Z') - { - buffer[0] = shift || (state[VK_CAPITAL] & 0x01) ? virt : virt + 'a' - 'A'; - break; - } - if (virt >= VK_NUMPAD0 && virt <= VK_NUMPAD9 && numlock && !shift) - { - buffer[0] = '0' + virt - VK_NUMPAD0; - break; - } - if (virt == VK_DECIMAL && numlock && !shift) - { - buffer[0] = '.'; - break; - } - break; - } - } - else /* Control codes */ - { - if (virt >= 'A' && virt <= 'Z') - buffer[0] = virt - 'A' + 1; - else - { - switch (virt) - { - case VK_OEM_4: - buffer[0] = 0x1b; - break; - case VK_OEM_5: - buffer[0] = 0x1c; - break; - case VK_OEM_6: - buffer[0] = 0x1d; - break; - case VK_SUBTRACT: - buffer[0] = 0x1e; - break; - } - } - } - - lstrcpynW( buf, buffer, size ); - TRACE( "returning %d / %s\n", strlenW( buffer ), debugstr_wn(buf, strlenW( buffer ))); - return strlenW( buffer ); -} - - /*********************************************************************** * ANDROID_GetKeyNameText */ diff --git a/dlls/wineandroid.drv/wineandroid.drv.spec b/dlls/wineandroid.drv/wineandroid.drv.spec index 00de23de27e..6f27c1586b3 100644 --- a/dlls/wineandroid.drv/wineandroid.drv.spec +++ b/dlls/wineandroid.drv/wineandroid.drv.spec @@ -7,7 +7,6 @@ @ cdecl GetKeyNameText(long ptr long) ANDROID_GetKeyNameText @ cdecl GetKeyboardLayout(long) ANDROID_GetKeyboardLayout @ cdecl MapVirtualKeyEx(long long long) ANDROID_MapVirtualKeyEx -@ cdecl ToUnicodeEx(long long ptr ptr long long long) ANDROID_ToUnicodeEx @ cdecl VkKeyScanEx(long long) ANDROID_VkKeyScanEx @ cdecl SetCursor(long) ANDROID_SetCursor @ cdecl ChangeDisplaySettingsEx(ptr ptr long long long) ANDROID_ChangeDisplaySettingsEx diff --git a/dlls/winemac.drv/keyboard.c b/dlls/winemac.drv/keyboard.c index 1ea15f59341..d9c819431f2 100644 --- a/dlls/winemac.drv/keyboard.c +++ b/dlls/winemac.drv/keyboard.c @@ -1553,7 +1553,8 @@ BOOL CDECL macdrv_RegisterHotKey(HWND hwnd, UINT mod_flags, UINT vkey) * */ INT CDECL macdrv_ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, - LPWSTR bufW, int bufW_size, UINT flags, HKL hkl) + LPWSTR bufW, int bufW_size, UINT flags, HKL hkl, + const WCHAR *default_buf, INT default_len) { struct macdrv_thread_data *thread_data = macdrv_init_thread_data(); INT ret = 0; diff --git a/dlls/winemac.drv/winemac.drv.spec b/dlls/winemac.drv/winemac.drv.spec index 39cf33370b4..97c94b6ee88 100644 --- a/dlls/winemac.drv/winemac.drv.spec +++ b/dlls/winemac.drv/winemac.drv.spec @@ -34,7 +34,7 @@ @ cdecl SysCommand(long long long) macdrv_SysCommand @ cdecl SystemParametersInfo(long long ptr long) macdrv_SystemParametersInfo @ cdecl ThreadDetach() macdrv_ThreadDetach -@ cdecl ToUnicodeEx(long long ptr ptr long long long) macdrv_ToUnicodeEx +@ cdecl ToUnicodeEx(long long ptr ptr long long long ptr long) macdrv_ToUnicodeEx @ cdecl UnregisterHotKey(long long long) macdrv_UnregisterHotKey @ cdecl UpdateClipboard() macdrv_UpdateClipboard @ cdecl UpdateLayeredWindow(long ptr ptr) macdrv_UpdateLayeredWindow diff --git a/dlls/winex11.drv/keyboard.c b/dlls/winex11.drv/keyboard.c index 01620c5e4a4..c45d12c7517 100644 --- a/dlls/winex11.drv/keyboard.c +++ b/dlls/winex11.drv/keyboard.c @@ -2432,7 +2432,8 @@ static char KEYBOARD_MapDeadKeysym(KeySym keysym) * */ INT CDECL X11DRV_ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, - LPWSTR bufW, int bufW_size, UINT flags, HKL hkl) + LPWSTR bufW, int bufW_size, UINT flags, HKL hkl, + const WCHAR *default_buf, INT default_len) { Display *display = thread_init_display(); XKeyEvent e; diff --git a/dlls/winex11.drv/winex11.drv.spec b/dlls/winex11.drv/winex11.drv.spec index c0e24d8fe82..b73ae87b929 100644 --- a/dlls/winex11.drv/winex11.drv.spec +++ b/dlls/winex11.drv/winex11.drv.spec @@ -11,7 +11,7 @@ @ cdecl GetKeyboardLayoutName(ptr) X11DRV_GetKeyboardLayoutName @ cdecl LoadKeyboardLayout(wstr long) X11DRV_LoadKeyboardLayout @ cdecl MapVirtualKeyEx(long long long) X11DRV_MapVirtualKeyEx -@ cdecl ToUnicodeEx(long long ptr ptr long long long) X11DRV_ToUnicodeEx +@ cdecl ToUnicodeEx(long long ptr ptr long long long ptr long) X11DRV_ToUnicodeEx @ cdecl UnloadKeyboardLayout(long) X11DRV_UnloadKeyboardLayout @ cdecl VkKeyScanEx(long long) X11DRV_VkKeyScanEx @ cdecl DestroyCursorIcon(long) X11DRV_DestroyCursorIcon -- 2.31.0

2 9

[PATCH v2] msado15: Support Properties interface on Field
by Alistair Leslie-Hughes 27 Apr '21

27 Apr '21

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/msado15/main.c | 1 + dlls/msado15/msado15_private.h | 1 + dlls/msado15/recordset.c | 144 ++++++++++++++++++++++++++++++++- dlls/msado15/tests/msado15.c | 20 +++++ 4 files changed, 164 insertions(+), 2 deletions(-) diff --git a/dlls/msado15/main.c b/dlls/msado15/main.c index 3479ceb5b02..6b85c84e8e8 100644 --- a/dlls/msado15/main.c +++ b/dlls/msado15/main.c @@ -184,6 +184,7 @@ static REFIID tid_ids[] = { &IID__Connection, &IID_Field, &IID_Fields, + &IID_Properties, &IID__Recordset, &IID__Stream, }; diff --git a/dlls/msado15/msado15_private.h b/dlls/msado15/msado15_private.h index 55afac3f389..600dcb90a97 100644 --- a/dlls/msado15/msado15_private.h +++ b/dlls/msado15/msado15_private.h @@ -48,6 +48,7 @@ typedef enum tid_t { Connection_tid, Field_tid, Fields_tid, + Properties_tid, Recordset_tid, Stream_tid, LAST_tid diff --git a/dlls/msado15/recordset.c b/dlls/msado15/recordset.c index 68d4c22d802..1fb44a9add1 100644 --- a/dlls/msado15/recordset.c +++ b/dlls/msado15/recordset.c @@ -65,6 +65,7 @@ struct field { Field Field_iface; ISupportErrorInfo ISupportErrorInfo_iface; + Properties Properties_iface; LONG refs; WCHAR *name; DataTypeEnum type; @@ -79,6 +80,11 @@ static inline struct field *impl_from_Field( Field *iface ) return CONTAINING_RECORD( iface, struct field, Field_iface ); } +static inline struct field *impl_from_Properties( Properties *iface ) +{ + return CONTAINING_RECORD( iface, struct field, Properties_iface ); +} + static ULONG WINAPI field_AddRef( Field *iface ) { struct field *field = impl_from_Field( iface ); @@ -181,8 +187,12 @@ static HRESULT WINAPI field_Invoke( Field *iface, DISPID member, REFIID riid, LC static HRESULT WINAPI field_get_Properties( Field *iface, Properties **obj ) { - FIXME( "%p, %p\n", iface, obj ); - return E_NOTIMPL; + struct field *field = impl_from_Field( iface ); + TRACE( "%p, %p\n", iface, obj ); + + *obj = &field->Properties_iface; + Properties_AddRef(&field->Properties_iface); + return S_OK; } static HRESULT WINAPI field_get_ActualSize( Field *iface, LONG *size ) @@ -447,6 +457,135 @@ static const ISupportErrorInfoVtbl field_supporterrorinfo_vtbl = field_supporterrorinfo_InterfaceSupportsErrorInfo }; +static HRESULT WINAPI field_props_QueryInterface(Properties *iface, REFIID riid, void **ppv) +{ + struct field *field = impl_from_Properties( iface ); + + if (IsEqualGUID( riid, &IID_Properties) || IsEqualGUID( riid, &IID_IDispatch ) || + IsEqualGUID( riid, &IID_IUnknown )) + { + *ppv = &field->Properties_iface; + } + else + { + FIXME( "interface %s not implemented\n", debugstr_guid(riid) ); + return E_NOINTERFACE; + } + Field_AddRef(&field->Field_iface); + return S_OK; +} + +static ULONG WINAPI field_props_AddRef(Properties *iface) +{ + struct field *field = impl_from_Properties( iface ); + return Field_AddRef(&field->Field_iface); +} + +static ULONG WINAPI field_props_Release(Properties *iface) +{ + struct field *field = impl_from_Properties( iface ); + return Field_Release(&field->Field_iface); +} + +static HRESULT WINAPI field_props_GetTypeInfoCount(Properties *iface, UINT *count) +{ + struct field *field = impl_from_Properties( iface ); + TRACE( "%p, %p\n", field, count ); + *count = 1; + return S_OK; +} + +static HRESULT WINAPI field_props_GetTypeInfo(Properties *iface, UINT index, LCID lcid, ITypeInfo **info) +{ + struct field *field = impl_from_Properties( iface ); + TRACE( "%p, %u, %u, %p\n", field, index, lcid, info ); + return get_typeinfo(Properties_tid, info); +} + +static HRESULT WINAPI field_props_GetIDsOfNames(Properties *iface, REFIID riid, LPOLESTR *names, UINT count, + LCID lcid, DISPID *dispid ) +{ + struct field *field = impl_from_Properties( iface ); + HRESULT hr; + ITypeInfo *typeinfo; + + TRACE( "%p, %s, %p, %u, %u, %p\n", field, debugstr_guid(riid), names, count, lcid, dispid ); + + hr = get_typeinfo(Properties_tid, &typeinfo); + if(SUCCEEDED(hr)) + { + hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, dispid); + ITypeInfo_Release(typeinfo); + } + + return hr; +} + +static HRESULT WINAPI field_props_Invoke(Properties *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, + DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err ) +{ + struct field *field = impl_from_Properties( iface ); + HRESULT hr; + ITypeInfo *typeinfo; + + TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", field, member, debugstr_guid(riid), lcid, flags, params, + result, excep_info, arg_err ); + + hr = get_typeinfo(Properties_tid, &typeinfo); + if(SUCCEEDED(hr)) + { + hr = ITypeInfo_Invoke(typeinfo, &field->Field_iface, member, flags, params, + result, excep_info, arg_err); + ITypeInfo_Release(typeinfo); + } + + return hr; +} + +static HRESULT WINAPI field_props_get_Count(Properties *iface, LONG *count) +{ + struct field *field = impl_from_Properties( iface ); + FIXME( "%p, %p\n", field, count); + *count = 0; + return S_OK; +} + +static HRESULT WINAPI field_props__NewEnum(Properties *iface, IUnknown **object) +{ + struct field *field = impl_from_Properties( iface ); + FIXME( "%p, %p\n", field, object); + return E_NOTIMPL; +} + +static HRESULT WINAPI field_props_Refresh(Properties *iface) +{ + struct field *field = impl_from_Properties( iface ); + FIXME( "%p\n", field); + return E_NOTIMPL; +} + +static HRESULT WINAPI field_props_get_Item(Properties *iface, VARIANT index, Property **object) +{ + struct field *field = impl_from_Properties( iface ); + FIXME( "%p, %s, %p\n", field, debugstr_variant(&index), object); + return MAKE_ADO_HRESULT(adErrItemNotFound);; +} + +static struct PropertiesVtbl field_properties_vtbl = +{ + field_props_QueryInterface, + field_props_AddRef, + field_props_Release, + field_props_GetTypeInfoCount, + field_props_GetTypeInfo, + field_props_GetIDsOfNames, + field_props_Invoke, + field_props_get_Count, + field_props__NewEnum, + field_props_Refresh, + field_props_get_Item +}; + static HRESULT Field_create( const WCHAR *name, LONG index, struct recordset *recordset, Field **obj ) { struct field *field; @@ -454,6 +593,7 @@ static HRESULT Field_create( const WCHAR *name, LONG index, struct recordset *re if (!(field = heap_alloc_zero( sizeof(*field) ))) return E_OUTOFMEMORY; field->Field_iface.lpVtbl = &field_vtbl; field->ISupportErrorInfo_iface.lpVtbl = &field_supporterrorinfo_vtbl; + field->Properties_iface.lpVtbl = &field_properties_vtbl; if (!(field->name = strdupW( name ))) { heap_free( field ); diff --git a/dlls/msado15/tests/msado15.c b/dlls/msado15/tests/msado15.c index db606f21fab..b5f1b70dedd 100644 --- a/dlls/msado15/tests/msado15.c +++ b/dlls/msado15/tests/msado15.c @@ -68,6 +68,8 @@ static void test_Recordset(void) ISupportErrorInfo *errorinfo; Fields *fields, *fields2; Field *field; + Properties *props; + Property *prop; LONG refs, count, state; VARIANT missing, val, index; CursorLocationEnum location; @@ -184,6 +186,24 @@ static void test_Recordset(void) ok( hr == S_OK, "got %08x\n", hr ); SysFreeString( name ); + hr = Field_QueryInterface(field, &IID_Properties, (void**)&props); + ok( hr == E_NOINTERFACE, "got %08x\n", hr ); + + hr = Field_get_Properties(field, &props); + ok( hr == S_OK, "got %08x\n", hr ); + + count = -1; + hr = Properties_get_Count(props, &count); + ok( hr == S_OK, "got %08x\n", hr ); + ok( !count, "got %d\n", count ); + + V_VT( &index ) = VT_I4; + V_I4( &index ) = 1000; + hr = Properties_get_Item(props, index, &prop); + ok( hr == MAKE_ADO_HRESULT(adErrItemNotFound), "got %08x\n", hr ); + + Properties_Release(props); + hr = _Recordset_Open( recordset, missing, missing, adOpenStatic, adLockBatchOptimistic, adCmdUnspecified ); ok( hr == S_OK, "got %08x\n", hr ); ok( is_eof( recordset ), "not eof\n" ); -- 2.30.2

2 1

[PATCH v2] user32/tests: Add more GetKeyboardLayout(Name) tests.
by Rémi Bernon 27 Apr '21

27 Apr '21

At least on recent Windows, the HKL values are a combination of user selected UI language in the low word, and keyboard layout id in the high word. The keyboard layout id used in HKL is sometimes different from its name, as returned by GetKeyboardLayoutName, in which case it's the "Layout Id" value in the corresponding registry key under the layout name. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- v2: Fix a misplaced todo_wine. dlls/user32/tests/input.c | 53 ++++++++++++++++++++++++++++++++++----- 1 file changed, 47 insertions(+), 6 deletions(-) diff --git a/dlls/user32/tests/input.c b/dlls/user32/tests/input.c index 2397b4104e4..c4c361575cd 100644 --- a/dlls/user32/tests/input.c +++ b/dlls/user32/tests/input.c @@ -53,6 +53,7 @@ #include "wingdi.h" #include "winuser.h" #include "winnls.h" +#include "winreg.h" #include "ddk/hidsdi.h" #include "wine/test.h" @@ -3034,8 +3035,11 @@ static void test_get_async_key_state(void) static void test_keyboard_layout_name(void) { + WCHAR klid[KL_NAMELENGTH], tmpklid[KL_NAMELENGTH], layout_path[MAX_PATH], value[5]; + HKL layout, tmplayout, layouts[64]; + DWORD status, value_size; + int i, len; BOOL ret; - char klid[KL_NAMELENGTH]; if (0) /* crashes on native system */ ret = GetKeyboardLayoutNameA(NULL); @@ -3045,12 +3049,49 @@ static void test_keyboard_layout_name(void) ok(!ret, "got %d\n", ret); ok(GetLastError() == ERROR_NOACCESS, "got %d\n", GetLastError()); - if (GetKeyboardLayout(0) != (HKL)(ULONG_PTR)0x04090409) return; + layout = GetKeyboardLayout(0); + + len = GetKeyboardLayoutList(ARRAY_SIZE(layouts), layouts); + ok(len > 0, "GetKeyboardLayoutList returned %d\n", len); + + for (i = len - 1; i >= 0; --i) + { + UINT id = (UINT_PTR)layouts[i]; + ActivateKeyboardLayout(layouts[i], 0); + GetKeyboardLayoutNameW(klid); + + if (id & 0x80000000) + { + todo_wine ok((id >> 28) == 0xf, "hkl high bits %#x, expected 0xf\n", id >> 28); + + value_size = sizeof(value); + wcscpy(layout_path, L"System\\CurrentControlSet\\Control\\Keyboard Layouts\\"); + wcscat(layout_path, klid); + status = RegGetValueW(HKEY_LOCAL_MACHINE, layout_path, L"Layout Id", RRF_RT_REG_SZ, NULL, (void *)&value, &value_size); + todo_wine ok(!status, "RegGetValueW returned %x\n", status); + ok(value_size == 5 * sizeof(WCHAR), "RegGetValueW returned size %d\n", value_size); + + swprintf(tmpklid, KL_NAMELENGTH, L"%04X", (id >> 16) & 0x0fff); + todo_wine ok(!wcsicmp(value, tmpklid), "RegGetValueW returned %s, expected %s\n", debugstr_w(value), debugstr_w(tmpklid)); + } + else + { + swprintf(tmpklid, KL_NAMELENGTH, L"%08X", id >> 16); + ok(!wcsicmp(klid, tmpklid), "GetKeyboardLayoutNameW returned %s, expected %s\n", debugstr_w(klid), debugstr_w(tmpklid)); + } + + ActivateKeyboardLayout(layout, 0); + tmplayout = LoadKeyboardLayoutW(klid, KLF_ACTIVATE); + + /* The low word of HKL is the selected user lang and may be different as LoadKeyboardLayoutW also selects the default lang from the layout */ + ok(((UINT_PTR)tmplayout & ~0xffff) == ((UINT_PTR)layouts[i] & ~0xffff), "GetKeyboardLayout returned %p, expected %p\n", tmplayout, layouts[i]); + + /* The layout name only depends on the keyboard layout: the high word of HKL. */ + GetKeyboardLayoutNameW(tmpklid); + ok(!wcsicmp(klid, tmpklid), "GetKeyboardLayoutNameW returned %s, expected %s\n", debugstr_w(tmpklid), debugstr_w(klid)); + } - klid[0] = 0; - ret = GetKeyboardLayoutNameA(klid); - ok(ret, "GetKeyboardLayoutNameA failed %u\n", GetLastError()); - ok(!strcmp(klid, "00000409"), "expected 00000409, got %s\n", klid); + ActivateKeyboardLayout(layout, 0); } static void test_key_names(void) -- 2.31.0

2 1

[tools 1/3] winetest/dissect: Link the report pages to the test index pages.
by Francois Gouget 27 Apr '21

27 Apr '21

Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- An alternative would be to key this off of the id and 'testfile' class. But it feels cleaner to have a separate property for this. Also I opted to right-align the new link to no clutter the source filename. So on the left is the box title and on the right are all the links (all results and up / down arrows). --- winetest/dissect | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/winetest/dissect b/winetest/dissect index 7e28eacca..a3250ed1c 100755 --- a/winetest/dissect +++ b/winetest/dissect @@ -562,7 +562,9 @@ sub create_test_unit_box() { $dllinfo{$dll}->{first} = "$dll:$unit"; } - return create_box("$dll:$unit", "testfile", get_source_link(undef, undef)); + my $box = create_box("$dll:$unit", "testfile", get_source_link(undef, undef)); + $box->{testname} = "$dll:$unit"; + return $box; } sub close_test_unit($) @@ -978,6 +980,10 @@ for (my $i = 0; $i <= $#boxes; $i++) { printf REPORT "<div id=\"%s\" class=\"%s\">\n", $boxes[$i]->{id}, $boxes[$i]->{class}; printf REPORT "<div class=\"updownbar\">%s<div class='ralign'>", $boxes[$i]->{title}; + if ($boxes[$i]->{testname}) + { + printf REPORT "<a href='/data/tests/%s.html'>all results</a> | ", $boxes[$i]->{testname}; + } printf REPORT "<a href=\"#%s\">↑</a>", $boxes[$i]->{prev} if defined $boxes[$i]->{prev}; printf REPORT "<a href=\"#%s\">↓</a>", $boxes[$i]->{next} if defined $boxes[$i]->{next}; print REPORT "</div></div>\n"; @@ -1004,7 +1010,12 @@ for (my $i = 0; $i <= $#boxes; $i++) print FILE "<a href=\"..\">summary</a> | <a href=\"../..\">index</a></div>\n"; printf FILE "<div id=\"%s\" class=\"%s\">\n", $boxes[$i]->{id}, $boxes[$i]->{class}; - printf FILE "<div class=\"updownbar\">%s</div>\n", $boxes[$i]->{title}; + printf FILE "<div class=\"updownbar\">%s", $boxes[$i]->{title}; + if ($boxes[$i]->{testname}) + { + printf FILE "<div class='ralign'><a href='/data/tests/%s.html'>all results</a></div>", $boxes[$i]->{testname}; + } + print FILE "</div>\n"; print FILE $boxes[$i]->{data}, "</div>\n"; print FILE end_html(); close FILE or mydie "error writing to '$tmpdir/$boxes[$i]->{id}.html': $!"; -- 2.20.1

1 2

[PATCH] user32/tests: Add more GetKeyboardLayout(Name) tests.
by Rémi Bernon 27 Apr '21

27 Apr '21

At least on recent Windows, the HKL values are a combination of user selected UI language in the low word, and keyboard layout id in the high word. The keyboard layout id used in HKL is sometimes different from its name, as returned by GetKeyboardLayoutName, in which case it's the "Layout Id" value in the corresponding registry key under the layout name. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/user32/tests/input.c | 53 ++++++++++++++++++++++++++++++++++----- 1 file changed, 47 insertions(+), 6 deletions(-) diff --git a/dlls/user32/tests/input.c b/dlls/user32/tests/input.c index 2397b4104e4..4fceaa7a159 100644 --- a/dlls/user32/tests/input.c +++ b/dlls/user32/tests/input.c @@ -53,6 +53,7 @@ #include "wingdi.h" #include "winuser.h" #include "winnls.h" +#include "winreg.h" #include "ddk/hidsdi.h" #include "wine/test.h" @@ -3034,8 +3035,11 @@ static void test_get_async_key_state(void) static void test_keyboard_layout_name(void) { + WCHAR klid[KL_NAMELENGTH], tmpklid[KL_NAMELENGTH], layout_path[MAX_PATH], value[5]; + HKL layout, tmplayout, layouts[64]; + DWORD status, value_size; + int i, len; BOOL ret; - char klid[KL_NAMELENGTH]; if (0) /* crashes on native system */ ret = GetKeyboardLayoutNameA(NULL); @@ -3045,12 +3049,49 @@ static void test_keyboard_layout_name(void) ok(!ret, "got %d\n", ret); ok(GetLastError() == ERROR_NOACCESS, "got %d\n", GetLastError()); - if (GetKeyboardLayout(0) != (HKL)(ULONG_PTR)0x04090409) return; + layout = GetKeyboardLayout(0); + + len = GetKeyboardLayoutList(ARRAY_SIZE(layouts), layouts); + ok(len > 0, "GetKeyboardLayoutList returned %d\n", len); + + for (i = len - 1; i >= 0; --i) + { + UINT id = (UINT_PTR)layouts[i]; + ActivateKeyboardLayout(layouts[i], 0); + GetKeyboardLayoutNameW(klid); + + if (id & 0x80000000) + { + todo_wine ok((id >> 28) == 0xf, "hkl high bits %#x, expected 0xf\n", id >> 28); + + value_size = sizeof(value); + wcscpy(layout_path, L"System\\CurrentControlSet\\Control\\Keyboard Layouts\\"); + wcscat(layout_path, klid); + status = RegGetValueW(HKEY_LOCAL_MACHINE, layout_path, L"Layout Id", RRF_RT_REG_SZ, NULL, (void *)&value, &value_size); + ok(!status, "RegGetValueW returned %x\n", status); + todo_wine ok(value_size == 5 * sizeof(WCHAR), "RegGetValueW returned size %d\n", value_size); + + swprintf(tmpklid, KL_NAMELENGTH, L"%04X", (id >> 16) & 0x0fff); + todo_wine ok(!wcsicmp(value, tmpklid), "RegGetValueW returned %s, expected %s\n", debugstr_w(value), debugstr_w(tmpklid)); + } + else + { + swprintf(tmpklid, KL_NAMELENGTH, L"%08X", id >> 16); + ok(!wcsicmp(klid, tmpklid), "GetKeyboardLayoutNameW returned %s, expected %s\n", debugstr_w(klid), debugstr_w(tmpklid)); + } + + ActivateKeyboardLayout(layout, 0); + tmplayout = LoadKeyboardLayoutW(klid, KLF_ACTIVATE); + + /* The low word of HKL is the selected user lang and may be different as LoadKeyboardLayoutW also selects the default lang from the layout */ + ok(((UINT_PTR)tmplayout & ~0xffff) == ((UINT_PTR)layouts[i] & ~0xffff), "GetKeyboardLayout returned %p, expected %p\n", tmplayout, layouts[i]); + + /* The layout name only depends on the keyboard layout: the high word of HKL. */ + GetKeyboardLayoutNameW(tmpklid); + ok(!wcsicmp(klid, tmpklid), "GetKeyboardLayoutNameW returned %s, expected %s\n", debugstr_w(tmpklid), debugstr_w(klid)); + } - klid[0] = 0; - ret = GetKeyboardLayoutNameA(klid); - ok(ret, "GetKeyboardLayoutNameA failed %u\n", GetLastError()); - ok(!strcmp(klid, "00000409"), "expected 00000409, got %s\n", klid); + ActivateKeyboardLayout(layout, 0); } static void test_key_names(void) -- 2.31.0

2 1

[PATCH v3 5/5] msxml3: When saving XML use encoding specified in the processing instruction.
by Dmitry Timoshkov 27 Apr '21

27 Apr '21

Otherwise when a PI node with not default encoding is assigned to a document then saving an XML leads to document being encoded as UTF-8 while XML declaration has what PI specifies. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/domdoc.c | 70 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 68 insertions(+), 2 deletions(-) diff --git a/dlls/msxml3/domdoc.c b/dlls/msxml3/domdoc.c index cf4f0433218..8e29c67148e 100644 --- a/dlls/msxml3/domdoc.c +++ b/dlls/msxml3/domdoc.c @@ -2528,6 +2528,63 @@ static int XMLCALL domdoc_stream_save_closecallback(void *ctx) return 0; } +static char *xmldoc_encoding(IXMLDOMDocument3 *doc) +{ + HRESULT hr; + IXMLDOMNode *node; + char *encoding = NULL; + + hr = IXMLDOMDocument3_get_firstChild(doc, &node); + if (hr == S_OK) + { + DOMNodeType type; + + hr = IXMLDOMNode_get_nodeType(node, &type); + if (hr == S_OK && type == NODE_PROCESSING_INSTRUCTION) + { + IXMLDOMProcessingInstruction *pi; + IXMLDOMNode *item; + IXMLDOMNamedNodeMap *node_map; + + hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void **)&pi); + if (hr == S_OK) + { + hr = IXMLDOMNode_get_attributes(node, &node_map); + if (hr == S_OK) + { + static const WCHAR encodingW[] = {'e','n','c','o','d','i','n','g',0}; + BSTR bstr; + + bstr = SysAllocString(encodingW); + hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, bstr, &item); + SysFreeString(bstr); + if (hr == S_OK) + { + VARIANT var; + + hr = IXMLDOMNode_get_nodeValue(item, &var); + if (hr == S_OK) + { + if (V_VT(&var) == VT_BSTR) + encoding = (char *)xmlchar_from_wchar(V_BSTR(&var)); + + VariantClear(&var); + } + } + + IXMLDOMNamedNodeMap_Release(node_map); + } + + IXMLDOMProcessingInstruction_Release(pi); + } + } + + IXMLDOMNode_Release(node); + } + + return encoding; +} + static HRESULT WINAPI domdoc_save( IXMLDOMDocument3 *iface, VARIANT destination ) @@ -2566,8 +2623,12 @@ static HRESULT WINAPI domdoc_save( ret = IUnknown_QueryInterface(pUnk, &IID_IStream, (void**)&stream); if(ret == S_OK) { + char *encoding = xmldoc_encoding(iface); + + TRACE("using encoding %s\n", encoding ? debugstr_a(encoding) : "default"); ctx = xmlSaveToIO(domdoc_stream_save_writecallback, - domdoc_stream_save_closecallback, stream, NULL, XML_SAVE_NO_DECL); + domdoc_stream_save_closecallback, stream, encoding, XML_SAVE_NO_DECL); + heap_free(encoding); if(!ctx) { @@ -2581,6 +2642,7 @@ static HRESULT WINAPI domdoc_save( case VT_BSTR: case VT_BSTR | VT_BYREF: { + char *encoding; /* save with file path */ HANDLE handle = CreateFileW( (V_VT(&destination) & VT_BYREF)? *V_BSTRREF(&destination) : V_BSTR(&destination), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); @@ -2590,8 +2652,12 @@ static HRESULT WINAPI domdoc_save( return E_FAIL; } + encoding = xmldoc_encoding(iface); + TRACE("using encoding %s\n", encoding ? debugstr_a(encoding) : "default"); ctx = xmlSaveToIO(domdoc_save_writecallback, domdoc_save_closecallback, - handle, NULL, XML_SAVE_NO_DECL); + handle, encoding, XML_SAVE_NO_DECL); + heap_free(encoding); + if (!ctx) { CloseHandle(handle); -- 2.31.1

2 1

[PATCH v3 4/5] msxml3: Implement IXMLDOMNamedNodeMap::getNamedItem() for a processing instruction node.
by Dmitry Timoshkov 27 Apr '21

27 Apr '21

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/pi.c | 45 +++++++++++++++++++++++++++++++++++--- dlls/msxml3/tests/domdoc.c | 5 ----- 2 files changed, 42 insertions(+), 8 deletions(-) diff --git a/dlls/msxml3/pi.c b/dlls/msxml3/pi.c index fe291e72af8..59ceee767a1 100644 --- a/dlls/msxml3/pi.c +++ b/dlls/msxml3/pi.c @@ -813,6 +813,27 @@ static const struct IXMLDOMProcessingInstructionVtbl dom_pi_vtbl = dom_pi_put_data }; +static xmlAttrPtr node_has_prop(const xmlNode *node, const xmlChar *name) +{ + xmlAttrPtr prop; + + /* xmlHasNsProp accepts only nodes of type XML_ELEMENT_NODE, + * so we have to look for an attribute in the node by hand. + */ + + prop = node->properties; + + while (prop) + { + if (xmlStrEqual(prop->name, name)) + return prop; + + prop = prop->next; + } + + return NULL; +} + static HRESULT dom_pi_get_qualified_item(const xmlNodePtr node, BSTR name, BSTR uri, IXMLDOMNode **item) { @@ -822,10 +843,28 @@ static HRESULT dom_pi_get_qualified_item(const xmlNodePtr node, BSTR name, BSTR static HRESULT dom_pi_get_named_item(const xmlNodePtr node, BSTR name, IXMLDOMNode **item) { - FIXME("(%p)->(%s %p): stub\n", node, debugstr_w(name), item ); - if (item) + xmlChar *nameA; + xmlAttrPtr attr; + + TRACE("(%p)->(%s %p)\n", node, debugstr_w(name), item); + + if (!item) return E_POINTER; + + nameA = xmlchar_from_wchar(name); + if (!nameA) return E_OUTOFMEMORY; + + attr = node_has_prop(node, nameA); + heap_free(nameA); + + if (!attr) + { *item = NULL; - return S_FALSE; + return S_FALSE; + } + + *item = create_node((xmlNodePtr)attr); + + return S_OK; } static HRESULT dom_pi_set_named_item(xmlNodePtr node, IXMLDOMNode *newItem, IXMLDOMNode **namedItem) diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 59a8a243c87..39355034d97 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -8579,13 +8579,9 @@ todo_wine item = NULL; hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, _bstr_("encoding"), &item); -todo_wine ok(hr == S_OK, "got 0x%08x\n", hr); -todo_wine ok(item != NULL, "got NULL\n"); -if (hr == S_OK) -{ hr = IXMLDOMNode_get_nodeName(item, &bstr); ok(hr == S_OK, "got 0x%08x\n", hr); ok(!lstrcmpW(bstr, L"encoding"), "got %s\n", wine_dbgstr_w(bstr)); @@ -8597,7 +8593,6 @@ if (hr == S_OK) ok(V_VT(&var) == VT_BSTR, "got %u\n", V_VT(&var)); ok(!lstrcmpW(V_BSTR(&var), L"windows-1252"), "got %s\n", wine_dbgstr_w(V_BSTR(&var))); VariantClear(&var); -} IXMLDOMNamedNodeMap_Release(node_map); IXMLDOMNode_Release(node); -- 2.31.1

2 1

[PATCH 1/5] msxml3: When writing to stream \0 terminate output.
by Dmitry Timoshkov 27 Apr '21

27 Apr '21

This fixes heap corruption when running the domdoc tests. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/domdoc.c | 12 +++++++++++- dlls/msxml3/tests/domdoc.c | 3 --- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/dlls/msxml3/domdoc.c b/dlls/msxml3/domdoc.c index cf4f0433218..cb34632c203 100644 --- a/dlls/msxml3/domdoc.c +++ b/dlls/msxml3/domdoc.c @@ -2524,8 +2524,18 @@ static int XMLCALL domdoc_stream_save_writecallback(void *ctx, const char *buffe static int XMLCALL domdoc_stream_save_closecallback(void *ctx) { + ULONG written; + HRESULT hr; + + hr = IStream_Write((IStream*)ctx, "\0", 1, &written); + if (hr != S_OK) + { + WARN("stream write error: 0x%08x\n", hr); + hr = -1; + } + IStream_Release((IStream*)ctx); - return 0; + return hr; } static HRESULT WINAPI domdoc_save( diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 6f8e2b44ed3..63fc57527b4 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -8586,7 +8586,6 @@ todo_wine hr = GetHGlobalFromStream(stream, &global); ok(hr == S_OK, "got 0x%08x\n", hr); p = GlobalLock(global); - p[GlobalSize(global)] = 0; ok(!strcmp(p, xml2) || !strcmp(p, xml2_wine), "got %s\n", wine_dbgstr_a(p)); GlobalUnlock(global); @@ -8609,7 +8608,6 @@ todo_wine hr = GetHGlobalFromStream(stream, &global); ok(hr == S_OK, "got 0x%08x\n", hr); p = GlobalLock(global); - p[GlobalSize(global)] = 0; ok(!strcmp(p, xml2) || !strcmp(p, xml2_wine), "got %s\n", wine_dbgstr_a(p)); GlobalUnlock(global); @@ -8631,7 +8629,6 @@ todo_wine ok(hr == S_OK, "got 0x%08x\n", hr); p = GlobalLock(global); - p[GlobalSize(global)] = 0; ok(!strcmp(p, xml3) || !strcmp(p, xml3_wine), "got %s\n", wine_dbgstr_a(p)); GlobalUnlock(global); -- 2.31.1

3 5

[PATCH 5/5] msxml3: When saving XML use encoding specified in the processing instruction.
by Dmitry Timoshkov 27 Apr '21

27 Apr '21

Otherwise when a PI node with not default encoding is assigned to a document then saving an XML leads to document being encoded as UTF-8 while XML declaration has what PI specifies. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/domdoc.c | 70 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 68 insertions(+), 2 deletions(-) diff --git a/dlls/msxml3/domdoc.c b/dlls/msxml3/domdoc.c index cb34632c203..fd87aa52f30 100644 --- a/dlls/msxml3/domdoc.c +++ b/dlls/msxml3/domdoc.c @@ -2538,6 +2538,63 @@ static int XMLCALL domdoc_stream_save_closecallback(void *ctx) return hr; } +static char *xmldoc_encoding(IXMLDOMDocument3 *doc) +{ + HRESULT hr; + IXMLDOMNode *node; + char *encoding = NULL; + + hr = IXMLDOMDocument3_get_firstChild(doc, &node); + if (hr == S_OK) + { + DOMNodeType type; + + hr = IXMLDOMNode_get_nodeType(node, &type); + if (hr == S_OK && type == NODE_PROCESSING_INSTRUCTION) + { + IXMLDOMProcessingInstruction *pi; + IXMLDOMNode *item; + IXMLDOMNamedNodeMap *node_map; + + hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void **)&pi); + if (hr == S_OK) + { + hr = IXMLDOMNode_get_attributes(node, &node_map); + if (hr == S_OK) + { + static const WCHAR encodingW[] = {'e','n','c','o','d','i','n','g',0}; + BSTR bstr; + + bstr = SysAllocString(encodingW); + hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, bstr, &item); + SysFreeString(bstr); + if (hr == S_OK) + { + VARIANT var; + + hr = IXMLDOMNode_get_nodeValue(item, &var); + if (hr == S_OK) + { + if (V_VT(&var) == VT_BSTR) + encoding = (char *)xmlchar_from_wchar(V_BSTR(&var)); + + VariantClear(&var); + } + } + + IXMLDOMNamedNodeMap_Release(node_map); + } + + IXMLDOMProcessingInstruction_Release(pi); + } + } + + IXMLDOMNode_Release(node); + } + + return encoding; +} + static HRESULT WINAPI domdoc_save( IXMLDOMDocument3 *iface, VARIANT destination ) @@ -2576,8 +2633,12 @@ static HRESULT WINAPI domdoc_save( ret = IUnknown_QueryInterface(pUnk, &IID_IStream, (void**)&stream); if(ret == S_OK) { + char *encoding = xmldoc_encoding(iface); + + TRACE("using encoding %s\n", encoding ? debugstr_a(encoding) : "default"); ctx = xmlSaveToIO(domdoc_stream_save_writecallback, - domdoc_stream_save_closecallback, stream, NULL, XML_SAVE_NO_DECL); + domdoc_stream_save_closecallback, stream, encoding, XML_SAVE_NO_DECL); + heap_free(encoding); if(!ctx) { @@ -2591,6 +2652,7 @@ static HRESULT WINAPI domdoc_save( case VT_BSTR: case VT_BSTR | VT_BYREF: { + char *encoding; /* save with file path */ HANDLE handle = CreateFileW( (V_VT(&destination) & VT_BYREF)? *V_BSTRREF(&destination) : V_BSTR(&destination), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); @@ -2600,8 +2662,12 @@ static HRESULT WINAPI domdoc_save( return E_FAIL; } + encoding = xmldoc_encoding(iface); + TRACE("using encoding %s\n", encoding ? debugstr_a(encoding) : "default"); ctx = xmlSaveToIO(domdoc_save_writecallback, domdoc_save_closecallback, - handle, NULL, XML_SAVE_NO_DECL); + handle, encoding, XML_SAVE_NO_DECL); + heap_free(encoding); + if (!ctx) { CloseHandle(handle); -- 2.31.1

2 1

[PATCH 4/5] msxml3: Implement IXMLDOMNamedNodeMap::getNamedItem() for a processing instruction node.
by Dmitry Timoshkov 27 Apr '21

27 Apr '21

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/pi.c | 45 +++++++++++++++++++++++++++++++++++--- dlls/msxml3/tests/domdoc.c | 5 ----- 2 files changed, 42 insertions(+), 8 deletions(-) diff --git a/dlls/msxml3/pi.c b/dlls/msxml3/pi.c index fe291e72af8..59ceee767a1 100644 --- a/dlls/msxml3/pi.c +++ b/dlls/msxml3/pi.c @@ -813,6 +813,27 @@ static const struct IXMLDOMProcessingInstructionVtbl dom_pi_vtbl = dom_pi_put_data }; +static xmlAttrPtr node_has_prop(const xmlNode *node, const xmlChar *name) +{ + xmlAttrPtr prop; + + /* xmlHasNsProp accepts only nodes of type XML_ELEMENT_NODE, + * so we have to look for an attribute in the node by hand. + */ + + prop = node->properties; + + while (prop) + { + if (xmlStrEqual(prop->name, name)) + return prop; + + prop = prop->next; + } + + return NULL; +} + static HRESULT dom_pi_get_qualified_item(const xmlNodePtr node, BSTR name, BSTR uri, IXMLDOMNode **item) { @@ -822,10 +843,28 @@ static HRESULT dom_pi_get_qualified_item(const xmlNodePtr node, BSTR name, BSTR static HRESULT dom_pi_get_named_item(const xmlNodePtr node, BSTR name, IXMLDOMNode **item) { - FIXME("(%p)->(%s %p): stub\n", node, debugstr_w(name), item ); - if (item) + xmlChar *nameA; + xmlAttrPtr attr; + + TRACE("(%p)->(%s %p)\n", node, debugstr_w(name), item); + + if (!item) return E_POINTER; + + nameA = xmlchar_from_wchar(name); + if (!nameA) return E_OUTOFMEMORY; + + attr = node_has_prop(node, nameA); + heap_free(nameA); + + if (!attr) + { *item = NULL; - return S_FALSE; + return S_FALSE; + } + + *item = create_node((xmlNodePtr)attr); + + return S_OK; } static HRESULT dom_pi_set_named_item(xmlNodePtr node, IXMLDOMNode *newItem, IXMLDOMNode **namedItem) diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 2880edc8e0d..2e1eae7a7ea 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -8579,13 +8579,9 @@ todo_wine item = NULL; hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, _bstr_("encoding"), &item); -todo_wine ok(hr == S_OK, "got 0x%08x\n", hr); -todo_wine ok(item != NULL, "got NULL\n"); -if (hr == S_OK) -{ hr = IXMLDOMNode_get_nodeName(item, &bstr); ok(hr == S_OK, "got 0x%08x\n", hr); ok(!lstrcmpW(bstr, L"encoding"), "got %s\n", wine_dbgstr_w(bstr)); @@ -8597,7 +8593,6 @@ if (hr == S_OK) ok(V_VT(&var) == VT_BSTR, "got %u\n", V_VT(&var)); ok(!lstrcmpW(V_BSTR(&var), L"windows-1252"), "got %s\n", wine_dbgstr_w(V_BSTR(&var))); VariantClear(&var); -} IXMLDOMNamedNodeMap_Release(node_map); IXMLDOMNode_Release(node); -- 2.31.1

2 1

[PATCH 2/5] msxml3/tests: Add more tests for processing instruction attributes.
by Dmitry Timoshkov 27 Apr '21

27 Apr '21

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/tests/domdoc.c | 43 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 41 insertions(+), 2 deletions(-) diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 63fc57527b4..2880edc8e0d 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -46,6 +46,8 @@ #include "wine/heap.h" #include "wine/test.h" +#define XML_E_UNEXPECTED_ATTRIBUTE 0xC00CE56C + /* undef the #define in msxml2 so that we can access all versions */ #undef CLSID_DOMDocument @@ -8529,10 +8531,11 @@ static void test_createProcessingInstruction(void) static const char xml3_wine[] = "<?xml version=\"1.0\" standalone=\"yes\"?>\n<test/>\n"; IXMLDOMProcessingInstruction *pi; IXMLDOMDocument *doc; - IXMLDOMNode *node; + IXMLDOMNode *node, *item; + IXMLDOMNamedNodeMap *node_map; IXMLDOMElement *element; WCHAR buff[10]; - BSTR xml; + BSTR xml, bstr; VARIANT var; HRESULT hr; IStream *stream; @@ -8543,6 +8546,10 @@ static void test_createProcessingInstruction(void) doc = create_document(&IID_IXMLDOMDocument); + hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\" encoding=\"windows-1252\" dummy=\"value\""), &pi); +todo_wine + ok(hr == XML_E_UNEXPECTED_ATTRIBUTE, "got 0x%08x\n", hr); + /* test for BSTR handling, pass broken BSTR */ memcpy(&buff[2], L"test", 5 * sizeof(WCHAR)); /* just a big length */ @@ -8561,6 +8568,38 @@ static void test_createProcessingInstruction(void) ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXMLDOMDocument_appendChild(doc, node, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = IXMLDOMNode_get_attributes(node, &node_map); + ok(hr == S_OK, "got 0x%08x\n", hr); + + item = (void *)0xdeadbeef; + hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, _bstr_("xml"), &item); + ok(hr == S_FALSE, "got 0x%08x\n", hr); + ok(!item, "got %p\n", item); + + item = NULL; + hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, _bstr_("encoding"), &item); +todo_wine + ok(hr == S_OK, "got 0x%08x\n", hr); +todo_wine + ok(item != NULL, "got NULL\n"); + +if (hr == S_OK) +{ + hr = IXMLDOMNode_get_nodeName(item, &bstr); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(!lstrcmpW(bstr, L"encoding"), "got %s\n", wine_dbgstr_w(bstr)); + SysFreeString(bstr); + + VariantInit(&var); + hr = IXMLDOMNode_get_nodeValue(item, &var); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(V_VT(&var) == VT_BSTR, "got %u\n", V_VT(&var)); + ok(!lstrcmpW(V_BSTR(&var), L"windows-1252"), "got %s\n", wine_dbgstr_w(V_BSTR(&var))); + VariantClear(&var); +} + + IXMLDOMNamedNodeMap_Release(node_map); IXMLDOMNode_Release(node); IXMLDOMProcessingInstruction_Release(pi); -- 2.31.1

2 1

[PATCH 3/5] msxml3: Implement ::get_attributes() for "xml" processing instruction node.
by Dmitry Timoshkov 27 Apr '21

27 Apr '21

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/pi.c | 140 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 139 insertions(+), 1 deletion(-) diff --git a/dlls/msxml3/pi.c b/dlls/msxml3/pi.c index cea95708087..fe291e72af8 100644 --- a/dlls/msxml3/pi.c +++ b/dlls/msxml3/pi.c @@ -34,6 +34,7 @@ #include "ole2.h" #include "msxml6.h" +#include "xmlparser.h" #include "msxml_private.h" #include "wine/debug.h" @@ -287,6 +288,138 @@ static HRESULT WINAPI dom_pi_get_nextSibling( return node_get_next_sibling(&This->node, domNode); } +static HRESULT xml_get_value(xmlChar **p, xmlChar **value) +{ + xmlChar *v; + int len; + + while (isspace(**p)) *p += 1; + if (**p != '=') return XML_E_MISSINGEQUALS; + *p += 1; + + while (isspace(**p)) *p += 1; + if (**p != '"') return XML_E_MISSINGQUOTE; + *p += 1; + + v = *p; + while (**p && **p != '"') *p += 1; + if (!**p) return XML_E_EXPECTINGCLOSEQUOTE; + len = *p - v; + if (!len) return XML_E_MISSINGNAME; + *p += 1; + + *value = heap_alloc(len + 1); + if (!*value) return E_OUTOFMEMORY; + memcpy(*value, v, len); + *(*value + len) = 0; + + return S_OK; +} + +static void set_prop(xmlNodePtr node, xmlAttrPtr attr) +{ + xmlAttrPtr prop; + + if (!node->properties) + { + node->properties = attr; + return; + } + + prop = node->properties; + while (prop->next) prop = prop->next; + + prop->next = attr; +} + +static HRESULT parse_xml_decl(xmlNodePtr node) +{ + xmlChar *version, *encoding, *standalone, *p; + xmlAttrPtr attr; + HRESULT hr = S_OK; + + if (!node->content) return S_OK; + + version = encoding = standalone = NULL; + + p = node->content; + + while (*p) + { + while (isspace(*p)) p++; + if (!*p) break; + + if (!strncmp((const char *)p, "version", 7)) + { + p += 7; + if ((hr = xml_get_value(&p, &version)) != S_OK) goto fail; + } + else if (!strncmp((const char *)p, "encoding", 8)) + { + p += 8; + if ((hr = xml_get_value(&p, &encoding)) != S_OK) goto fail; + } + else if (!strncmp((const char *)p, "standalone", 10)) + { + p += 10; + if ((hr = xml_get_value(&p, &standalone)) != S_OK) goto fail; + } + else + { + FIXME("unexpected XML attribute %s\n", debugstr_a((const char *)p)); + hr = XML_E_UNEXPECTED_ATTRIBUTE; + goto fail; + } + } + + /* xmlSetProp/xmlSetNsProp accept only nodes of type XML_ELEMENT_NODE, + * so we have to create and assign attributes to a node by hand. + */ + + if (version) + { + attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"version", version); + if (attr) + { + attr->doc = node->doc; + set_prop(node, attr); + } + else hr = E_OUTOFMEMORY; + } + if (encoding) + { + attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"encoding", encoding); + if (attr) + { + attr->doc = node->doc; + set_prop(node, attr); + } + else hr = E_OUTOFMEMORY; + } + if (standalone) + { + attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"standalone", standalone); + if (attr) + { + attr->doc = node->doc; + set_prop(node, attr); + } + else hr = E_OUTOFMEMORY; + } + +fail: + if (hr != S_OK) + { + xmlFreePropList(node->properties); + node->properties = NULL; + } + + heap_free(version); + heap_free(encoding); + heap_free(standalone); + return hr; +} + static HRESULT WINAPI dom_pi_get_attributes( IXMLDOMProcessingInstruction *iface, IXMLDOMNamedNodeMap** map) @@ -307,7 +440,12 @@ static HRESULT WINAPI dom_pi_get_attributes( if (!strcmpW(name, xmlW)) { - FIXME("created dummy map for <?xml ?>\n"); + if (!This->node.node->properties) + { + hr = parse_xml_decl(This->node.node); + if (hr != S_OK) return S_FALSE; + } + *map = create_nodemap(This->node.node, &dom_pi_attr_map); SysFreeString(name); return S_OK; -- 2.31.1

1 0

[PATCH 5/5] comctl32/theme_dialog: Pass the WM_SYSCOLORCHANGE message to the original dialog procedure.
by Zhiyi Zhang 27 Apr '21

27 Apr '21

Even though themed dialog itself doesn't need to repaint after WM_SYSCOLORCHANGE is received, WM_SYSCOLORCHANGE should be passed to the original dialog procedure DefDlgProcW(), which can then forward WM_SYSCOLORCHANGE to its common controls and call COMCTL32_RefreshSysColors(). Fix wrong property sheet tab background color after winecfg disables theming. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=44511 Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/tests/misc.c | 12 ++---------- dlls/comctl32/theme_dialog.c | 8 +------- 2 files changed, 3 insertions(+), 17 deletions(-) diff --git a/dlls/comctl32/tests/misc.c b/dlls/comctl32/tests/misc.c index e2a1dc00bc4..9d3ca76e8d5 100644 --- a/dlls/comctl32/tests/misc.c +++ b/dlls/comctl32/tests/misc.c @@ -21,7 +21,6 @@ #include <stdio.h> #include <windows.h> #include <commctrl.h> -#include <uxtheme.h> #include "wine/test.h" #include "v6util.h" @@ -40,9 +39,8 @@ static BOOL (WINAPI * pStr_SetPtrW)(LPWSTR, LPCWSTR); static BOOL (WINAPI *pSetWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR, DWORD_PTR); static BOOL (WINAPI *pRemoveWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR); static LRESULT (WINAPI *pDefSubclassProc)(HWND, UINT, WPARAM, LPARAM); -static BOOL (WINAPI *pIsThemeActive)(void); -static HMODULE hComctl32, hUxtheme; +static HMODULE hComctl32; /* For message tests */ enum seq_index @@ -108,9 +106,6 @@ static BOOL init_functions_v6(void) COMCTL32_GET_PROC(412, RemoveWindowSubclass) COMCTL32_GET_PROC(413, DefSubclassProc) - hUxtheme = LoadLibraryA("uxtheme.dll"); - pIsThemeActive = (void *)GetProcAddress(hUxtheme, "IsThemeActive"); - return TRUE; } @@ -630,7 +625,6 @@ static INT_PTR CALLBACK wm_syscolorchange_dlg_proc(HWND hwnd, UINT message, WPAR static void test_WM_SYSCOLORCHANGE(void) { HWND parent, dialog; - BOOL todo; struct { DLGTEMPLATE tmplate; @@ -652,8 +646,7 @@ static void test_WM_SYSCOLORCHANGE(void) flush_sequences(sequences, NUM_MSG_SEQUENCES); SendMessageW(dialog, WM_SYSCOLORCHANGE, 0, 0); - todo = pIsThemeActive && pIsThemeActive(); - ok_sequence(sequences, CHILD_SEQ_INDEX, wm_syscolorchange_seq, "test dialog WM_SYSCOLORCHANGE", todo); + ok_sequence(sequences, CHILD_SEQ_INDEX, wm_syscolorchange_seq, "test dialog WM_SYSCOLORCHANGE", FALSE); EndDialog(dialog, 0); DestroyWindow(parent); @@ -687,5 +680,4 @@ START_TEST(misc) unload_v6_module(ctx_cookie, hCtx); FreeLibrary(hComctl32); - FreeLibrary(hUxtheme); } diff --git a/dlls/comctl32/theme_dialog.c b/dlls/comctl32/theme_dialog.c index 29007ba5c60..0f7835ae32f 100644 --- a/dlls/comctl32/theme_dialog.c +++ b/dlls/comctl32/theme_dialog.c @@ -63,13 +63,7 @@ LRESULT CALLBACK THEMING_DialogSubclassProc (HWND hWnd, UINT msg, OpenThemeData( hWnd, themeClass ); InvalidateRect( hWnd, NULL, TRUE ); return 0; - - case WM_SYSCOLORCHANGE: - if (!doTheming) return THEMING_CallOriginalClass (hWnd, msg, wParam, lParam); - /* Do nothing. When themed, a WM_THEMECHANGED will be received, too, - * which will do the repaint. */ - break; - + case WM_ERASEBKGND: if (!doTheming) return THEMING_CallOriginalClass (hWnd, msg, wParam, lParam); { -- 2.30.2

1 0

[PATCH 4/5] comctl32/test: Test that WM_SYSCOLORCHANGE should always be passed to the dialog procedure.
by Zhiyi Zhang 27 Apr '21

27 Apr '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/tests/misc.c | 59 +++++++++++++++++++++++++++++++++++++- 1 file changed, 58 insertions(+), 1 deletion(-) diff --git a/dlls/comctl32/tests/misc.c b/dlls/comctl32/tests/misc.c index 15ff3b2d099..e2a1dc00bc4 100644 --- a/dlls/comctl32/tests/misc.c +++ b/dlls/comctl32/tests/misc.c @@ -21,6 +21,7 @@ #include <stdio.h> #include <windows.h> #include <commctrl.h> +#include <uxtheme.h> #include "wine/test.h" #include "v6util.h" @@ -39,8 +40,9 @@ static BOOL (WINAPI * pStr_SetPtrW)(LPWSTR, LPCWSTR); static BOOL (WINAPI *pSetWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR, DWORD_PTR); static BOOL (WINAPI *pRemoveWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR); static LRESULT (WINAPI *pDefSubclassProc)(HWND, UINT, WPARAM, LPARAM); +static BOOL (WINAPI *pIsThemeActive)(void); -static HMODULE hComctl32 = 0; +static HMODULE hComctl32, hUxtheme; /* For message tests */ enum seq_index @@ -106,6 +108,9 @@ static BOOL init_functions_v6(void) COMCTL32_GET_PROC(412, RemoveWindowSubclass) COMCTL32_GET_PROC(413, DefSubclassProc) + hUxtheme = LoadLibraryA("uxtheme.dll"); + pIsThemeActive = (void *)GetProcAddress(hUxtheme, "IsThemeActive"); + return TRUE; } @@ -604,6 +609,56 @@ static void test_WM_THEMECHANGED(void) DestroyWindow(parent); } +static const struct message wm_syscolorchange_seq[] = +{ + {WM_SYSCOLORCHANGE, sent | wparam | lparam}, + {0}, +}; + +static INT_PTR CALLBACK wm_syscolorchange_dlg_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) +{ + struct message msg = {0}; + + msg.message = message; + msg.flags = sent | wparam | lparam; + msg.wParam = wParam; + msg.lParam = lParam; + add_message(sequences, CHILD_SEQ_INDEX, &msg); + return FALSE; +} + +static void test_WM_SYSCOLORCHANGE(void) +{ + HWND parent, dialog; + BOOL todo; + struct + { + DLGTEMPLATE tmplate; + WORD menu; + WORD class; + WORD title; + } temp = {0}; + + parent = CreateWindowExA(0, WC_STATICA, "parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 100, 100, + 200, 200, 0, 0, 0, NULL); + ok(!!parent, "CreateWindowExA failed, error %d\n", GetLastError()); + + temp.tmplate.style = WS_CHILD | WS_VISIBLE; + temp.tmplate.cx = 50; + temp.tmplate.cy = 50; + dialog = CreateDialogIndirectParamA(NULL, &temp.tmplate, parent, wm_syscolorchange_dlg_proc, 0); + ok(!!dialog, "CreateDialogIndirectParamA failed, error %d\n", GetLastError()); + flush_events(); + flush_sequences(sequences, NUM_MSG_SEQUENCES); + + SendMessageW(dialog, WM_SYSCOLORCHANGE, 0, 0); + todo = pIsThemeActive && pIsThemeActive(); + ok_sequence(sequences, CHILD_SEQ_INDEX, wm_syscolorchange_seq, "test dialog WM_SYSCOLORCHANGE", todo); + + EndDialog(dialog, 0); + DestroyWindow(parent); +} + START_TEST(misc) { ULONG_PTR ctx_cookie; @@ -628,7 +683,9 @@ START_TEST(misc) test_builtin_classes(); test_LoadIconWithScaleDown(); test_WM_THEMECHANGED(); + test_WM_SYSCOLORCHANGE(); unload_v6_module(ctx_cookie, hCtx); FreeLibrary(hComctl32); + FreeLibrary(hUxtheme); } -- 2.30.2

1 0

[PATCH 3/5] comctl32/theming: Register themed dialog and scrollbar even when theming is not active.
by Zhiyi Zhang 27 Apr '21

27 Apr '21

So that we can turn on theming in runtime. Otherwise, themed dialog and scrollbar are not enabled even if a theme is made active in winecfg if theming is disabled at start. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=44511 Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/tests/misc.c | 2 +- dlls/comctl32/theming.c | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/dlls/comctl32/tests/misc.c b/dlls/comctl32/tests/misc.c index 4b0c1f9a4d0..15ff3b2d099 100644 --- a/dlls/comctl32/tests/misc.c +++ b/dlls/comctl32/tests/misc.c @@ -580,7 +580,7 @@ static void test_WM_THEMECHANGED(void) {TRACKBAR_CLASSA, wm_themechanged_paint_seq}, {WC_TREEVIEWA, wm_themechanged_paint_erase_seq, 1, {0x1128}}, {UPDOWN_CLASSA, wm_themechanged_paint_erase_seq}, - {WC_SCROLLBARA, wm_themechanged_paint_erase_seq, 1, {SBM_GETSCROLLINFO}, TRUE}, + {WC_SCROLLBARA, wm_themechanged_paint_erase_seq, 1, {SBM_GETSCROLLINFO}}, }; parent = CreateWindowExA(0, WC_STATICA, "parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 100, 100, diff --git a/dlls/comctl32/theming.c b/dlls/comctl32/theming.c index ed7bb0a5b33..8078e661b76 100644 --- a/dlls/comctl32/theming.c +++ b/dlls/comctl32/theming.c @@ -26,7 +26,6 @@ #include "wingdi.h" #include "winuser.h" #include "comctl32.h" -#include "uxtheme.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(theming); @@ -96,8 +95,6 @@ void THEMING_Initialize (void) { unsigned int i; - if (!IsThemeActive()) return; - atSubclassProp = GlobalAddAtomW (L"CC32ThemingSubCl"); atRefDataProp = GlobalAddAtomW (L"CC32ThemingData"); -- 2.30.2

1 0

[PATCH 2/5] comctl32: Repaint after the WM_THEMECHANGED message is received.
by Zhiyi Zhang 27 Apr '21

27 Apr '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/button.c | 1 + dlls/comctl32/combo.c | 1 + dlls/comctl32/datetime.c | 1 + dlls/comctl32/edit.c | 1 + dlls/comctl32/header.c | 2 +- dlls/comctl32/ipaddress.c | 1 + dlls/comctl32/listbox.c | 1 + dlls/comctl32/listview.c | 1 + dlls/comctl32/monthcal.c | 1 + dlls/comctl32/pager.c | 9 +++++++++ dlls/comctl32/progress.c | 2 +- dlls/comctl32/static.c | 4 ++++ dlls/comctl32/status.c | 1 + dlls/comctl32/tab.c | 1 + dlls/comctl32/tests/misc.c | 36 ++++++++++++++++----------------- dlls/comctl32/theme_scrollbar.c | 1 + dlls/comctl32/toolbar.c | 1 + dlls/comctl32/trackbar.c | 1 + dlls/comctl32/treeview.c | 1 + dlls/comctl32/updown.c | 2 +- 20 files changed, 48 insertions(+), 21 deletions(-) diff --git a/dlls/comctl32/button.c b/dlls/comctl32/button.c index b5a9ee7f7f6..d3dcc67b169 100644 --- a/dlls/comctl32/button.c +++ b/dlls/comctl32/button.c @@ -534,6 +534,7 @@ static LRESULT CALLBACK BUTTON_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, L theme = GetWindowTheme( hWnd ); CloseThemeData( theme ); OpenThemeData( hWnd, WC_BUTTONW ); + InvalidateRect( hWnd, NULL, TRUE ); break; case WM_ERASEBKGND: diff --git a/dlls/comctl32/combo.c b/dlls/comctl32/combo.c index 887587a053b..074f54f0937 100644 --- a/dlls/comctl32/combo.c +++ b/dlls/comctl32/combo.c @@ -1698,6 +1698,7 @@ static LRESULT CALLBACK COMBO_WindowProc( HWND hwnd, UINT message, WPARAM wParam theme = GetWindowTheme( hwnd ); CloseThemeData( theme ); OpenThemeData( hwnd, WC_COMBOBOXW ); + InvalidateRect( hwnd, NULL, TRUE ); break; case WM_PRINTCLIENT: diff --git a/dlls/comctl32/datetime.c b/dlls/comctl32/datetime.c index 93bca8c2f5c..ac5268f146c 100644 --- a/dlls/comctl32/datetime.c +++ b/dlls/comctl32/datetime.c @@ -1544,6 +1544,7 @@ static LRESULT DATETIME_ThemeChanged (DATETIME_INFO *infoPtr) theme = GetWindowTheme(infoPtr->hwndSelf); CloseThemeData(theme); OpenThemeData(infoPtr->hwndSelf, themeClass); + InvalidateRect(infoPtr->hwndSelf, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/edit.c b/dlls/comctl32/edit.c index 639443bc338..d9354a107b1 100644 --- a/dlls/comctl32/edit.c +++ b/dlls/comctl32/edit.c @@ -5097,6 +5097,7 @@ static LRESULT CALLBACK EDIT_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPAR case WM_THEMECHANGED: CloseThemeData(GetWindowTheme(hwnd)); OpenThemeData(hwnd, WC_EDITW); + InvalidateRect(hwnd, NULL, TRUE); break; default: diff --git a/dlls/comctl32/header.c b/dlls/comctl32/header.c index 085549fed65..8bb39261dd1 100644 --- a/dlls/comctl32/header.c +++ b/dlls/comctl32/header.c @@ -2110,7 +2110,7 @@ static LRESULT HEADER_ThemeChanged(const HEADER_INFO *infoPtr) HTHEME theme = GetWindowTheme(infoPtr->hwndSelf); CloseThemeData(theme); OpenThemeData(infoPtr->hwndSelf, themeClass); - InvalidateRect(infoPtr->hwndSelf, NULL, FALSE); + InvalidateRect(infoPtr->hwndSelf, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/ipaddress.c b/dlls/comctl32/ipaddress.c index b6302a89ba6..f24fb4a9335 100644 --- a/dlls/comctl32/ipaddress.c +++ b/dlls/comctl32/ipaddress.c @@ -462,6 +462,7 @@ static LRESULT IPADDRESS_ThemeChanged (const IPADDRESS_INFO *infoPtr) HTHEME theme = GetWindowTheme (infoPtr->Self); CloseThemeData (theme); theme = OpenThemeData (theme, WC_EDITW); + InvalidateRect (infoPtr->Self, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/listbox.c b/dlls/comctl32/listbox.c index 239f54aafab..f9283f45282 100644 --- a/dlls/comctl32/listbox.c +++ b/dlls/comctl32/listbox.c @@ -3136,6 +3136,7 @@ static LRESULT CALLBACK LISTBOX_WindowProc( HWND hwnd, UINT msg, WPARAM wParam, theme = GetWindowTheme( hwnd ); CloseThemeData( theme ); OpenThemeData( hwnd, WC_LISTBOXW ); + InvalidateRect( hwnd, NULL, TRUE ); break; default: diff --git a/dlls/comctl32/listview.c b/dlls/comctl32/listview.c index 799ec509f33..05a772ab175 100644 --- a/dlls/comctl32/listview.c +++ b/dlls/comctl32/listview.c @@ -9345,6 +9345,7 @@ static LRESULT LISTVIEW_ThemeChanged(const LISTVIEW_INFO *infoPtr) HTHEME theme = GetWindowTheme(infoPtr->hwndSelf); CloseThemeData(theme); OpenThemeData(infoPtr->hwndSelf, themeClass); + InvalidateRect(infoPtr->hwndSelf, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/monthcal.c b/dlls/comctl32/monthcal.c index 98c682df334..c0bec07f477 100644 --- a/dlls/comctl32/monthcal.c +++ b/dlls/comctl32/monthcal.c @@ -2697,6 +2697,7 @@ static LRESULT theme_changed (const MONTHCAL_INFO* infoPtr) HTHEME theme = GetWindowTheme (infoPtr->hwndSelf); CloseThemeData (theme); OpenThemeData (infoPtr->hwndSelf, themeClass); + InvalidateRect (infoPtr->hwndSelf, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/pager.c b/dlls/comctl32/pager.c index 4763ed5640d..b8baa93e15f 100644 --- a/dlls/comctl32/pager.c +++ b/dlls/comctl32/pager.c @@ -966,6 +966,12 @@ PAGER_Timer (PAGER_INFO* infoPtr, INT nTimerId) return 0; } +static LRESULT PAGER_ThemeChanged (const PAGER_INFO* infoPtr) +{ + InvalidateRect(infoPtr->hwndSelf, NULL, TRUE); + return 0; +} + static LRESULT PAGER_EraseBackground (const PAGER_INFO* infoPtr, HDC hdc) { @@ -1553,6 +1559,9 @@ PAGER_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) case WM_COMMAND: return SendMessageW (infoPtr->hwndNotify, uMsg, wParam, lParam); + case WM_THEMECHANGED: + return PAGER_ThemeChanged (infoPtr); + default: return DefWindowProcW (hwnd, uMsg, wParam, lParam); } diff --git a/dlls/comctl32/progress.c b/dlls/comctl32/progress.c index 5cf2ccda20f..fb4c2dc66dd 100644 --- a/dlls/comctl32/progress.c +++ b/dlls/comctl32/progress.c @@ -615,7 +615,7 @@ static LRESULT WINAPI ProgressWindowProc(HWND hwnd, UINT message, dwExStyle |= WS_EX_STATICEDGE; SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle); - InvalidateRect (hwnd, NULL, FALSE); + InvalidateRect (hwnd, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/static.c b/dlls/comctl32/static.c index b3254e5761b..2bd2b22bc20 100644 --- a/dlls/comctl32/static.c +++ b/dlls/comctl32/static.c @@ -505,6 +505,10 @@ static LRESULT CALLBACK STATIC_WindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, STATIC_TryPaintFcn( hwnd, full_style ); break; + case WM_THEMECHANGED: + InvalidateRect( hwnd, 0, TRUE ); + break; + case WM_NCCREATE: { CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam; diff --git a/dlls/comctl32/status.c b/dlls/comctl32/status.c index 0c3a90887c8..7bc9ec4386f 100644 --- a/dlls/comctl32/status.c +++ b/dlls/comctl32/status.c @@ -1111,6 +1111,7 @@ static LRESULT theme_changed (const STATUS_INFO* infoPtr) HTHEME theme = GetWindowTheme (infoPtr->Self); CloseThemeData (theme); OpenThemeData (infoPtr->Self, themeClass); + InvalidateRect (infoPtr->Self, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/tab.c b/dlls/comctl32/tab.c index 3bb5310d1f3..017719a183d 100644 --- a/dlls/comctl32/tab.c +++ b/dlls/comctl32/tab.c @@ -3106,6 +3106,7 @@ static LRESULT theme_changed(const TAB_INFO *infoPtr) HTHEME theme = GetWindowTheme (infoPtr->hwnd); CloseThemeData (theme); OpenThemeData (infoPtr->hwnd, themeClass); + InvalidateRect (infoPtr->hwnd, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/tests/misc.c b/dlls/comctl32/tests/misc.c index f4fcb300bb2..4b0c1f9a4d0 100644 --- a/dlls/comctl32/tests/misc.c +++ b/dlls/comctl32/tests/misc.c @@ -556,30 +556,30 @@ static void test_WM_THEMECHANGED(void) static const struct wm_themechanged_test tests[] = { {ANIMATE_CLASSA, wm_themechanged_no_paint_seq}, - {WC_BUTTONA, wm_themechanged_paint_erase_seq, 2, {WM_GETTEXT, WM_GETTEXTLENGTH}, TRUE}, - {WC_COMBOBOXA, wm_themechanged_paint_erase_seq, 1, {WM_CTLCOLOREDIT}, TRUE}, + {WC_BUTTONA, wm_themechanged_paint_erase_seq, 2, {WM_GETTEXT, WM_GETTEXTLENGTH}}, + {WC_COMBOBOXA, wm_themechanged_paint_erase_seq, 1, {WM_CTLCOLOREDIT}}, {WC_COMBOBOXEXA, wm_themechanged_no_paint_seq}, - {DATETIMEPICK_CLASSA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, - {WC_EDITA, wm_themechanged_paint_erase_seq, 7, {WM_GETTEXTLENGTH, WM_GETFONT, EM_GETSEL, EM_GETRECT, EM_CHARFROMPOS, EM_LINEFROMCHAR, EM_POSFROMCHAR}, TRUE}, - {WC_HEADERA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {DATETIMEPICK_CLASSA, wm_themechanged_paint_erase_seq}, + {WC_EDITA, wm_themechanged_paint_erase_seq, 7, {WM_GETTEXTLENGTH, WM_GETFONT, EM_GETSEL, EM_GETRECT, EM_CHARFROMPOS, EM_LINEFROMCHAR, EM_POSFROMCHAR}}, + {WC_HEADERA, wm_themechanged_paint_erase_seq}, {HOTKEY_CLASSA, wm_themechanged_no_paint_seq}, - {WC_IPADDRESSA, wm_themechanged_paint_erase_seq, 1, {WM_CTLCOLOREDIT}, TRUE}, - {WC_LISTBOXA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, - {WC_LISTVIEWA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, - {MONTHCAL_CLASSA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {WC_IPADDRESSA, wm_themechanged_paint_erase_seq, 1, {WM_CTLCOLOREDIT}}, + {WC_LISTBOXA, wm_themechanged_paint_erase_seq}, + {WC_LISTVIEWA, wm_themechanged_paint_erase_seq}, + {MONTHCAL_CLASSA, wm_themechanged_paint_erase_seq}, {WC_NATIVEFONTCTLA, wm_themechanged_no_paint_seq}, - {WC_PAGESCROLLERA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, - {PROGRESS_CLASSA, wm_themechanged_paint_erase_seq, 3, {WM_STYLECHANGING, WM_STYLECHANGED, WM_NCPAINT}, TRUE}, + {WC_PAGESCROLLERA, wm_themechanged_paint_erase_seq}, + {PROGRESS_CLASSA, wm_themechanged_paint_erase_seq, 3, {WM_STYLECHANGING, WM_STYLECHANGED, WM_NCPAINT}}, {REBARCLASSNAMEA, wm_themechanged_no_paint_seq, 1, {WM_WINDOWPOSCHANGING}}, - {WC_STATICA, wm_themechanged_paint_erase_seq, 2, {WM_GETTEXT, WM_GETTEXTLENGTH}, TRUE}, - {STATUSCLASSNAMEA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {WC_STATICA, wm_themechanged_paint_erase_seq, 2, {WM_GETTEXT, WM_GETTEXTLENGTH}}, + {STATUSCLASSNAMEA, wm_themechanged_paint_erase_seq}, {"SysLink", wm_themechanged_no_paint_seq}, - {WC_TABCONTROLA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, - {TOOLBARCLASSNAMEA, wm_themechanged_paint_erase_seq, 1, {WM_WINDOWPOSCHANGING}, TRUE}, + {WC_TABCONTROLA, wm_themechanged_paint_erase_seq}, + {TOOLBARCLASSNAMEA, wm_themechanged_paint_erase_seq, 1, {WM_WINDOWPOSCHANGING}}, {TOOLTIPS_CLASSA, wm_themechanged_no_paint_seq}, - {TRACKBAR_CLASSA, wm_themechanged_paint_seq, 0, {0}, TRUE}, - {WC_TREEVIEWA, wm_themechanged_paint_erase_seq, 1, {0x1128}, TRUE}, - {UPDOWN_CLASSA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {TRACKBAR_CLASSA, wm_themechanged_paint_seq}, + {WC_TREEVIEWA, wm_themechanged_paint_erase_seq, 1, {0x1128}}, + {UPDOWN_CLASSA, wm_themechanged_paint_erase_seq}, {WC_SCROLLBARA, wm_themechanged_paint_erase_seq, 1, {SBM_GETSCROLLINFO}, TRUE}, }; diff --git a/dlls/comctl32/theme_scrollbar.c b/dlls/comctl32/theme_scrollbar.c index 27d31bd4ac5..304ff5bacbc 100644 --- a/dlls/comctl32/theme_scrollbar.c +++ b/dlls/comctl32/theme_scrollbar.c @@ -547,6 +547,7 @@ LRESULT CALLBACK THEMING_ScrollbarSubclassProc (HWND hwnd, UINT msg, theme = GetWindowTheme(hwnd); CloseThemeData(theme); OpenThemeData(hwnd, themeClass); + InvalidateRect(hwnd, NULL, TRUE); break; case WM_SYSCOLORCHANGE: diff --git a/dlls/comctl32/toolbar.c b/dlls/comctl32/toolbar.c index 667a2f4c277..1aeb499c45f 100644 --- a/dlls/comctl32/toolbar.c +++ b/dlls/comctl32/toolbar.c @@ -6556,6 +6556,7 @@ static LRESULT theme_changed (HWND hwnd) HTHEME theme = GetWindowTheme (hwnd); CloseThemeData (theme); OpenThemeData (hwnd, themeClass); + InvalidateRect (hwnd, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/trackbar.c b/dlls/comctl32/trackbar.c index 66522fd8582..1859cf0f516 100644 --- a/dlls/comctl32/trackbar.c +++ b/dlls/comctl32/trackbar.c @@ -1720,6 +1720,7 @@ static LRESULT theme_changed (const TRACKBAR_INFO* infoPtr) HTHEME theme = GetWindowTheme (infoPtr->hwndSelf); CloseThemeData (theme); OpenThemeData (infoPtr->hwndSelf, themeClass); + InvalidateRect (infoPtr->hwndSelf, NULL, FALSE); return 0; } diff --git a/dlls/comctl32/treeview.c b/dlls/comctl32/treeview.c index a45096d8239..98cf5489f2b 100644 --- a/dlls/comctl32/treeview.c +++ b/dlls/comctl32/treeview.c @@ -5633,6 +5633,7 @@ static LRESULT TREEVIEW_ThemeChanged(const TREEVIEW_INFO *infoPtr) HTHEME theme = GetWindowTheme (infoPtr->hwnd); CloseThemeData (theme); OpenThemeData (infoPtr->hwnd, themeClass); + InvalidateRect (infoPtr->hwnd, NULL, TRUE); return 0; } diff --git a/dlls/comctl32/updown.c b/dlls/comctl32/updown.c index a804018d5f8..d5625839db3 100644 --- a/dlls/comctl32/updown.c +++ b/dlls/comctl32/updown.c @@ -966,7 +966,7 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam, L theme = GetWindowTheme (hwnd); CloseThemeData (theme); OpenThemeData (hwnd, L"Spin"); - InvalidateRect (hwnd, NULL, FALSE); + InvalidateRect (hwnd, NULL, TRUE); break; case WM_TIMER: -- 2.30.2

1 0

[PATCH 1/5] comctl32/tests: Test that WM_THEMECHANGED should invalidate client area.
by Zhiyi Zhang 27 Apr '21

27 Apr '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/tests/misc.c | 206 ++++++++++++++++++++++++++++++++++++- 1 file changed, 205 insertions(+), 1 deletion(-) diff --git a/dlls/comctl32/tests/misc.c b/dlls/comctl32/tests/misc.c index a3ba2028873..f4fcb300bb2 100644 --- a/dlls/comctl32/tests/misc.c +++ b/dlls/comctl32/tests/misc.c @@ -24,6 +24,7 @@ #include "wine/test.h" #include "v6util.h" +#include "msg.h" static PVOID (WINAPI * pAlloc)(LONG); static PVOID (WINAPI * pReAlloc)(PVOID, LONG); @@ -35,8 +36,21 @@ static BOOL (WINAPI * pStr_SetPtrA)(LPSTR, LPCSTR); static INT (WINAPI * pStr_GetPtrW)(LPCWSTR, LPWSTR, INT); static BOOL (WINAPI * pStr_SetPtrW)(LPWSTR, LPCWSTR); +static BOOL (WINAPI *pSetWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR, DWORD_PTR); +static BOOL (WINAPI *pRemoveWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR); +static LRESULT (WINAPI *pDefSubclassProc)(HWND, UINT, WPARAM, LPARAM); + static HMODULE hComctl32 = 0; +/* For message tests */ +enum seq_index +{ + CHILD_SEQ_INDEX, + NUM_MSG_SEQUENCES +}; + +static struct msg_sequence *sequences[NUM_MSG_SEQUENCES]; + static char testicon_data[] = { 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x02, 0x02, 0x00, 0x00, 0x01, 0x00, @@ -79,6 +93,40 @@ static BOOL InitFunctionPtrs(void) return TRUE; } +static BOOL init_functions_v6(void) +{ + hComctl32 = LoadLibraryA("comctl32.dll"); + if (!hComctl32) + { + trace("Could not load comctl32.dll version 6\n"); + return FALSE; + } + + COMCTL32_GET_PROC(410, SetWindowSubclass) + COMCTL32_GET_PROC(412, RemoveWindowSubclass) + COMCTL32_GET_PROC(413, DefSubclassProc) + + return TRUE; +} + +/* try to make sure pending X events have been processed before continuing */ +static void flush_events(void) +{ + MSG msg; + int diff = 200; + int min_timeout = 100; + DWORD time = GetTickCount() + diff; + + while (diff > 0) + { + if (MsgWaitForMultipleObjects(0, NULL, FALSE, min_timeout, QS_ALLINPUT) == WAIT_TIMEOUT) + break; + while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) + DispatchMessageA(&msg); + diff = time - GetTickCount(); + } +} + static void test_GetPtrAW(void) { if (pStr_GetPtrA) @@ -406,6 +454,156 @@ static void test_comctl32_classes(BOOL v6) check_class("SysLink", v6, CS_GLOBALCLASS, 0, FALSE); } +struct wm_themechanged_test +{ + const char *class; + const struct message *expected_msg; + int ignored_msg_count; + DWORD ignored_msgs[16]; + BOOL todo; +}; + +static BOOL ignore_message(UINT msg) +{ + /* these are always ignored */ + return (msg >= 0xc000 || + msg == WM_GETICON || + msg == WM_GETOBJECT || + msg == WM_TIMECHANGE || + msg == WM_DISPLAYCHANGE || + msg == WM_DEVICECHANGE || + msg == WM_DWMNCRENDERINGCHANGED || + msg == WM_WININICHANGE || + msg == WM_CHILDACTIVATE); +} + +static LRESULT CALLBACK test_wm_themechanged_proc(HWND hwnd, UINT message, WPARAM wParam, + LPARAM lParam, UINT_PTR id, DWORD_PTR ref_data) +{ + const struct wm_themechanged_test *test = (const struct wm_themechanged_test *)ref_data; + static int defwndproc_counter = 0; + struct message msg = {0}; + LRESULT ret; + int i; + + if (ignore_message(message)) + return pDefSubclassProc(hwnd, message, wParam, lParam); + + /* Extra messages to be ignored for a test case */ + for (i = 0; i < test->ignored_msg_count; ++i) + { + if (message == test->ignored_msgs[i]) + return pDefSubclassProc(hwnd, message, wParam, lParam); + } + + msg.message = message; + msg.flags = sent | wparam | lparam; + if (defwndproc_counter) + msg.flags |= defwinproc; + msg.wParam = wParam; + msg.lParam = lParam; + add_message(sequences, CHILD_SEQ_INDEX, &msg); + + if (message == WM_NCDESTROY) + pRemoveWindowSubclass(hwnd, test_wm_themechanged_proc, 0); + + ++defwndproc_counter; + ret = pDefSubclassProc(hwnd, message, wParam, lParam); + --defwndproc_counter; + + return ret; +} + +static HWND create_control(const char *class, DWORD style, HWND parent, DWORD_PTR data) +{ + HWND hwnd; + + if (parent) + style |= WS_CHILD; + hwnd = CreateWindowExA(0, class, "test", style, 0, 0, 50, 20, parent, 0, 0, NULL); + ok(!!hwnd, "Failed to create %s style %#x parent %p\n", class, style, parent); + pSetWindowSubclass(hwnd, test_wm_themechanged_proc, 0, data); + return hwnd; +} + +static const struct message wm_themechanged_paint_erase_seq[] = +{ + {WM_THEMECHANGED, sent | wparam | lparam}, + {WM_PAINT, sent | wparam | lparam}, + {WM_ERASEBKGND, sent | defwinproc}, + {0}, +}; + +static const struct message wm_themechanged_paint_seq[] = +{ + {WM_THEMECHANGED, sent | wparam | lparam}, + {WM_PAINT, sent | wparam | lparam}, + {0}, +}; + +static const struct message wm_themechanged_no_paint_seq[] = +{ + {WM_THEMECHANGED, sent | wparam | lparam}, + {0}, +}; + +static void test_WM_THEMECHANGED(void) +{ + HWND parent, child; + char buffer[64]; + int i; + + static const struct wm_themechanged_test tests[] = + { + {ANIMATE_CLASSA, wm_themechanged_no_paint_seq}, + {WC_BUTTONA, wm_themechanged_paint_erase_seq, 2, {WM_GETTEXT, WM_GETTEXTLENGTH}, TRUE}, + {WC_COMBOBOXA, wm_themechanged_paint_erase_seq, 1, {WM_CTLCOLOREDIT}, TRUE}, + {WC_COMBOBOXEXA, wm_themechanged_no_paint_seq}, + {DATETIMEPICK_CLASSA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {WC_EDITA, wm_themechanged_paint_erase_seq, 7, {WM_GETTEXTLENGTH, WM_GETFONT, EM_GETSEL, EM_GETRECT, EM_CHARFROMPOS, EM_LINEFROMCHAR, EM_POSFROMCHAR}, TRUE}, + {WC_HEADERA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {HOTKEY_CLASSA, wm_themechanged_no_paint_seq}, + {WC_IPADDRESSA, wm_themechanged_paint_erase_seq, 1, {WM_CTLCOLOREDIT}, TRUE}, + {WC_LISTBOXA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {WC_LISTVIEWA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {MONTHCAL_CLASSA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {WC_NATIVEFONTCTLA, wm_themechanged_no_paint_seq}, + {WC_PAGESCROLLERA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {PROGRESS_CLASSA, wm_themechanged_paint_erase_seq, 3, {WM_STYLECHANGING, WM_STYLECHANGED, WM_NCPAINT}, TRUE}, + {REBARCLASSNAMEA, wm_themechanged_no_paint_seq, 1, {WM_WINDOWPOSCHANGING}}, + {WC_STATICA, wm_themechanged_paint_erase_seq, 2, {WM_GETTEXT, WM_GETTEXTLENGTH}, TRUE}, + {STATUSCLASSNAMEA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {"SysLink", wm_themechanged_no_paint_seq}, + {WC_TABCONTROLA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {TOOLBARCLASSNAMEA, wm_themechanged_paint_erase_seq, 1, {WM_WINDOWPOSCHANGING}, TRUE}, + {TOOLTIPS_CLASSA, wm_themechanged_no_paint_seq}, + {TRACKBAR_CLASSA, wm_themechanged_paint_seq, 0, {0}, TRUE}, + {WC_TREEVIEWA, wm_themechanged_paint_erase_seq, 1, {0x1128}, TRUE}, + {UPDOWN_CLASSA, wm_themechanged_paint_erase_seq, 0, {0}, TRUE}, + {WC_SCROLLBARA, wm_themechanged_paint_erase_seq, 1, {SBM_GETSCROLLINFO}, TRUE}, + }; + + parent = CreateWindowExA(0, WC_STATICA, "parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 100, 100, + 200, 200, 0, 0, 0, NULL); + ok(!!parent, "Failed to create parent window\n"); + + for (i = 0; i < ARRAY_SIZE(tests); ++i) + { + child = create_control(tests[i].class, WS_VISIBLE, parent, (DWORD_PTR)&tests[i]); + flush_events(); + flush_sequences(sequences, NUM_MSG_SEQUENCES); + + SendMessageW(child, WM_THEMECHANGED, 0, 0); + flush_events(); + + sprintf(buffer, "Test %d class %s WM_THEMECHANGED", i, tests[i].class); + ok_sequence(sequences, CHILD_SEQ_INDEX, tests[i].expected_msg, buffer, tests[i].todo); + DestroyWindow(child); + } + + DestroyWindow(parent); +} + START_TEST(misc) { ULONG_PTR ctx_cookie; @@ -416,15 +614,21 @@ START_TEST(misc) test_GetPtrAW(); test_Alloc(); - test_comctl32_classes(FALSE); + FreeLibrary(hComctl32); + if (!load_v6_module(&ctx_cookie, &hCtx)) return; + if(!init_functions_v6()) + return; + init_msg_sequences(sequences, NUM_MSG_SEQUENCES); test_comctl32_classes(TRUE); test_builtin_classes(); test_LoadIconWithScaleDown(); + test_WM_THEMECHANGED(); unload_v6_module(ctx_cookie, hCtx); + FreeLibrary(hComctl32); } -- 2.30.2

1 0

[PATCH v2 1/3] sechost: Update return codes for ControlTraceA and W
by David Koolhoven 26 Apr '21

26 Apr '21

This lets programs know tracing is not available. Signed-off-by: David Koolhoven <david(a)koolhoven-home.net> --- dlls/sechost/trace.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/sechost/trace.c b/dlls/sechost/trace.c index 01733690ac8..8f8c316a353 100644 --- a/dlls/sechost/trace.c +++ b/dlls/sechost/trace.c @@ -37,7 +37,7 @@ ULONG WINAPI ControlTraceA( TRACEHANDLE handle, const char *session, EVENT_TRACE_PROPERTIES *properties, ULONG control ) { FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(handle), debugstr_a(session), properties, control); - return ERROR_SUCCESS; + return ERROR_WMI_INSTANCE_NOT_FOUND; } /****************************************************************************** @@ -47,7 +47,7 @@ ULONG WINAPI ControlTraceW( TRACEHANDLE handle, const WCHAR *session, EVENT_TRACE_PROPERTIES *properties, ULONG control ) { FIXME("(%s, %s, %p, %d) stub\n", wine_dbgstr_longlong(handle), debugstr_w(session), properties, control); - return ERROR_SUCCESS; + return ERROR_WMI_INSTANCE_NOT_FOUND; } /****************************************************************************** -- 2.19.1

2 4

[PATCH] mountmgr.sys: Implement StorageDeviceSeekPenaltyProperty
by David Koolhoven 26 Apr '21

26 Apr '21

Implements StorageDeviceSeekPenaltyProperty for query_propery() Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51065 Signed-off-by: David Koolhoven <david(a)koolhoven-home.net> --- dlls/mountmgr.sys/device.c | 120 ++++++++++++++++++++++++++++++++++++- include/ntddstor.h | 9 ++- 2 files changed, 126 insertions(+), 3 deletions(-) diff --git a/dlls/mountmgr.sys/device.c b/dlls/mountmgr.sys/device.c index 04e8fe3c0f5..d031080c459 100644 --- a/dlls/mountmgr.sys/device.c +++ b/dlls/mountmgr.sys/device.c @@ -28,6 +28,10 @@ #include <fcntl.h> #include <unistd.h> #include <sys/time.h> +#ifdef linux +#include <sys/stat.h> +#include <sys/sysmacros.h> +#endif #ifdef HAVE_SYS_IOCTL_H # include <sys/ioctl.h> #endif @@ -1867,8 +1871,6 @@ static NTSTATUS query_property( struct disk_device *device, IRP *irp ) } else { - FIXME( "Faking StorageDeviceProperty data\n" ); - memset( irp->AssociatedIrp.SystemBuffer, 0, irpsp->Parameters.DeviceIoControl.OutputBufferLength ); descriptor = irp->AssociatedIrp.SystemBuffer; descriptor->Version = sizeof(STORAGE_DEVICE_DESCRIPTOR); @@ -1894,6 +1896,120 @@ static NTSTATUS query_property( struct disk_device *device, IRP *irp ) break; } + case StorageDeviceSeekPenaltyProperty: + { +#ifdef linux + FILE *fp; + char isrotapathstr[260]; + char evpath[260]; + char ueventbufstr[260]; + char isrotastrbuf[2]; + char *fgetsret = NULL; + int ret = 0; + char *rptr = NULL; + char *sptr = NULL; + char *devstr_edited = NULL; + char *mountstr = NULL; + char mountpath[260]; + char *part_dev = NULL; + char *path, *p = NULL; + int c = 0; + struct stat statbuf; + DEVICE_SEEK_PENALTY_DESCRIPTOR *descriptor; + + memset( irp->AssociatedIrp.SystemBuffer, 0, irpsp->Parameters.DeviceIoControl.OutputBufferLength ); + descriptor = irp->AssociatedIrp.SystemBuffer; + descriptor->Version = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + descriptor->Size = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + + if (!device->unix_mount) { + status = STATUS_DATA_ERROR; + break; + } + + if (!(path = get_dosdevices_path( &p ))) { + status = STATUS_DATA_ERROR; + break; + } + + /* Crop any drive letters off the end of the string */ + if (!strncmp(&path[strlen(path) - 2], "::", 2)) { + path[strlen(path) - 3] = '\0'; + } + + snprintf (mountpath, 260, "%s%s", path, device->unix_mount); + ret = stat (mountpath, &statbuf); + if (ret == -1) { + status = STATUS_DATA_ERROR; + break; + } + HeapFree( GetProcessHeap(), 0, path ); + sprintf (evpath, "/sys/dev/block/%d:%d/uevent", major(statbuf.st_dev), minor(statbuf.st_dev)); + fp = fopen(evpath, "r"); + if (!fp) { + status = STATUS_DATA_ERROR; + break; + } + while ((rptr = fgets (ueventbufstr, 260, fp))) { + sptr = strstr (rptr, "DEVNAME="); + if (sptr) { + sptr += strlen ("DEVNAME="); + break; + } + } + fclose (fp); + devstr_edited = sptr; + if (!devstr_edited) { + status = STATUS_DATA_ERROR; + break; + } + /* Find first character after forwardslash '/' */ + part_dev = strrchr (devstr_edited, '/'); + if (!part_dev || (part_dev == devstr_edited)) part_dev = devstr_edited; + else part_dev++; + /* Trim off trailing digits and whitespace */ + c = strlen (devstr_edited); + c--; + while ((devstr_edited[c] >= '0' && devstr_edited[c] <= '9') + || (devstr_edited[c] == '\n' || devstr_edited[c] == '\r')) + devstr_edited[c--] = '\0'; + + ret = snprintf (isrotapathstr, 260, "/sys/block/%s/queue/rotational", part_dev); + if (ret < 1 || ret == 260) { + status = STATUS_DATA_ERROR; + break; + } + + fp = fopen(isrotapathstr, "r"); + if (!fp) { + status = STATUS_DATA_ERROR; + break; + } + + fgetsret = fgets(isrotastrbuf, 2, fp); + if (!fgetsret) { + status = STATUS_DATA_ERROR; + break; + } + + fclose (fp); + + if (isrotastrbuf[0] == '1') { + descriptor->IncursSeekPenalty = TRUE; + } else if (isrotastrbuf[0] == '0') { + descriptor->IncursSeekPenalty = FALSE; + } else { + status = STATUS_DATA_ERROR; + break; + } + + status = STATUS_SUCCESS; +#else + FIXME( "Unsupported property StorageDeviceSeekPenalty\n" ); + status = STATUS_NOT_SUPPORTED; +#endif + break; + } default: FIXME( "Unsupported property %#x\n", query->PropertyId ); status = STATUS_NOT_SUPPORTED; diff --git a/include/ntddstor.h b/include/ntddstor.h index b8c4bb73b0d..836def413fe 100644 --- a/include/ntddstor.h +++ b/include/ntddstor.h @@ -214,7 +214,8 @@ typedef enum _STORAGE_QUERY_TYPE { typedef enum _STORAGE_PROPERTY_ID { StorageDeviceProperty = 0, - StorageAdapterProperty + StorageAdapterProperty = 1, + StorageDeviceSeekPenaltyProperty = 7, } STORAGE_PROPERTY_ID, *PSTORAGE_PROPERTY_ID; typedef struct _STORAGE_PROPERTY_QUERY { @@ -272,6 +273,12 @@ typedef struct _STORAGE_ADAPTER_DESCRIPTOR { USHORT BusMinorVersion; } STORAGE_ADAPTER_DESCRIPTOR, *PSTORAGE_ADAPTER_DESCRIPTOR; +typedef struct _DEVICE_SEEK_PENALTY_DESCRIPTOR { + ULONG Version; + ULONG Size; + BOOLEAN IncursSeekPenalty; +} DEVICE_SEEK_PENALTY_DESCRIPTOR, *PDEVICE_SEEK_PENALTY_DESCRIPTOR; + #ifdef __cplusplus } #endif -- 2.19.1

1 0

[PATCH 2/2] mountmgr.sys: Implement StorageDeviceSeekPenaltyProperty
by David Koolhoven 26 Apr '21

26 Apr '21

Implements StorageDeviceSeekPenaltyProperty for query_propery() Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51065 Signed-off-by: David Koolhoven <david(a)koolhoven-home.net> --- dlls/mountmgr.sys/device.c | 120 ++++++++++++++++++++++++++++++++++++- include/ntddstor.h | 9 ++- 2 files changed, 126 insertions(+), 3 deletions(-) diff --git a/dlls/mountmgr.sys/device.c b/dlls/mountmgr.sys/device.c index 04e8fe3c0f5..d031080c459 100644 --- a/dlls/mountmgr.sys/device.c +++ b/dlls/mountmgr.sys/device.c @@ -28,6 +28,10 @@ #include <fcntl.h> #include <unistd.h> #include <sys/time.h> +#ifdef linux +#include <sys/stat.h> +#include <sys/sysmacros.h> +#endif #ifdef HAVE_SYS_IOCTL_H # include <sys/ioctl.h> #endif @@ -1867,8 +1871,6 @@ static NTSTATUS query_property( struct disk_device *device, IRP *irp ) } else { - FIXME( "Faking StorageDeviceProperty data\n" ); - memset( irp->AssociatedIrp.SystemBuffer, 0, irpsp->Parameters.DeviceIoControl.OutputBufferLength ); descriptor = irp->AssociatedIrp.SystemBuffer; descriptor->Version = sizeof(STORAGE_DEVICE_DESCRIPTOR); @@ -1894,6 +1896,120 @@ static NTSTATUS query_property( struct disk_device *device, IRP *irp ) break; } + case StorageDeviceSeekPenaltyProperty: + { +#ifdef linux + FILE *fp; + char isrotapathstr[260]; + char evpath[260]; + char ueventbufstr[260]; + char isrotastrbuf[2]; + char *fgetsret = NULL; + int ret = 0; + char *rptr = NULL; + char *sptr = NULL; + char *devstr_edited = NULL; + char *mountstr = NULL; + char mountpath[260]; + char *part_dev = NULL; + char *path, *p = NULL; + int c = 0; + struct stat statbuf; + DEVICE_SEEK_PENALTY_DESCRIPTOR *descriptor; + + memset( irp->AssociatedIrp.SystemBuffer, 0, irpsp->Parameters.DeviceIoControl.OutputBufferLength ); + descriptor = irp->AssociatedIrp.SystemBuffer; + descriptor->Version = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + descriptor->Size = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + + if (!device->unix_mount) { + status = STATUS_DATA_ERROR; + break; + } + + if (!(path = get_dosdevices_path( &p ))) { + status = STATUS_DATA_ERROR; + break; + } + + /* Crop any drive letters off the end of the string */ + if (!strncmp(&path[strlen(path) - 2], "::", 2)) { + path[strlen(path) - 3] = '\0'; + } + + snprintf (mountpath, 260, "%s%s", path, device->unix_mount); + ret = stat (mountpath, &statbuf); + if (ret == -1) { + status = STATUS_DATA_ERROR; + break; + } + HeapFree( GetProcessHeap(), 0, path ); + sprintf (evpath, "/sys/dev/block/%d:%d/uevent", major(statbuf.st_dev), minor(statbuf.st_dev)); + fp = fopen(evpath, "r"); + if (!fp) { + status = STATUS_DATA_ERROR; + break; + } + while ((rptr = fgets (ueventbufstr, 260, fp))) { + sptr = strstr (rptr, "DEVNAME="); + if (sptr) { + sptr += strlen ("DEVNAME="); + break; + } + } + fclose (fp); + devstr_edited = sptr; + if (!devstr_edited) { + status = STATUS_DATA_ERROR; + break; + } + /* Find first character after forwardslash '/' */ + part_dev = strrchr (devstr_edited, '/'); + if (!part_dev || (part_dev == devstr_edited)) part_dev = devstr_edited; + else part_dev++; + /* Trim off trailing digits and whitespace */ + c = strlen (devstr_edited); + c--; + while ((devstr_edited[c] >= '0' && devstr_edited[c] <= '9') + || (devstr_edited[c] == '\n' || devstr_edited[c] == '\r')) + devstr_edited[c--] = '\0'; + + ret = snprintf (isrotapathstr, 260, "/sys/block/%s/queue/rotational", part_dev); + if (ret < 1 || ret == 260) { + status = STATUS_DATA_ERROR; + break; + } + + fp = fopen(isrotapathstr, "r"); + if (!fp) { + status = STATUS_DATA_ERROR; + break; + } + + fgetsret = fgets(isrotastrbuf, 2, fp); + if (!fgetsret) { + status = STATUS_DATA_ERROR; + break; + } + + fclose (fp); + + if (isrotastrbuf[0] == '1') { + descriptor->IncursSeekPenalty = TRUE; + } else if (isrotastrbuf[0] == '0') { + descriptor->IncursSeekPenalty = FALSE; + } else { + status = STATUS_DATA_ERROR; + break; + } + + status = STATUS_SUCCESS; +#else + FIXME( "Unsupported property StorageDeviceSeekPenalty\n" ); + status = STATUS_NOT_SUPPORTED; +#endif + break; + } default: FIXME( "Unsupported property %#x\n", query->PropertyId ); status = STATUS_NOT_SUPPORTED; diff --git a/include/ntddstor.h b/include/ntddstor.h index b8c4bb73b0d..836def413fe 100644 --- a/include/ntddstor.h +++ b/include/ntddstor.h @@ -214,7 +214,8 @@ typedef enum _STORAGE_QUERY_TYPE { typedef enum _STORAGE_PROPERTY_ID { StorageDeviceProperty = 0, - StorageAdapterProperty + StorageAdapterProperty = 1, + StorageDeviceSeekPenaltyProperty = 7, } STORAGE_PROPERTY_ID, *PSTORAGE_PROPERTY_ID; typedef struct _STORAGE_PROPERTY_QUERY { @@ -272,6 +273,12 @@ typedef struct _STORAGE_ADAPTER_DESCRIPTOR { USHORT BusMinorVersion; } STORAGE_ADAPTER_DESCRIPTOR, *PSTORAGE_ADAPTER_DESCRIPTOR; +typedef struct _DEVICE_SEEK_PENALTY_DESCRIPTOR { + ULONG Version; + ULONG Size; + BOOLEAN IncursSeekPenalty; +} DEVICE_SEEK_PENALTY_DESCRIPTOR, *PDEVICE_SEEK_PENALTY_DESCRIPTOR; + #ifdef __cplusplus } #endif -- 2.19.1

1 1

[PATCH] server: Make region.c a little less ugly.
by Zebediah Figura 26 Apr '21

26 Apr '21

This patch introduces no functional change, but makes some ugly code a little prettier. --- server/region.c | 1036 ++++++++++++++++------------------------------- 1 file changed, 339 insertions(+), 697 deletions(-) diff --git a/server/region.c b/server/region.c index 9f377ee05d3..ca5aba8cd63 100644 --- a/server/region.c +++ b/server/region.c @@ -72,709 +72,351 @@ SOFTWARE. ************************************************************************/ -#include <stdarg.h> -#include <stdlib.h> -#include <string.h> -#include "ntstatus.h" -#define WIN32_NO_STATUS -#include "winternl.h" -#include "request.h" -#include "user.h" -struct region -{ - int size; - int num_rects; - rectangle_t *rects; - rectangle_t extents; -}; +#include <stdarg.h> + #include <stdlib.h> + #include <string.h> + #include "ntstatus.h" + #define WIN32_NO_STATUS + #include "winternl.h" + #include "request.h" + #include"user.h" + struct region + {int size;int + num_rects ; + rectangle_t + *rects; rectangle_t extents;}; + # define RGN_DEFAULT_RECTS 2 + # define EXTENTCHECK( \ + r1 ,r2)((r1 )->right >\ + (r2)->left &&(\ + r1) ->left<(\ + r2)->right\ + &&(r1 )->bottom > (r2)\ + ->top&&(r1 )->top<(r2) ->bottom) + typedef int(* overlap_func_t)( struct region + * reg, const rectangle_t*r1,const rectangle_t* + r1End, const rectangle_t*r2,const rectangle_t* + r2End ,int top ,int bottom ); typedef int(* + non_overlap_func_t )(struct region* reg ,const + rectangle_t* r,const rectangle_t* rEnd,int top + ,int bottom );static const rectangle_t + empty_rect; /*all-zero rectangle for empty + regions */ /*add a rectangle to a region + */ static inline rectangle_t *add_rect ( + struct region * reg ){ if (reg-> num_rects >= + reg ->size ){ rectangle_t*new_rect =realloc(reg + -> rects , 2* sizeof(rectangle_t )*reg->size); + if(!new_rect) { set_error ( STATUS_NO_MEMORY + );return NULL;}reg->rects=new_rect;reg->size *= 2; + }return reg->rects +reg->num_rects++;}/* + make sure all the rectangles + are valid and that + the region is + properly y-x- + banded */static + inline int validate_rectangles (const + rectangle_t *rects,unsigned int nb_rects){ + const rectangle_t*ptr,*end; for(ptr + =rects ,end=rects+nb_rects; ptr<end + ;ptr++ ){ if(is_rect_empty( ptr )) + return 0 ;/*empty rectangle*/ if(ptr== + end-1)break; if(ptr[0].top == ptr[1 ].top)/*same + band*/{if(ptr[0]. bottom!=ptr[1].bottom) return 0; /* not + same y extent*/if ( ptr[0].right >= ptr[1].left)return 0;/*not + properly x ordered*/}else/*new band*/{if(ptr[0].bottom> + ptr[1].top)return 0;/*not properly y ordered + */}}return 1;}/*attempt to merge + the rects in the current band with those in + the previous one. Used only by region_op. */ static int + coalesce_region(struct region*pReg,int prevStart,int curStart){ + int curNumRects; rectangle_t*pRegEnd= & pReg->rects[pReg + ->num_rects]; rectangle_t*pPrevRect= &pReg->rects + [prevStart ];rectangle_t*pCurRect =&pReg-> + rects[ curStart];int prevNumRects= curStart- +prevStart ;int bandtop=pCurRect-> top;for( +curNumRects =0;(pCurRect!=pRegEnd) &&(pCurRect + ->top==bandtop );curNumRects++){pCurRect ++;}if(pCurRect + !=pRegEnd){pRegEnd --;while(pRegEnd[-1].top == pRegEnd -> top) + pRegEnd--;curStart= pRegEnd-pReg->rects; pRegEnd=pReg->rects+ + pReg->num_rects;}if((curNumRects==prevNumRects)&&(curNumRects + !=0)){pCurRect-=curNumRects;if (pPrevRect->bottom == + pCurRect->top){ do{ if((pPrevRect->left != + pCurRect->left) ||(pPrevRect-> + right != pCurRect->right))return curStart; + pPrevRect++; pCurRect++; prevNumRects -= 1; } while( + prevNumRects != 0);pReg->num_rects -= curNumRects;pCurRect -= + curNumRects;pPrevRect -= curNumRects;do{ pPrevRect->bottom= + pCurRect->bottom; pPrevRect++;pCurRect ++; curNumRects-= + 1;} while ( curNumRects != 0);if ( pCurRect == + pRegEnd) curStart= prevStart; else do{* +pPrevRect ++ = *pCurRect++;} while ( +pCurRect !=pRegEnd);}} return curStart + ;}/*apply an operation to two regions */ + /*check the GDI version of the code for + explanations */ static int region_op (struct region* + newReg,const struct region*reg1,const struct region *reg2, + overlap_func_t overlap_func,non_overlap_func_t + non_overlap1_func,non_overlap_func_t + non_overlap2_func){int ybot,ytop,top,bot,prevBand + ,curBand; const rectangle_t * r1BandEnd, *r2BandEnd; const + rectangle_t*r1= reg1->rects; const rectangle_t*r2= + reg2->rects ;const rectangle_t *r1End =r1+ + reg1-> num_rects ;const rectangle_t + *r2End =r2+reg2->num_rects; rectangle_t* +new_rects ,*old_rects=newReg ->rects; + int new_size ,ret=0;new_size=max( reg1->num_rects + ,reg2->num_rects )*2;if(!(new_rects= mem_alloc(new_size + *sizeof(*newReg ->rects)))) return 0;newReg->size= + new_size; newReg ->rects=new_rects; newReg->num_rects + =0;if(reg1->extents.top< reg2->extents.top)ybot=reg1-> + extents.top;else ybot = reg2->extents.top; + prevBand=0;do{curBand=newReg->num_rects; r1BandEnd=r1; + while((r1BandEnd!=r1End) && (r1BandEnd->top==r1->top)) + r1BandEnd++;r2BandEnd=r2;while((r2BandEnd != r2End)&&( + r2BandEnd->top == r2->top))r2BandEnd++;if(r1->top<r2-> + top){top=max(r1->top,ybot);bot=min(r1->bottom,r2->top) + ;if(top!=bot&&non_overlap1_func){if(!non_overlap1_func + (newReg,r1,r1BandEnd,top,bot))goto done;}ytop=r2->top; + }else if(r2->top < r1->top){top=max(r2->top,ybot);bot= + min(r2->bottom,r1->top);if(top!=bot&&non_overlap2_func + ){if (!non_overlap2_func(newReg,r2,r2BandEnd,top,bot)) goto done;} + ytop=r1->top;}else{ytop=r1->top;}if (newReg->num_rects != curBand) + prevBand = coalesce_region(newReg,prevBand,curBand); ybot=min(r1-> + bottom,r2->bottom); curBand = newReg->num_rects;if(ybot>ytop){if(! + overlap_func(newReg,r1,r1BandEnd,r2,r2BandEnd,ytop,ybot))goto done + ;}if(newReg->num_rects!=curBand)prevBand = coalesce_region(newReg, + prevBand,curBand);if(r1->bottom==ybot)r1=r1BandEnd;if(r2->bottom== +ybot)r2=r2BandEnd;}while((r1!=r1End)&&(r2!=r2End));curBand=newReg->num_rects;if( +r1 != r1End){if (non_overlap1_func){do{r1BandEnd=r1;while((r1BandEnd < r1End)&&( +r1BandEnd->top==r1->top))r1BandEnd++;if (!non_overlap1_func(newReg,r1,r1BandEnd, +max(r1->top,ybot),r1->bottom))goto done;r1=r1BandEnd;}while(r1!=r1End);}}else if +((r2!=r2End) && non_overlap2_func){do{r2BandEnd=r2;while ((r2BandEnd < r2End)&&( +r2BandEnd->top==r2->top))r2BandEnd++;if (!non_overlap2_func(newReg,r2,r2BandEnd, +max(r2->top, ybot ),r2->bottom +))goto done; r2=r2BandEnd;} while (r2!=r2End); +}if(newReg-> num_rects!=curBand)coalesce_region ( newReg , +prevBand , curBand);if((newReg->num_rects<(newReg->size/ 2))&&(newReg +->size >2)){ new_size=max(newReg->num_rects,RGN_DEFAULT_RECTS); if(new_rects += realloc( newReg->rects, sizeof (* newReg ->rects)* new_size )){ +newReg->rects=new_rects;newReg ->size=new_size;}}ret=1; done: +free(old_rects);return ret; }/* recalculate the extents +of a region */static void set_region_extents(struct +region*region){rectangle_t *pRect,*pRectEnd;if(region +->num_rects==0){region-> extents.left= 0;region-> +extents.top = 0;region-> extents.right=0;region-> +extents.bottom=0;return; }pRect = region-> rects; +pRectEnd =&pRect[region-> num_rects - 1]; region-> +extents.left=pRect->left; region->extents.top=pRect +->top;region->extents.right =pRectEnd-> right; region-> +extents.bottom=pRectEnd->bottom ;while(pRect <= pRectEnd){if ( +pRect->left< region->extents.left) region->extents.left= pRect->left; +if (pRect-> right>region->extents.right)region->extents.right= pRect->right +;pRect++; }} /*handle an overlapping band for intersect _region */ +static int intersect_overlapping(struct region *pReg, const +rectangle_t* r1,const rectangle_t *r1End,const +rectangle_t *r2, const +rectangle_t*r2End,int top,int bottom){int left,right;while ((r1 != r1End)&&(r2!= +r2End)){left=max(r1->left,r2->left);right=min(r1->right,r2->right);if(left<right +){rectangle_t*rect = add_rect(pReg);if(!rect)return 0;rect->left=left;rect->top= +top;rect->right=right;rect->bottom=bottom;}if (r1->right<r2->right)r1++;else if( +r2->right<r1->right)r2++;else{r1++;r2++;}}return 1;} /* handle a non-overlapping +band for subtract_region*/static int subtract_non_overlapping(struct region*pReg +,const rectangle_t*r,const rectangle_t*rEnd, int top,int bottom){while(r!=rEnd){ + rectangle_t*rect =add_rect(pReg); + if(!rect) return 0;rect->left=r-> + left;rect->top = top;rect->right= + r->right; rect-> bottom = bottom; + r++;} return 1;} /* handle an + overlapping band for subtract_region */ + static int subtract_overlapping(struct region *pReg, + const rectangle_t*r1, const rectangle_t*r1End, const + rectangle_t *r2,const rectangle_t *r2End,int top,int + bottom){int left=r1->left; while((r1!=r1End + )&&(r2!=r2End)){ if (r2->right <= + left) r2++; else if (r2->left <= + left){left =r2-> right; if(left>= + r1->right){r1++; if(r1!=r1End)left=r1->left + ;}else r2++;}else if(r2->left<r1->right){rectangle_t + *rect=add_rect(pReg); if(!rect)return 0; rect->left= + left;rect->top=top;rect->right=r2->left;rect->bottom + =bottom;left=r2->right;if (left>=r1->right + ){r1++; if(r1 != r1End) left=r1-> + left;}else r2++; } else {if (r1-> + right > left ) { rectangle_t*rect + =add_rect(pReg); if(!rect)return 0;rect + ->left=left;rect->top=top;rect->right=r1->right;rect + ->bottom=bottom;}r1++;if(r1!=r1End) left=r1->left;}} + while(r1!=r1End){rectangle_t*rect=add_rect(pReg);if( + !rect)return 0;rect->left= left; rect->top= + top;rect->right= r1->right;rect-> + bottom=bottom;r1 ++;if(r1!=r1End) + left= r1->left;} return 1;}/*handle a + non-overlapping band for union_region*/static int + union_non_overlapping( struct region *pReg, const + rectangle_t *r, const rectangle_t *rEnd, int top,int + bottom){while(r != rEnd){rectangle_t *rect=add_rect( + pReg);if(!rect)return 0; rect->left = r-> + left; rect->top= top;rect->right= + r->right; rect-> bottom=bottom; r + ++;} return 1;} /* handle an overlapping band for union_region */ static int + union_overlapping(struct region*pReg,const rectangle_t *r1,const rectangle_t + *r1End, const rectangle_t *r2,const rectangle_t *r2End,int top, int bottom){ + #define MERGERECT(r)if((pReg->num_rects!=0)&&(pReg->rects[pReg->num_rects-1\ + ].top==top)&&(pReg->rects[ pReg->num_rects-1].bottom\ + ==bottom) && (pReg->rects[ pReg->num_rects -1].right\ + >=r->left)){if(pReg->rects [pReg->num_rects-1].right<\ + r->right){pReg->rects[pReg ->num_rects-1].right = r->\ + right;}}else {rectangle_t* rect = add_rect(pReg);if(\ + !rect)return 0;rect->top= top;rect->bottom=bottom;\ + rect->left=r->left;rect ->right = r->right;}r++; + while((r1!=r1End)&&(r2 !=r2End)){if(r1->left<r2 + ->left){MERGERECT(r1);} else{MERGERECT(r2);}}if( + r1!=r1End){do{MERGERECT(r1);}while(r1!= + r1End);}else while (r2!=r2End){ + MERGERECT(r2);}return 1; + #undef MERGERECT + }/*create an empty region*/ + struct region*create_empty_region(void + ){struct region*region;if(!(region=mem_alloc(sizeof + (*region))))return NULL;if (!(region->rects=mem_alloc + (RGN_DEFAULT_RECTS *sizeof (*region->rects )))){free( + region);return NULL;}region ->size = RGN_DEFAULT_RECTS; + region->num_rects=0;region ->extents.left=0; region-> + extents.top = 0; region-> extents.right = 0;region-> + extents.bottom = 0; return region;}/* create a region + from request data */struct region* create_region_from_req_data + (const void*data,data_size_t size){ unsigned int alloc_rects; + struct region*region;const rectangle_t *rects = data; + int nb_rects = size/sizeof( rectangle_t ); /* special + case: empty region can be specified by a single all- + zero rectangle*/if(nb_rects== 1&&!memcmp(rects,&empty_rect + ,sizeof(empty_rect)))nb_rects =0;if(!validate_rectangles + (rects,nb_rects)){set_error (STATUS_INVALID_PARAMETER) + ;return NULL;}if(!(region= mem_alloc(sizeof(*region) + ))) return NULL; alloc_rects = max(nb_rects, + RGN_DEFAULT_RECTS);if(!(region->rects + = mem_alloc( alloc_rects * + sizeof(*region-> + rects)))){free(region);return + NULL;}region->size=alloc_rects; region-> + num_rects=nb_rects;memcpy (region->rects, rects, + nb_rects*sizeof(*rects)); set_region_extents(region + );return region;}/*free a region */void free_region + (struct region*region){free (region->rects);free(region + );}/*set region to a simple rectangle*/void set_region_rect + (struct region *region, const rectangle_t*rect){if + (!is_rect_empty ( rect )){ region ->num_rects=1;region->rects + [0]=region->extents=*rect; }else{ region->num_rects=0;region + ->extents=empty_rect;}} /* retrieve the region data + for sending to the client*/ rectangle_t*get_region_data + (const struct region*region ,data_size_t max_size, + data_size_t *total_size ){ const rectangle_t *data = + region->rects;if(!(*total_size =region->num_rects*sizeof( + rectangle_t))){/* return a single empty rect for empty + regions*/*total_size=sizeof (empty_rect);data=&empty_rect + ;}if (max_size >= *total_size)return memdup(data,* + total_size);set_error(STATUS_BUFFER_OVERFLOW + );return NULL;}/*retrieve the region + data for sending to the + client and free + the region at the same time + */rectangle_t*get_region_data_and_free + (struct region *region, data_size_t max_size, + data_size_t*total_size) {rectangle_t*ret=region + ->rects;if(!(*total_size =region->num_rects*sizeof + (rectangle_t))){/* return a single empty rect for + empty regions*/*total_size =sizeof( empty_rect );if( + max_size>=sizeof(empty_rect )){ret=memdup(&empty_rect, + sizeof( empty_rect ));free( region->rects);}}if(max_size + <*total_size){free( region ->rects); set_error( + STATUS_BUFFER_OVERFLOW ); ret = NULL;}free(region);return + ret;} /* check if a given region is empty*/int is_region_empty + (const struct region*region ){return region->num_rects == 0;}/* + get the extents rect of a region */void get_region_extents + (const struct region*region ,rectangle_t*rect){*rect= + region->extents;}/* add an offset to a region */void + offset_region(struct region *region, int x, int y ){ + rectangle_t*rect,*end;if(! region->num_rects)return; + for(rect=region->rects,end =rect+region->num_rects; + rect<end;rect++)offset_rect(rect,x,y);offset_rect( + &region->extents,x,y);}/*mirror a region + relative to a window client + rect */ void + mirror_region(const rectangle_t + *client_rect,struct region*region){int start + ,end,i,j;for(start=0;start <region->num_rects;start= + end+1){for(end=start;end <region->num_rects-1;end + ++)if(region->rects[end+1] .top!=region->rects[end]. + top)break;for(i=start,j=end ;i<j;i++,j--){rectangle_t + rect=region->rects[j];region ->rects[i]=region->rects[j + ];region->rects[j] = rect; mirror_rect(client_rect,& + region->rects[j]);mirror_rect (client_rect,&region->rects + [i]);}if(i==j)mirror_rect( client_rect,&region->rects + [i]);} mirror_rect( client_rect, &region->extents );}/* scale a region for a + given dpi factor */ void scale_region( struct region * region, unsigned int + + + + + + + + + + dpi_from,unsigned int dpi_to ){rectangle_t + *rect,*end;if(!region->num_rects)return;for( + rect=region->rects, end=rect+region->num_rects + ;rect<end;rect++)scale_dpi_rect(rect,dpi_from, + dpi_to); scale_dpi_rect(&region->extents, + dpi_from,dpi_to);} /* make a copy of a region; + returns dst or NULL on error */ struct region* + copy_region ( struct region *dst, const struct + region*src){if(dst == src)return dst; if(dst-> + size<src->num_rects){rectangle_t*rect=realloc( + dst->rects,src->num_rects*sizeof(*rect)); if(! + rect){set_error(STATUS_NO_MEMORY);return NULL; + }dst->rects=rect;dst->size=src->num_rects;}dst + ->num_rects=src->num_rects; dst->extents=src-> + extents; memcpy( dst->rects,src->rects,src-> + num_rects*sizeof(*dst->rects)); return dst;} + /* compute the intersection of two regions + into dst, which can be one of the source + regions*/struct region*intersect_region( + struct region*dst,const struct region + *src1,const struct region *src2) + {if (!src1->num_rects||! + src2->num_rects||! + EXTENTCHECK( + &src1-> + extents + ,&src2-> + extents + )){dst-> + num_rects + =0;dst-> + extents + .left=0 + ;dst-> + extents + .top=0 + ;dst-> + extents + .right= + 0;dst-> + extents + .bottom= + 0;return + dst;}if(! + region_op + (dst,src1,src2 + ,intersect_overlapping,NULL, + NULL))return NULL;set_region_extents(dst);return dst;} -#define RGN_DEFAULT_RECTS 2 -#define EXTENTCHECK(r1, r2) \ - ((r1)->right > (r2)->left && \ - (r1)->left < (r2)->right && \ - (r1)->bottom > (r2)->top && \ - (r1)->top < (r2)->bottom) -typedef int (*overlap_func_t)( struct region *reg, const rectangle_t *r1, const rectangle_t *r1End, - const rectangle_t *r2, const rectangle_t *r2End, int top, int bottom ); -typedef int (*non_overlap_func_t)( struct region *reg, const rectangle_t *r, - const rectangle_t *rEnd, int top, int bottom ); -static const rectangle_t empty_rect; /* all-zero rectangle for empty regions */ - -/* add a rectangle to a region */ -static inline rectangle_t *add_rect( struct region *reg ) -{ - if (reg->num_rects >= reg->size) - { - rectangle_t *new_rect = realloc( reg->rects, 2 * sizeof(rectangle_t) * reg->size ); - if (!new_rect) - { - set_error( STATUS_NO_MEMORY ); - return NULL; - } - reg->rects = new_rect; - reg->size *= 2; - } - return reg->rects + reg->num_rects++; -} - -/* make sure all the rectangles are valid and that the region is properly y-x-banded */ -static inline int validate_rectangles( const rectangle_t *rects, unsigned int nb_rects ) -{ - const rectangle_t *ptr, *end; - - for (ptr = rects, end = rects + nb_rects; ptr < end; ptr++) - { - if (is_rect_empty( ptr )) return 0; /* empty rectangle */ - if (ptr == end - 1) break; - if (ptr[0].top == ptr[1].top) /* same band */ - { - if (ptr[0].bottom != ptr[1].bottom) return 0; /* not same y extent */ - if (ptr[0].right >= ptr[1].left) return 0; /* not properly x ordered */ - } - else /* new band */ - { - if (ptr[0].bottom > ptr[1].top) return 0; /* not properly y ordered */ - } - } - return 1; -} - -/* attempt to merge the rects in the current band with those in the */ -/* previous one. Used only by region_op. */ -static int coalesce_region( struct region *pReg, int prevStart, int curStart ) -{ - int curNumRects; - rectangle_t *pRegEnd = &pReg->rects[pReg->num_rects]; - rectangle_t *pPrevRect = &pReg->rects[prevStart]; - rectangle_t *pCurRect = &pReg->rects[curStart]; - int prevNumRects = curStart - prevStart; - int bandtop = pCurRect->top; - - for (curNumRects = 0; - (pCurRect != pRegEnd) && (pCurRect->top == bandtop); - curNumRects++) - { - pCurRect++; - } - - if (pCurRect != pRegEnd) - { - pRegEnd--; - while (pRegEnd[-1].top == pRegEnd->top) pRegEnd--; - curStart = pRegEnd - pReg->rects; - pRegEnd = pReg->rects + pReg->num_rects; - } - - if ((curNumRects == prevNumRects) && (curNumRects != 0)) - { - pCurRect -= curNumRects; - if (pPrevRect->bottom == pCurRect->top) - { - do - { - if ((pPrevRect->left != pCurRect->left) || - (pPrevRect->right != pCurRect->right)) return curStart; - pPrevRect++; - pCurRect++; - prevNumRects -= 1; - } while (prevNumRects != 0); - - pReg->num_rects -= curNumRects; - pCurRect -= curNumRects; - pPrevRect -= curNumRects; - - do - { - pPrevRect->bottom = pCurRect->bottom; - pPrevRect++; - pCurRect++; - curNumRects -= 1; - } while (curNumRects != 0); - - if (pCurRect == pRegEnd) curStart = prevStart; - else do { *pPrevRect++ = *pCurRect++; } while (pCurRect != pRegEnd); - - } - } - return curStart; -} - -/* apply an operation to two regions */ -/* check the GDI version of the code for explanations */ -static int region_op( struct region *newReg, const struct region *reg1, const struct region *reg2, - overlap_func_t overlap_func, - non_overlap_func_t non_overlap1_func, - non_overlap_func_t non_overlap2_func ) -{ - int ybot, ytop, top, bot, prevBand, curBand; - const rectangle_t *r1BandEnd, *r2BandEnd; - - const rectangle_t *r1 = reg1->rects; - const rectangle_t *r2 = reg2->rects; - const rectangle_t *r1End = r1 + reg1->num_rects; - const rectangle_t *r2End = r2 + reg2->num_rects; - - rectangle_t *new_rects, *old_rects = newReg->rects; - int new_size, ret = 0; - - new_size = max( reg1->num_rects, reg2->num_rects ) * 2; - if (!(new_rects = mem_alloc( new_size * sizeof(*newReg->rects) ))) return 0; - - newReg->size = new_size; - newReg->rects = new_rects; - newReg->num_rects = 0; - - if (reg1->extents.top < reg2->extents.top) - ybot = reg1->extents.top; - else - ybot = reg2->extents.top; - - prevBand = 0; - - do - { - curBand = newReg->num_rects; - - r1BandEnd = r1; - while ((r1BandEnd != r1End) && (r1BandEnd->top == r1->top)) r1BandEnd++; - - r2BandEnd = r2; - while ((r2BandEnd != r2End) && (r2BandEnd->top == r2->top)) r2BandEnd++; - - if (r1->top < r2->top) - { - top = max(r1->top,ybot); - bot = min(r1->bottom,r2->top); - - if ((top != bot) && non_overlap1_func) - { - if (!non_overlap1_func( newReg, r1, r1BandEnd, top, bot )) goto done; - } - - ytop = r2->top; - } - else if (r2->top < r1->top) - { - top = max(r2->top,ybot); - bot = min(r2->bottom,r1->top); - - if ((top != bot) && non_overlap2_func) - { - if (!non_overlap2_func( newReg, r2, r2BandEnd, top, bot )) goto done; - } - - ytop = r1->top; - } - else - { - ytop = r1->top; - } - - if (newReg->num_rects != curBand) - prevBand = coalesce_region(newReg, prevBand, curBand); - - ybot = min(r1->bottom, r2->bottom); - curBand = newReg->num_rects; - if (ybot > ytop) - { - if (!overlap_func( newReg, r1, r1BandEnd, r2, r2BandEnd, ytop, ybot )) goto done; - } - - if (newReg->num_rects != curBand) - prevBand = coalesce_region(newReg, prevBand, curBand); - - if (r1->bottom == ybot) r1 = r1BandEnd; - if (r2->bottom == ybot) r2 = r2BandEnd; - } while ((r1 != r1End) && (r2 != r2End)); - - curBand = newReg->num_rects; - if (r1 != r1End) - { - if (non_overlap1_func) - { - do - { - r1BandEnd = r1; - while ((r1BandEnd < r1End) && (r1BandEnd->top == r1->top)) r1BandEnd++; - if (!non_overlap1_func( newReg, r1, r1BandEnd, max(r1->top,ybot), r1->bottom )) - goto done; - r1 = r1BandEnd; - } while (r1 != r1End); - } - } - else if ((r2 != r2End) && non_overlap2_func) - { - do - { - r2BandEnd = r2; - while ((r2BandEnd < r2End) && (r2BandEnd->top == r2->top)) r2BandEnd++; - if (!non_overlap2_func( newReg, r2, r2BandEnd, max(r2->top,ybot), r2->bottom )) - goto done; - r2 = r2BandEnd; - } while (r2 != r2End); - } - - if (newReg->num_rects != curBand) coalesce_region(newReg, prevBand, curBand); - - if ((newReg->num_rects < (newReg->size / 2)) && (newReg->size > 2)) - { - new_size = max( newReg->num_rects, RGN_DEFAULT_RECTS ); - if ((new_rects = realloc( newReg->rects, sizeof(*newReg->rects) * new_size ))) - { - newReg->rects = new_rects; - newReg->size = new_size; - } - } - ret = 1; -done: - free( old_rects ); - return ret; -} - -/* recalculate the extents of a region */ -static void set_region_extents( struct region *region ) -{ - rectangle_t *pRect, *pRectEnd; - - if (region->num_rects == 0) - { - region->extents.left = 0; - region->extents.top = 0; - region->extents.right = 0; - region->extents.bottom = 0; - return; - } - - pRect = region->rects; - pRectEnd = &pRect[region->num_rects - 1]; - - region->extents.left = pRect->left; - region->extents.top = pRect->top; - region->extents.right = pRectEnd->right; - region->extents.bottom = pRectEnd->bottom; - - while (pRect <= pRectEnd) - { - if (pRect->left < region->extents.left) region->extents.left = pRect->left; - if (pRect->right > region->extents.right) region->extents.right = pRect->right; - pRect++; - } -} - -/* handle an overlapping band for intersect_region */ -static int intersect_overlapping( struct region *pReg, - const rectangle_t *r1, const rectangle_t *r1End, - const rectangle_t *r2, const rectangle_t *r2End, - int top, int bottom ) - -{ - int left, right; - - while ((r1 != r1End) && (r2 != r2End)) - { - left = max(r1->left, r2->left); - right = min(r1->right, r2->right); - - if (left < right) - { - rectangle_t *rect = add_rect( pReg ); - if (!rect) return 0; - rect->left = left; - rect->top = top; - rect->right = right; - rect->bottom = bottom; - } - - if (r1->right < r2->right) r1++; - else if (r2->right < r1->right) r2++; - else - { - r1++; - r2++; - } - } - return 1; -} - -/* handle a non-overlapping band for subtract_region */ -static int subtract_non_overlapping( struct region *pReg, const rectangle_t *r, - const rectangle_t *rEnd, int top, int bottom ) -{ - while (r != rEnd) - { - rectangle_t *rect = add_rect( pReg ); - if (!rect) return 0; - rect->left = r->left; - rect->top = top; - rect->right = r->right; - rect->bottom = bottom; - r++; - } - return 1; -} - -/* handle an overlapping band for subtract_region */ -static int subtract_overlapping( struct region *pReg, - const rectangle_t *r1, const rectangle_t *r1End, - const rectangle_t *r2, const rectangle_t *r2End, - int top, int bottom ) -{ - int left = r1->left; - - while ((r1 != r1End) && (r2 != r2End)) - { - if (r2->right <= left) r2++; - else if (r2->left <= left) - { - left = r2->right; - if (left >= r1->right) - { - r1++; - if (r1 != r1End) - left = r1->left; - } - else r2++; - } - else if (r2->left < r1->right) - { - rectangle_t *rect = add_rect( pReg ); - if (!rect) return 0; - rect->left = left; - rect->top = top; - rect->right = r2->left; - rect->bottom = bottom; - left = r2->right; - if (left >= r1->right) - { - r1++; - if (r1 != r1End) - left = r1->left; - } - else r2++; - } - else - { - if (r1->right > left) - { - rectangle_t *rect = add_rect( pReg ); - if (!rect) return 0; - rect->left = left; - rect->top = top; - rect->right = r1->right; - rect->bottom = bottom; - } - r1++; - if (r1 != r1End) - left = r1->left; - } - } - - while (r1 != r1End) - { - rectangle_t *rect = add_rect( pReg ); - if (!rect) return 0; - rect->left = left; - rect->top = top; - rect->right = r1->right; - rect->bottom = bottom; - r1++; - if (r1 != r1End) left = r1->left; - } - return 1; -} - -/* handle a non-overlapping band for union_region */ -static int union_non_overlapping( struct region *pReg, const rectangle_t *r, - const rectangle_t *rEnd, int top, int bottom ) -{ - while (r != rEnd) - { - rectangle_t *rect = add_rect( pReg ); - if (!rect) return 0; - rect->left = r->left; - rect->top = top; - rect->right = r->right; - rect->bottom = bottom; - r++; - } - return 1; -} - -/* handle an overlapping band for union_region */ -static int union_overlapping( struct region *pReg, - const rectangle_t *r1, const rectangle_t *r1End, - const rectangle_t *r2, const rectangle_t *r2End, - int top, int bottom ) -{ -#define MERGERECT(r) \ - if ((pReg->num_rects != 0) && \ - (pReg->rects[pReg->num_rects-1].top == top) && \ - (pReg->rects[pReg->num_rects-1].bottom == bottom) && \ - (pReg->rects[pReg->num_rects-1].right >= r->left)) \ - { \ - if (pReg->rects[pReg->num_rects-1].right < r->right) \ - { \ - pReg->rects[pReg->num_rects-1].right = r->right; \ - } \ - } \ - else \ - { \ - rectangle_t *rect = add_rect( pReg ); \ - if (!rect) return 0; \ - rect->top = top; \ - rect->bottom = bottom; \ - rect->left = r->left; \ - rect->right = r->right; \ - } \ - r++; - - while ((r1 != r1End) && (r2 != r2End)) - { - if (r1->left < r2->left) - { - MERGERECT(r1); - } - else - { - MERGERECT(r2); - } - } - - if (r1 != r1End) - { - do - { - MERGERECT(r1); - } while (r1 != r1End); - } - else while (r2 != r2End) - { - MERGERECT(r2); - } - return 1; -#undef MERGERECT -} - - -/* create an empty region */ -struct region *create_empty_region(void) -{ - struct region *region; - - if (!(region = mem_alloc( sizeof(*region) ))) return NULL; - if (!(region->rects = mem_alloc( RGN_DEFAULT_RECTS * sizeof(*region->rects) ))) - { - free( region ); - return NULL; - } - region->size = RGN_DEFAULT_RECTS; - region->num_rects = 0; - region->extents.left = 0; - region->extents.top = 0; - region->extents.right = 0; - region->extents.bottom = 0; - return region; -} - -/* create a region from request data */ -struct region *create_region_from_req_data( const void *data, data_size_t size ) -{ - unsigned int alloc_rects; - struct region *region; - const rectangle_t *rects = data; - int nb_rects = size / sizeof(rectangle_t); - - /* special case: empty region can be specified by a single all-zero rectangle */ - if (nb_rects == 1 && !memcmp( rects, &empty_rect, sizeof(empty_rect) )) nb_rects = 0; - - if (!validate_rectangles( rects, nb_rects )) - { - set_error( STATUS_INVALID_PARAMETER ); - return NULL; - } - - if (!(region = mem_alloc( sizeof(*region) ))) return NULL; - - alloc_rects = max( nb_rects, RGN_DEFAULT_RECTS ); - if (!(region->rects = mem_alloc( alloc_rects * sizeof(*region->rects) ))) - { - free( region ); - return NULL; - } - region->size = alloc_rects; - region->num_rects = nb_rects; - memcpy( region->rects, rects, nb_rects * sizeof(*rects) ); - set_region_extents( region ); - return region; -} - -/* free a region */ -void free_region( struct region *region ) -{ - free( region->rects ); - free( region ); -} - -/* set region to a simple rectangle */ -void set_region_rect( struct region *region, const rectangle_t *rect ) -{ - if (!is_rect_empty( rect )) - { - region->num_rects = 1; - region->rects[0] = region->extents = *rect; - } - else - { - region->num_rects = 0; - region->extents = empty_rect; - } -} - -/* retrieve the region data for sending to the client */ -rectangle_t *get_region_data( const struct region *region, data_size_t max_size, data_size_t *total_size ) -{ - const rectangle_t *data = region->rects; - - if (!(*total_size = region->num_rects * sizeof(rectangle_t))) - { - /* return a single empty rect for empty regions */ - *total_size = sizeof(empty_rect); - data = &empty_rect; - } - if (max_size >= *total_size) return memdup( data, *total_size ); - set_error( STATUS_BUFFER_OVERFLOW ); - return NULL; -} - -/* retrieve the region data for sending to the client and free the region at the same time */ -rectangle_t *get_region_data_and_free( struct region *region, data_size_t max_size, data_size_t *total_size ) -{ - rectangle_t *ret = region->rects; - - if (!(*total_size = region->num_rects * sizeof(rectangle_t))) - { - /* return a single empty rect for empty regions */ - *total_size = sizeof(empty_rect); - if (max_size >= sizeof(empty_rect)) - { - ret = memdup( &empty_rect, sizeof(empty_rect) ); - free( region->rects ); - } - } - - if (max_size < *total_size) - { - free( region->rects ); - set_error( STATUS_BUFFER_OVERFLOW ); - ret = NULL; - } - free( region ); - return ret; -} - -/* check if a given region is empty */ -int is_region_empty( const struct region *region ) -{ - return region->num_rects == 0; -} - - -/* get the extents rect of a region */ -void get_region_extents( const struct region *region, rectangle_t *rect ) -{ - *rect = region->extents; -} - -/* add an offset to a region */ -void offset_region( struct region *region, int x, int y ) -{ - rectangle_t *rect, *end; - - if (!region->num_rects) return; - for (rect = region->rects, end = rect + region->num_rects; rect < end; rect++) - offset_rect( rect, x, y ); - offset_rect( &region->extents, x, y ); -} - -/* mirror a region relative to a window client rect */ -void mirror_region( const rectangle_t *client_rect, struct region *region ) -{ - int start, end, i, j; - - for (start = 0; start < region->num_rects; start = end + 1) - { - for (end = start; end < region->num_rects - 1; end++) - if (region->rects[end + 1].top != region->rects[end].top) break; - for (i = start, j = end; i < j; i++, j--) - { - rectangle_t rect = region->rects[j]; - region->rects[i] = region->rects[j]; - region->rects[j] = rect; - mirror_rect( client_rect, &region->rects[j] ); - mirror_rect( client_rect, &region->rects[i] ); - } - if (i == j) mirror_rect( client_rect, &region->rects[i] ); - } - mirror_rect( client_rect, &region->extents ); -} - - -/* scale a region for a given dpi factor */ -void scale_region( struct region *region, unsigned int dpi_from, unsigned int dpi_to ) -{ - rectangle_t *rect, *end; - - if (!region->num_rects) return; - for (rect = region->rects, end = rect + region->num_rects; rect < end; rect++) - scale_dpi_rect( rect, dpi_from, dpi_to ); - scale_dpi_rect( &region->extents, dpi_from, dpi_to ); -} - - -/* make a copy of a region; returns dst or NULL on error */ -struct region *copy_region( struct region *dst, const struct region *src ) -{ - if (dst == src) return dst; - - if (dst->size < src->num_rects) - { - rectangle_t *rect = realloc( dst->rects, src->num_rects * sizeof(*rect) ); - if (!rect) - { - set_error( STATUS_NO_MEMORY ); - return NULL; - } - dst->rects = rect; - dst->size = src->num_rects; - } - dst->num_rects = src->num_rects; - dst->extents = src->extents; - memcpy( dst->rects, src->rects, src->num_rects * sizeof(*dst->rects) ); - return dst; -} - -/* compute the intersection of two regions into dst, which can be one of the source regions */ -struct region *intersect_region( struct region *dst, const struct region *src1, - const struct region *src2 ) -{ - if (!src1->num_rects || !src2->num_rects || !EXTENTCHECK(&src1->extents, &src2->extents)) - { - dst->num_rects = 0; - dst->extents.left = 0; - dst->extents.top = 0; - dst->extents.right = 0; - dst->extents.bottom = 0; - return dst; - } - if (!region_op( dst, src1, src2, intersect_overlapping, NULL, NULL )) return NULL; - set_region_extents( dst ); - return dst; -} /* compute the subtraction of two regions into dst, which can be one of the source regions */ struct region *subtract_region( struct region *dst, const struct region *src1, -- 2.30.2

5 4

[PATCH v2 1/4] user32: Move ToUnicodeEx from wineandroid.drv to user32.
by Rémi Bernon 26 Apr '21

26 Apr '21

As a default implementation for en_US keyboard layout, calling the driver implementation next so that it can override the result. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- v2: Move code from driver to user32 common code instead of nulldrv, graphics drivers callbacks are then called to have a chance to override the default values. The last patch completely removes LoadKeyboardLayout driver call, it was unimplemented anyway. It can just be ignored if that's not the right way forward. IMHO it'd make things easier to have an internal keyboard layout management, with key translations being done according to the thread and process active layouts, but I can also see why we would like to make it more seamlessly integrated with the system (although I'm not sure if it's possible to map all Windows specificities). Supersdes: 204099-204104 dlls/user32/driver.c | 8 +- dlls/user32/input.c | 79 ++++++++++++++++++- dlls/user32/user_private.h | 2 +- dlls/wineandroid.drv/keyboard.c | 94 ----------------------- dlls/wineandroid.drv/wineandroid.drv.spec | 1 - dlls/winemac.drv/keyboard.c | 2 +- dlls/winemac.drv/winemac.drv.spec | 2 +- dlls/winex11.drv/keyboard.c | 2 +- dlls/winex11.drv/winex11.drv.spec | 2 +- 9 files changed, 84 insertions(+), 108 deletions(-) diff --git a/dlls/user32/driver.c b/dlls/user32/driver.c index 7ac77141696..7f26a48657f 100644 --- a/dlls/user32/driver.c +++ b/dlls/user32/driver.c @@ -284,9 +284,9 @@ static BOOL CDECL nulldrv_RegisterHotKey( HWND hwnd, UINT modifiers, UINT vk ) } static INT CDECL nulldrv_ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, LPWSTR str, - int size, UINT flags, HKL layout ) + int size, UINT flags, HKL layout, INT default_ret ) { - return 0; + return default_ret; } static BOOL CDECL nulldrv_UnloadKeyboardLayout( HKL layout ) @@ -592,9 +592,9 @@ static BOOL CDECL loaderdrv_RegisterHotKey( HWND hwnd, UINT modifiers, UINT vk ) } static INT CDECL loaderdrv_ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, LPWSTR str, - int size, UINT flags, HKL layout ) + int size, UINT flags, HKL layout, INT default_ret ) { - return load_driver()->pToUnicodeEx( virt, scan, state, str, size, flags, layout ); + return load_driver()->pToUnicodeEx( virt, scan, state, str, size, flags, layout, default_ret ); } static BOOL CDECL loaderdrv_UnloadKeyboardLayout( HKL layout ) diff --git a/dlls/user32/input.c b/dlls/user32/input.c index 805bfe3e9de..4f0be6be3f2 100644 --- a/dlls/user32/input.c +++ b/dlls/user32/input.c @@ -877,11 +877,82 @@ INT WINAPI ToUnicode(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, /**************************************************************************** * ToUnicodeEx (USER32.@) */ -INT WINAPI ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, - LPWSTR lpwStr, int size, UINT flags, HKL hkl) +INT WINAPI ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, + WCHAR *str, int size, UINT flags, HKL layout ) { - if (!lpKeyState) return 0; - return USER_Driver->pToUnicodeEx(virtKey, scanCode, lpKeyState, lpwStr, size, flags, hkl); + static HKL us_layout = (HKL)MAKELONG(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT)); + BOOL shift, ctrl, numlock; + WCHAR buffer[2]; + INT len; + + TRACE_(keyboard)( "virt %u, scan %u, state %p, str %p, size %d, flags %x, layout %p.\n", + virt, scan, state, str, size, flags, layout ); + + if (!state) return 0; + + shift = state[VK_SHIFT] & 0x80; + ctrl = state[VK_CONTROL] & 0x80; + numlock = state[VK_NUMLOCK] & 0x01; + + if (layout != us_layout) buffer[0] = 0; /* FIXME: non-us layout */ + else if (scan & 0x8000) buffer[0] = 0; /* key up */ + else if (!ctrl) + { + switch (virt) + { + case VK_BACK: buffer[0] = '\b'; break; + case VK_OEM_1: buffer[0] = shift ? ':' : ';'; break; + case VK_OEM_2: buffer[0] = shift ? '?' : '/'; break; + case VK_OEM_3: buffer[0] = shift ? '~' : '`'; break; + case VK_OEM_4: buffer[0] = shift ? '{' : '['; break; + case VK_OEM_5: buffer[0] = shift ? '|' : '\\'; break; + case VK_OEM_6: buffer[0] = shift ? '}' : ']'; break; + case VK_OEM_7: buffer[0] = shift ? '"' : '\''; break; + case VK_OEM_COMMA: buffer[0] = shift ? '<' : ','; break; + case VK_OEM_MINUS: buffer[0] = shift ? '_' : '-'; break; + case VK_OEM_PERIOD: buffer[0] = shift ? '>' : '.'; break; + case VK_OEM_PLUS: buffer[0] = shift ? '+' : '='; break; + case VK_RETURN: buffer[0] = '\r'; break; + case VK_SPACE: buffer[0] = ' '; break; + case VK_TAB: buffer[0] = '\t'; break; + case VK_MULTIPLY: buffer[0] = '*'; break; + case VK_ADD: buffer[0] = '+'; break; + case VK_SUBTRACT: buffer[0] = '-'; break; + case VK_DIVIDE: buffer[0] = '/'; break; + default: + if (virt >= '0' && virt <= '9') + buffer[0] = shift ? ")!@#$%^&*("[virt - '0'] : virt; + else if (virt >= 'A' && virt <= 'Z') + buffer[0] = shift || (state[VK_CAPITAL] & 0x01) ? virt : virt + 'a' - 'A'; + else if (virt >= VK_NUMPAD0 && virt <= VK_NUMPAD9 && numlock && !shift) + buffer[0] = '0' + virt - VK_NUMPAD0; + else if (virt == VK_DECIMAL && numlock && !shift) + buffer[0] = '.'; + else + buffer[0] = 0; + break; + } + } + else /* Control codes */ + { + switch (virt) + { + case VK_OEM_4: buffer[0] = 0x1b; break; + case VK_OEM_5: buffer[0] = 0x1c; break; + case VK_OEM_6: buffer[0] = 0x1d; break; + case VK_SUBTRACT: buffer[0] = 0x1e; break; + default: + if (virt >= 'A' && virt <= 'Z') buffer[0] = virt - 'A' + 1; + else buffer[0] = 0; + break; + } + } + buffer[1] = 0; + + wcsncpy( str, buffer, size ); + len = USER_Driver->pToUnicodeEx( virt, scan, state, str, size, flags, layout, wcslen( buffer ) ); + TRACE_(keyboard)( "ret %d, str %s.\n", len, debugstr_wn(str, len) ); + return len; } /**************************************************************************** diff --git a/dlls/user32/user_private.h b/dlls/user32/user_private.h index 5f8059a12a0..98eec94da57 100644 --- a/dlls/user32/user_private.h +++ b/dlls/user32/user_private.h @@ -71,7 +71,7 @@ typedef struct tagUSER_DRIVER { HKL (CDECL *pLoadKeyboardLayout)(LPCWSTR, UINT); UINT (CDECL *pMapVirtualKeyEx)(UINT, UINT, HKL); BOOL (CDECL *pRegisterHotKey)(HWND, UINT, UINT); - INT (CDECL *pToUnicodeEx)(UINT, UINT, const BYTE *, LPWSTR, int, UINT, HKL); + INT (CDECL *pToUnicodeEx)(UINT, UINT, const BYTE *, LPWSTR, int, UINT, HKL, INT); BOOL (CDECL *pUnloadKeyboardLayout)(HKL); void (CDECL *pUnregisterHotKey)(HWND, UINT, UINT); SHORT (CDECL *pVkKeyScanEx)(WCHAR, HKL); diff --git a/dlls/wineandroid.drv/keyboard.c b/dlls/wineandroid.drv/keyboard.c index 0a6ede0ec5f..04565c3fad8 100644 --- a/dlls/wineandroid.drv/keyboard.c +++ b/dlls/wineandroid.drv/keyboard.c @@ -750,100 +750,6 @@ jboolean keyboard_event( JNIEnv *env, jobject obj, jint win, jint action, jint k } -/*********************************************************************** - * ANDROID_ToUnicodeEx - */ -INT CDECL ANDROID_ToUnicodeEx( UINT virt, UINT scan, const BYTE *state, - LPWSTR buf, int size, UINT flags, HKL hkl ) -{ - WCHAR buffer[2]; - BOOL shift = state[VK_SHIFT] & 0x80; - BOOL ctrl = state[VK_CONTROL] & 0x80; - BOOL numlock = state[VK_NUMLOCK] & 0x01; - - buffer[0] = buffer[1] = 0; - - if (scan & 0x8000) return 0; /* key up */ - - /* FIXME: hardcoded layout */ - - if (!ctrl) - { - switch (virt) - { - case VK_BACK: buffer[0] = '\b'; break; - case VK_OEM_1: buffer[0] = shift ? ':' : ';'; break; - case VK_OEM_2: buffer[0] = shift ? '?' : '/'; break; - case VK_OEM_3: buffer[0] = shift ? '~' : '`'; break; - case VK_OEM_4: buffer[0] = shift ? '{' : '['; break; - case VK_OEM_5: buffer[0] = shift ? '|' : '\\'; break; - case VK_OEM_6: buffer[0] = shift ? '}' : ']'; break; - case VK_OEM_7: buffer[0] = shift ? '"' : '\''; break; - case VK_OEM_COMMA: buffer[0] = shift ? '<' : ','; break; - case VK_OEM_MINUS: buffer[0] = shift ? '_' : '-'; break; - case VK_OEM_PERIOD: buffer[0] = shift ? '>' : '.'; break; - case VK_OEM_PLUS: buffer[0] = shift ? '+' : '='; break; - case VK_RETURN: buffer[0] = '\r'; break; - case VK_SPACE: buffer[0] = ' '; break; - case VK_TAB: buffer[0] = '\t'; break; - case VK_MULTIPLY: buffer[0] = '*'; break; - case VK_ADD: buffer[0] = '+'; break; - case VK_SUBTRACT: buffer[0] = '-'; break; - case VK_DIVIDE: buffer[0] = '/'; break; - default: - if (virt >= '0' && virt <= '9') - { - buffer[0] = shift ? ")!@#$%^&*("[virt - '0'] : virt; - break; - } - if (virt >= 'A' && virt <= 'Z') - { - buffer[0] = shift || (state[VK_CAPITAL] & 0x01) ? virt : virt + 'a' - 'A'; - break; - } - if (virt >= VK_NUMPAD0 && virt <= VK_NUMPAD9 && numlock && !shift) - { - buffer[0] = '0' + virt - VK_NUMPAD0; - break; - } - if (virt == VK_DECIMAL && numlock && !shift) - { - buffer[0] = '.'; - break; - } - break; - } - } - else /* Control codes */ - { - if (virt >= 'A' && virt <= 'Z') - buffer[0] = virt - 'A' + 1; - else - { - switch (virt) - { - case VK_OEM_4: - buffer[0] = 0x1b; - break; - case VK_OEM_5: - buffer[0] = 0x1c; - break; - case VK_OEM_6: - buffer[0] = 0x1d; - break; - case VK_SUBTRACT: - buffer[0] = 0x1e; - break; - } - } - } - - lstrcpynW( buf, buffer, size ); - TRACE( "returning %d / %s\n", strlenW( buffer ), debugstr_wn(buf, strlenW( buffer ))); - return strlenW( buffer ); -} - - /*********************************************************************** * ANDROID_GetKeyNameText */ diff --git a/dlls/wineandroid.drv/wineandroid.drv.spec b/dlls/wineandroid.drv/wineandroid.drv.spec index 00de23de27e..6f27c1586b3 100644 --- a/dlls/wineandroid.drv/wineandroid.drv.spec +++ b/dlls/wineandroid.drv/wineandroid.drv.spec @@ -7,7 +7,6 @@ @ cdecl GetKeyNameText(long ptr long) ANDROID_GetKeyNameText @ cdecl GetKeyboardLayout(long) ANDROID_GetKeyboardLayout @ cdecl MapVirtualKeyEx(long long long) ANDROID_MapVirtualKeyEx -@ cdecl ToUnicodeEx(long long ptr ptr long long long) ANDROID_ToUnicodeEx @ cdecl VkKeyScanEx(long long) ANDROID_VkKeyScanEx @ cdecl SetCursor(long) ANDROID_SetCursor @ cdecl ChangeDisplaySettingsEx(ptr ptr long long long) ANDROID_ChangeDisplaySettingsEx diff --git a/dlls/winemac.drv/keyboard.c b/dlls/winemac.drv/keyboard.c index 1ea15f59341..5e4b5882c77 100644 --- a/dlls/winemac.drv/keyboard.c +++ b/dlls/winemac.drv/keyboard.c @@ -1553,7 +1553,7 @@ BOOL CDECL macdrv_RegisterHotKey(HWND hwnd, UINT mod_flags, UINT vkey) * */ INT CDECL macdrv_ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, - LPWSTR bufW, int bufW_size, UINT flags, HKL hkl) + LPWSTR bufW, int bufW_size, UINT flags, HKL hkl, INT default_ret) { struct macdrv_thread_data *thread_data = macdrv_init_thread_data(); INT ret = 0; diff --git a/dlls/winemac.drv/winemac.drv.spec b/dlls/winemac.drv/winemac.drv.spec index 39cf33370b4..3baa730eabc 100644 --- a/dlls/winemac.drv/winemac.drv.spec +++ b/dlls/winemac.drv/winemac.drv.spec @@ -34,7 +34,7 @@ @ cdecl SysCommand(long long long) macdrv_SysCommand @ cdecl SystemParametersInfo(long long ptr long) macdrv_SystemParametersInfo @ cdecl ThreadDetach() macdrv_ThreadDetach -@ cdecl ToUnicodeEx(long long ptr ptr long long long) macdrv_ToUnicodeEx +@ cdecl ToUnicodeEx(long long ptr ptr long long long long) macdrv_ToUnicodeEx @ cdecl UnregisterHotKey(long long long) macdrv_UnregisterHotKey @ cdecl UpdateClipboard() macdrv_UpdateClipboard @ cdecl UpdateLayeredWindow(long ptr ptr) macdrv_UpdateLayeredWindow diff --git a/dlls/winex11.drv/keyboard.c b/dlls/winex11.drv/keyboard.c index 01620c5e4a4..82dd67d9373 100644 --- a/dlls/winex11.drv/keyboard.c +++ b/dlls/winex11.drv/keyboard.c @@ -2432,7 +2432,7 @@ static char KEYBOARD_MapDeadKeysym(KeySym keysym) * */ INT CDECL X11DRV_ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState, - LPWSTR bufW, int bufW_size, UINT flags, HKL hkl) + LPWSTR bufW, int bufW_size, UINT flags, HKL hkl, INT default_ret) { Display *display = thread_init_display(); XKeyEvent e; diff --git a/dlls/winex11.drv/winex11.drv.spec b/dlls/winex11.drv/winex11.drv.spec index c0e24d8fe82..7aecac2c016 100644 --- a/dlls/winex11.drv/winex11.drv.spec +++ b/dlls/winex11.drv/winex11.drv.spec @@ -11,7 +11,7 @@ @ cdecl GetKeyboardLayoutName(ptr) X11DRV_GetKeyboardLayoutName @ cdecl LoadKeyboardLayout(wstr long) X11DRV_LoadKeyboardLayout @ cdecl MapVirtualKeyEx(long long long) X11DRV_MapVirtualKeyEx -@ cdecl ToUnicodeEx(long long ptr ptr long long long) X11DRV_ToUnicodeEx +@ cdecl ToUnicodeEx(long long ptr ptr long long long long) X11DRV_ToUnicodeEx @ cdecl UnloadKeyboardLayout(long) X11DRV_UnloadKeyboardLayout @ cdecl VkKeyScanEx(long long) X11DRV_VkKeyScanEx @ cdecl DestroyCursorIcon(long) X11DRV_DestroyCursorIcon -- 2.31.0

4 12

[PATCH v2] winegstreamer: Poll gst_pad_query_duration before converting from byte length.
by Connor McAdams 26 Apr '21

26 Apr '21

Wait to query the pad duration until after caps are received, and poll gst_pad_query_duration a few times before giving up and trying to get duration by converting from byte-length. Fixes a bug in Fallout: New Vegas where the duration value is incorrect and causes the audio to loop. Signed-off-by: Connor McAdams <cmcadams(a)codeweavers.com> --- dlls/winegstreamer/wg_parser.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/dlls/winegstreamer/wg_parser.c b/dlls/winegstreamer/wg_parser.c index 5529321490e..e07fb7510ac 100644 --- a/dlls/winegstreamer/wg_parser.c +++ b/dlls/winegstreamer/wg_parser.c @@ -1499,9 +1499,21 @@ static gboolean src_event_cb(GstPad *pad, GstObject *parent, GstEvent *event) static LONGLONG query_duration(GstPad *pad) { gint64 duration, byte_length; + unsigned int i; if (gst_pad_query_duration(pad, GST_FORMAT_TIME, &duration)) return duration / 100; + /* + * Sometimes we query duration too early, try again a few times before + * giving up and trying to convert from byte length. If the duration can't + * be found after 50ms, we probably have a bigger issue. + */ + for (i = 0; i < 10; ++i) + { + g_usleep(5000); + if (gst_pad_query_duration(pad, GST_FORMAT_TIME, &duration)) + return duration / 100; + } WARN("Failed to query time duration; trying to convert from byte length.\n"); @@ -1553,9 +1565,9 @@ static HRESULT CDECL wg_parser_connect(struct wg_parser *parser, uint64_t file_s { struct wg_parser_stream *stream = parser->streams[i]; - stream->duration = query_duration(stream->their_src); while (!stream->has_caps && !parser->error) pthread_cond_wait(&parser->init_cond, &parser->mutex); + stream->duration = query_duration(stream->their_src); if (parser->error) { pthread_mutex_unlock(&parser->mutex); -- 2.25.1

2 1

[PATCH] windowscodecs: Add stub for DdsFrameEncode.
by Ziqing Hui 26 Apr '21

26 Apr '21

Signed-off-by: Ziqing Hui <zhui(a)codeweavers.com> --- dlls/windowscodecs/ddsformat.c | 234 ++++++++++++++++++++++++++++++++- 1 file changed, 231 insertions(+), 3 deletions(-)

2 1

[PATCH] mscoree: Initialize parsed_config_file private_path.
by Rémi Bernon 26 Apr '21

26 Apr '21

In case of error we may free uninitialized pointer otherwise. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- The free happens in free_parsed_config_file, which is called unconditionnally after parse_config_file / parsed_config_stream. dlls/mscoree/config.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/mscoree/config.c b/dlls/mscoree/config.c index 38f304f3df8..b6aa647d876 100644 --- a/dlls/mscoree/config.c +++ b/dlls/mscoree/config.c @@ -617,6 +617,7 @@ static const struct ISAXErrorHandlerVtbl ConfigFileHandlerErrorVtbl = static void init_config(parsed_config_file *config) { list_init(&config->supported_runtimes); + config->private_path = NULL; } static HRESULT parse_config(VARIANT input, parsed_config_file *result) -- 2.31.0

2 1

[PATCH] advapi32: Introduce QueryTraceA()
by David Koolhoven 26 Apr '21

26 Apr '21

Provide QueryTraceA() to programs which need it. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=50992 Signed-off-by: David Koolhoven <david(a)koolhoven-home.net> --- dlls/advapi32/advapi32.spec | 2 +- dlls/advapi32/eventlog.c | 9 +++++++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/dlls/advapi32/advapi32.spec b/dlls/advapi32/advapi32.spec index d5235c6adb9..1b7a83d347a 100644 --- a/dlls/advapi32/advapi32.spec +++ b/dlls/advapi32/advapi32.spec @@ -603,7 +603,7 @@ @ stdcall -import QueryServiceObjectSecurity(long long ptr long ptr) @ stdcall -import QueryServiceStatus(long ptr) @ stdcall -import QueryServiceStatusEx (long long ptr long ptr) -# @ stub QueryTraceA +@ stdcall QueryTraceA(int64 str ptr) @ stdcall QueryTraceW(int64 wstr ptr) # @ stub QueryUserServiceName # @ stub QueryUsersOnEncryptedFile diff --git a/dlls/advapi32/eventlog.c b/dlls/advapi32/eventlog.c index c01955e22d5..22e5a3f9d59 100644 --- a/dlls/advapi32/eventlog.c +++ b/dlls/advapi32/eventlog.c @@ -673,6 +673,15 @@ ULONG WINAPI StopTraceA( TRACEHANDLE session, LPCSTR session_name, PEVENT_TRACE_ return ERROR_SUCCESS; } +/****************************************************************************** + * QueryTraceA [ADVAPI32.@] + */ +ULONG WINAPI QueryTraceA( TRACEHANDLE handle, LPCSTR sessionname, PEVENT_TRACE_PROPERTIES properties ) +{ + FIXME("%s %s %p: stub\n", wine_dbgstr_longlong(handle), debugstr_a(sessionname), properties); + return ERROR_WMI_INSTANCE_NOT_FOUND; +} + /****************************************************************************** * QueryTraceW [ADVAPI32.@] */ -- 2.19.1

1 0

[PATCH] windows.globalization: Fix an incorrect sizeof (Coverity).
by Sven Baars 26 Apr '21

26 Apr '21

Signed-off-by: Sven Baars <sbaars(a)codeweavers.com> --- dlls/windows.globalization/main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/windows.globalization/main.c b/dlls/windows.globalization/main.c index 1c41e77d41b..b124f79c644 100644 --- a/dlls/windows.globalization/main.c +++ b/dlls/windows.globalization/main.c @@ -183,7 +183,7 @@ static HRESULT STDMETHODCALLTYPE hstring_vector_GetMany(IVectorView_HSTRING *ifa TRACE("iface %p, start_index %#x, items %p, count %p.\n", iface, start_index, items, count); - memset(items, 0, items_size * sizeof(HSTRING *)); + memset(items, 0, items_size * sizeof(*items)); for (i = start_index; i < impl->count && i < start_index + items_size; ++i) if (FAILED(hr = WindowsDuplicateString(impl->values[i], items + i - start_index))) -- 2.30.0.335.ge6362826a0

3 5

[PATCH] winegstreamer: Poll gst_pad_query_duration before converting from byte length.
by Connor McAdams 26 Apr '21

26 Apr '21

Poll gst_pad_query_duration a few times before giving up and trying to get duration by converting from byte-length. Fixes a bug in Fallout: New Vegas where the duration value is incorrect and causes the audio to loop. Signed-off-by: Connor McAdams <cmcadams(a)codeweavers.com> --- dlls/winegstreamer/wg_parser.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/dlls/winegstreamer/wg_parser.c b/dlls/winegstreamer/wg_parser.c index 5529321490e..391b0b26532 100644 --- a/dlls/winegstreamer/wg_parser.c +++ b/dlls/winegstreamer/wg_parser.c @@ -1499,9 +1499,21 @@ static gboolean src_event_cb(GstPad *pad, GstObject *parent, GstEvent *event) static LONGLONG query_duration(GstPad *pad) { gint64 duration, byte_length; + unsigned int i; if (gst_pad_query_duration(pad, GST_FORMAT_TIME, &duration)) return duration / 100; + /* + * Sometimes we query duration too early, try again a few times before + * giving up and trying to convert from byte length. If the duration can't + * be found after 50ms, we probably have a bigger issue. + */ + for (i = 0; i < 10; ++i) + { + g_usleep(5000); + if (gst_pad_query_duration(pad, GST_FORMAT_TIME, &duration)) + return duration / 100; + } WARN("Failed to query time duration; trying to convert from byte length.\n"); -- 2.25.1

1 1

[PATCH v7 1/4] kernel32/tests: Test renaming a file/directory to a different casing of itself or existing target.
by Gabriel Ivăncescu 26 Apr '21

26 Apr '21

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/kernel32/tests/file.c | 64 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/dlls/kernel32/tests/file.c b/dlls/kernel32/tests/file.c index 5deed96..bb05188 100644 --- a/dlls/kernel32/tests/file.c +++ b/dlls/kernel32/tests/file.c @@ -1954,6 +1954,7 @@ static void test_MoveFileA(void) char tempdir[MAX_PATH]; char source[MAX_PATH], dest[MAX_PATH]; static const char prefix[] = "pfx"; + WIN32_FIND_DATAA find_data; HANDLE hfile; HANDLE hmapfile; DWORD ret; @@ -2023,9 +2024,72 @@ static void test_MoveFileA(void) ok(ret, "MoveFileA: failed, error %d\n", GetLastError()); lstrcatA(tempdir, "Remove Me"); + + /* test renaming a file "Remove Me" to itself but in lowercase "me" */ + lstrcpyA(source, tempdir); + tempdir[lstrlenA(tempdir) - 2] = 'm'; + + hfile = CreateFileA(source, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0); + ok(hfile != INVALID_HANDLE_VALUE, "failed to create %s\n", source); + CloseHandle(hfile); + + ret = MoveFileA(source, tempdir); + ok(ret, "MoveFileA: failed, error %d\n", GetLastError()); + + hfile = FindFirstFileA(tempdir, &find_data); + ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); + if (hfile != INVALID_HANDLE_VALUE) + { + todo_wine ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), + "MoveFile failed to change casing on same file: got %s\n", find_data.cFileName); + } + CloseHandle(hfile); + + /* test renaming another file "Remove Be" to "Remove Me", which replaces the existing "Remove me" */ + tempdir[lstrlenA(tempdir) - 2] = 'B'; + + hfile = CreateFileA(tempdir, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0); + ok(hfile != INVALID_HANDLE_VALUE, "failed to create %s\n", tempdir); + CloseHandle(hfile); + + ret = MoveFileA(tempdir, source); + ok(!ret, "MoveFileA: expected failure\n"); + ok(GetLastError() == ERROR_ALREADY_EXISTS, "MoveFileA: expected ERROR_ALREADY_EXISTS, got %d\n", GetLastError()); + ret = MoveFileExA(tempdir, source, MOVEFILE_REPLACE_EXISTING); + ok(ret, "MoveFileExA: failed, error %d\n", GetLastError()); + + tempdir[lstrlenA(tempdir) - 2] = 'm'; + + hfile = FindFirstFileA(tempdir, &find_data); + ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); + if (hfile != INVALID_HANDLE_VALUE) + { + ok(!lstrcmpA(strrchr(source, '\\') + 1, find_data.cFileName), + "MoveFile failed to change casing on existing target file: got %s\n", find_data.cFileName); + } + CloseHandle(hfile); + + ret = DeleteFileA(tempdir); + ok(ret, "DeleteFileA: error %d\n", GetLastError()); + + /* now test a directory from "Remove me" to uppercase "Me" */ ret = CreateDirectoryA(tempdir, NULL); ok(ret == TRUE, "CreateDirectoryA failed\n"); + lstrcpyA(source, tempdir); + tempdir[lstrlenA(tempdir) - 2] = 'M'; + ret = MoveFileA(source, tempdir); + ok(ret, "MoveFileA: failed, error %d\n", GetLastError()); + + hfile = FindFirstFileA(tempdir, &find_data); + ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); + if (hfile != INVALID_HANDLE_VALUE) + { + todo_wine ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), + "MoveFile failed to change casing on same directory: got %s\n", find_data.cFileName); + } + CloseHandle(hfile); + lstrcpyA(source, dest); lstrcpyA(dest, tempdir); lstrcatA(dest, "\\wild?.*"); -- 2.30.0

4 8

[PATCH vkd3d 1/6] vkd3d-shader: Rename name_offset to name_bytecode_offset.
by Zebediah Figura 26 Apr '21

26 Apr '21

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/hlsl.h | 4 ++-- libs/vkd3d-shader/hlsl_codegen.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 3dc7a26b..0c755f46 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -136,9 +136,9 @@ struct hlsl_struct_field struct hlsl_type *type; const char *name; const char *semantic; - unsigned int reg_offset; - unsigned int name_offset; + + unsigned int name_bytecode_offset; }; struct hlsl_reg diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 1b5e8a27..2c07171b 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -1051,7 +1051,7 @@ static void write_sm1_type(struct bytecode_buffer *buffer, struct hlsl_type *typ { LIST_FOR_EACH_ENTRY(field, array_type->e.elements, struct hlsl_struct_field, entry) { - field->name_offset = buffer->count; + field->name_bytecode_offset = buffer->count; put_string(buffer, field->name); write_sm1_type(buffer, field->type, ctab_start); } @@ -1060,7 +1060,7 @@ static void write_sm1_type(struct bytecode_buffer *buffer, struct hlsl_type *typ LIST_FOR_EACH_ENTRY(field, array_type->e.elements, struct hlsl_struct_field, entry) { - put_dword(buffer, (field->name_offset - ctab_start) * sizeof(*buffer->data)); + put_dword(buffer, (field->name_bytecode_offset - ctab_start) * sizeof(*buffer->data)); put_dword(buffer, (field->type->bytecode_offset - ctab_start) * sizeof(*buffer->data)); ++field_count; } -- 2.31.1

5 17

[PATCH 1/4] include: Always define u_* types in winsock.h.
by Zebediah Figura 26 Apr '21

26 Apr '21

All modules either build with msvcrt headers or define USE_WS_PREFIX now. Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- include/msvcrt/sys/types.h | 8 -------- include/winsock.h | 21 +++++---------------- 2 files changed, 5 insertions(+), 24 deletions(-) diff --git a/include/msvcrt/sys/types.h b/include/msvcrt/sys/types.h index b44aa386d44..47af7752a5d 100644 --- a/include/msvcrt/sys/types.h +++ b/include/msvcrt/sys/types.h @@ -46,14 +46,6 @@ typedef int _off_t; #define _OFF_T_DEFINED #endif -#ifndef _BSDTYPES_DEFINED -typedef unsigned char u_char; -typedef unsigned short u_short; -typedef unsigned int u_int; -typedef __msvcrt_ulong u_long; -#define _BSDTYPES_DEFINED -#endif - #define dev_t _dev_t #define ino_t _ino_t #define mode_t _mode_t diff --git a/include/winsock.h b/include/winsock.h index cafac1a1723..1d33d573329 100644 --- a/include/winsock.h +++ b/include/winsock.h @@ -114,28 +114,17 @@ #include <inaddr.h> -#ifdef USE_WS_PREFIX -typedef unsigned char WS_u_char; -typedef unsigned short WS_u_short; -typedef unsigned int WS_u_int; -typedef ULONG WS_u_long; -#elif (defined(_MSC_VER) || defined(__MINGW32__) || defined(__WATCOMC__)) && !defined(_BSDTYPES_DEFINED) -/* MinGW doesn't define the u_xxx types */ -typedef unsigned char u_char; -typedef unsigned short u_short; -typedef unsigned int u_int; -typedef ULONG u_long; -#define _BSDTYPES_DEFINED -#else -#define u_long ULONG /* make sure we don't use the system u_long */ -#endif - #ifdef USE_WS_PREFIX # define WS(x) WS_##x #else # define WS(x) x #endif +typedef unsigned char WS(u_char); +typedef unsigned short WS(u_short); +typedef unsigned int WS(u_int); +typedef ULONG WS(u_long); + #ifdef __cplusplus extern "C" { #endif /* defined(__cplusplus) */ -- 2.30.2

4 7

[PATCH v4 1/5] wined3d: Add VK_BUFFER_USAGE_VERTEX_BUFFER_BIT to the null buffer's usage.
by Jan Sikorski 26 Apr '21

26 Apr '21

Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> --- dlls/wined3d/device.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index bf4c37756a7..f3d7cff74bf 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -652,7 +652,7 @@ bool wined3d_device_vk_create_null_resources(struct wined3d_device_vk *device_vk vk_info = context_vk->vk_info; usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT - | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; + | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; memory_type = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; if (!wined3d_context_vk_create_bo(context_vk, 16, usage, memory_type, &r->bo)) return false; -- 2.30.2

2 6

[PATCH 4/4] explorer: Initialise window->pidl to NULL in shellwindows_Register().
by Henri Verbeet 26 Apr '21

26 Apr '21

Since array_reserve() doesn't. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- programs/explorer/desktop.c | 1 + 1 file changed, 1 insertion(+) diff --git a/programs/explorer/desktop.c b/programs/explorer/desktop.c index 94d178880a8..51d1535aea6 100644 --- a/programs/explorer/desktop.c +++ b/programs/explorer/desktop.c @@ -1219,6 +1219,7 @@ static HRESULT WINAPI shellwindows_Register(IShellWindows *iface, window->hwnd = hwnd; window->class = class; *cookie = window->cookie = ++cookie_counter; + window->pidl = NULL; LeaveCriticalSection(&sw->cs); return S_OK; -- 2.20.1

1 0

[PATCH 3/4] ntdll: Clear ret->Buffer on failure in get_env_var() (Valgrind).
by Henri Verbeet 26 Apr '21

26 Apr '21

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/ntdll/loader.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/dlls/ntdll/loader.c b/dlls/ntdll/loader.c index 38dd276608b..e71564d065b 100644 --- a/dlls/ntdll/loader.c +++ b/dlls/ntdll/loader.c @@ -2604,7 +2604,11 @@ static NTSTATUS get_env_var( const WCHAR *name, SIZE_T extra, UNICODE_STRING *re return status; } RtlFreeHeap( GetProcessHeap(), 0, ret->Buffer ); - if (status != STATUS_BUFFER_TOO_SMALL) return status; + if (status != STATUS_BUFFER_TOO_SMALL) + { + ret->Buffer = NULL; + return status; + } size = len + 1 + extra; } } -- 2.20.1

1 0

[PATCH 2/4] wined3d: Correct the wined3d_device_set_depth_stencil_state() .spec entry.
by Henri Verbeet 26 Apr '21

26 Apr '21

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/wined3d.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/wined3d/wined3d.spec b/dlls/wined3d/wined3d.spec index 3d10509c389..1ea837cc59a 100644 --- a/dlls/wined3d/wined3d.spec +++ b/dlls/wined3d/wined3d.spec @@ -104,7 +104,7 @@ @ cdecl wined3d_device_set_cs_uav(ptr long ptr long) @ cdecl wined3d_device_set_cursor_position(ptr long long long) @ cdecl wined3d_device_set_cursor_properties(ptr long long ptr long) -@ cdecl wined3d_device_set_depth_stencil_state(ptr ptr) +@ cdecl wined3d_device_set_depth_stencil_state(ptr ptr long) @ cdecl wined3d_device_set_depth_stencil_view(ptr ptr) @ cdecl wined3d_device_set_dialog_box_mode(ptr long) @ cdecl wined3d_device_set_domain_shader(ptr ptr) -- 2.20.1

1 0

[PATCH 1/4] wined3d: Correct the wined3d_device_set_blend_state() .spec entry.
by Henri Verbeet 26 Apr '21

26 Apr '21

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/wined3d.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/wined3d/wined3d.spec b/dlls/wined3d/wined3d.spec index 203ffd67b89..3d10509c389 100644 --- a/dlls/wined3d/wined3d.spec +++ b/dlls/wined3d/wined3d.spec @@ -95,7 +95,7 @@ @ cdecl wined3d_device_release_focus_window(ptr) @ cdecl wined3d_device_reset(ptr ptr ptr ptr long) @ cdecl wined3d_device_set_base_vertex_index(ptr long) -@ cdecl wined3d_device_set_blend_state(ptr ptr ptr) +@ cdecl wined3d_device_set_blend_state(ptr ptr ptr long) @ cdecl wined3d_device_set_clip_status(ptr ptr) @ cdecl wined3d_device_set_compute_shader(ptr ptr) @ cdecl wined3d_device_set_constant_buffer(ptr long long ptr) -- 2.20.1

1 0

[PATCH 1/4] mf/evr: Return current device manager as a service.
by Nikolay Sivov 26 Apr '21

26 Apr '21

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mf/evr.c | 39 +++++++++++++++++++++++++++++++-------- dlls/mf/tests/mf.c | 4 ++++ 2 files changed, 35 insertions(+), 8 deletions(-) diff --git a/dlls/mf/evr.c b/dlls/mf/evr.c index 79e2f57f9c5..8b4a9c03b5f 100644 --- a/dlls/mf/evr.c +++ b/dlls/mf/evr.c @@ -591,19 +591,14 @@ static ULONG WINAPI video_stream_get_service_Release(IMFGetService *iface) return IMFStreamSink_Release(&stream->IMFStreamSink_iface); } -static HRESULT WINAPI video_stream_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj) +static HRESULT WINAPI video_stream_get_service(struct video_stream *stream, REFGUID service, REFIID riid, void **obj) { - struct video_stream *stream = impl_from_stream_IMFGetService(iface); HRESULT hr = S_OK; - TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj); - if (IsEqualGUID(service, &MR_VIDEO_ACCELERATION_SERVICE)) { if (IsEqualIID(riid, &IID_IMFVideoSampleAllocator)) { - EnterCriticalSection(&stream->cs); - if (!stream->allocator) { hr = MFCreateVideoSampleAllocator(&IID_IMFVideoSampleAllocator, (void **)&stream->allocator); @@ -613,10 +608,12 @@ static HRESULT WINAPI video_stream_get_service_GetService(IMFGetService *iface, if (SUCCEEDED(hr)) hr = IMFVideoSampleAllocator_QueryInterface(stream->allocator, riid, obj); - LeaveCriticalSection(&stream->cs); - return hr; } + else if (IsEqualIID(riid, &IID_IDirect3DDeviceManager9) && stream->parent->device_manager) + { + return IUnknown_QueryInterface(stream->parent->device_manager, riid, obj); + } return E_NOINTERFACE; } @@ -626,6 +623,23 @@ static HRESULT WINAPI video_stream_get_service_GetService(IMFGetService *iface, return E_NOTIMPL; } +static HRESULT WINAPI video_stream_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj) +{ + struct video_stream *stream = impl_from_stream_IMFGetService(iface); + HRESULT hr; + + TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj); + + EnterCriticalSection(&stream->cs); + if (!stream->parent) + hr = MF_E_STREAMSINK_REMOVED; + else + hr = video_stream_get_service(stream, service, riid, obj); + LeaveCriticalSection(&stream->cs); + + return hr; +} + static const IMFGetServiceVtbl video_stream_get_service_vtbl = { video_stream_get_service_QueryInterface, @@ -1992,6 +2006,8 @@ static HRESULT WINAPI video_renderer_get_service_GetService(IMFGetService *iface TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj); + EnterCriticalSection(&renderer->cs); + if (IsEqualGUID(service, &MR_VIDEO_MIXER_SERVICE)) { hr = IMFTransform_QueryInterface(renderer->mixer, &IID_IMFGetService, (void **)&gs); @@ -2000,11 +2016,18 @@ static HRESULT WINAPI video_renderer_get_service_GetService(IMFGetService *iface { hr = IMFVideoPresenter_QueryInterface(renderer->presenter, &IID_IMFGetService, (void **)&gs); } + else if (IsEqualGUID(service, &MR_VIDEO_ACCELERATION_SERVICE) && IsEqualIID(riid, &IID_IDirect3DDeviceManager9)) + { + if (renderer->device_manager) + hr = IUnknown_QueryInterface(renderer->device_manager, riid, obj); + } else { FIXME("Unsupported service %s.\n", debugstr_guid(service)); } + LeaveCriticalSection(&renderer->cs); + if (gs) { hr = IMFGetService_GetService(gs, service, riid, obj); diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index b990b4614da..39b9d64e729 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -4269,6 +4269,7 @@ static void test_evr(void) check_service_interface(sink, &MR_VIDEO_MIXER_SERVICE, &IID_IMFVideoMixerControl2, TRUE); check_service_interface(sink, &MR_VIDEO_RENDER_SERVICE, &IID_IMFVideoDisplayControl, TRUE); check_service_interface(sink, &MR_VIDEO_RENDER_SERVICE, &IID_IMFVideoPositionMapper, TRUE); + check_service_interface(sink, &MR_VIDEO_ACCELERATION_SERVICE, &IID_IDirect3DDeviceManager9, TRUE); hr = MFGetService((IUnknown *)sink, &MR_VIDEO_RENDER_SERVICE, &IID_IMFVideoDisplayControl, (void **)&display_control); @@ -4415,6 +4416,9 @@ static void test_evr(void) IMFMediaTypeHandler_Release(type_handler); /* Stream uses an allocator. */ + check_service_interface(stream_sink, &MR_VIDEO_ACCELERATION_SERVICE, &IID_IMFVideoSampleAllocator, TRUE); + check_service_interface(stream_sink, &MR_VIDEO_ACCELERATION_SERVICE, &IID_IDirect3DDeviceManager9, TRUE); + hr = MFGetService((IUnknown *)stream_sink, &MR_VIDEO_ACCELERATION_SERVICE, &IID_IMFVideoSampleAllocator, (void **)&allocator); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); -- 2.30.2

2 5

[PATCH 4/4] msxml3: When saving XML use encoding specified in the processing instruction.
by Dmitry Timoshkov 26 Apr '21

26 Apr '21

Otherwise when a PI node with not default encoding is assigned to a document then saving an XML leads to document being encoded as UTF-8 while XML declaration has what PI specifies. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/domdoc.c | 70 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 68 insertions(+), 2 deletions(-) diff --git a/dlls/msxml3/domdoc.c b/dlls/msxml3/domdoc.c index cf4f0433218..8e29c67148e 100644 --- a/dlls/msxml3/domdoc.c +++ b/dlls/msxml3/domdoc.c @@ -2528,6 +2528,63 @@ static int XMLCALL domdoc_stream_save_closecallback(void *ctx) return 0; } +static char *xmldoc_encoding(IXMLDOMDocument3 *doc) +{ + HRESULT hr; + IXMLDOMNode *node; + char *encoding = NULL; + + hr = IXMLDOMDocument3_get_firstChild(doc, &node); + if (hr == S_OK) + { + DOMNodeType type; + + hr = IXMLDOMNode_get_nodeType(node, &type); + if (hr == S_OK && type == NODE_PROCESSING_INSTRUCTION) + { + IXMLDOMProcessingInstruction *pi; + IXMLDOMNode *item; + IXMLDOMNamedNodeMap *node_map; + + hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void **)&pi); + if (hr == S_OK) + { + hr = IXMLDOMNode_get_attributes(node, &node_map); + if (hr == S_OK) + { + static const WCHAR encodingW[] = {'e','n','c','o','d','i','n','g',0}; + BSTR bstr; + + bstr = SysAllocString(encodingW); + hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, bstr, &item); + SysFreeString(bstr); + if (hr == S_OK) + { + VARIANT var; + + hr = IXMLDOMNode_get_nodeValue(item, &var); + if (hr == S_OK) + { + if (V_VT(&var) == VT_BSTR) + encoding = (char *)xmlchar_from_wchar(V_BSTR(&var)); + + VariantClear(&var); + } + } + + IXMLDOMNamedNodeMap_Release(node_map); + } + + IXMLDOMProcessingInstruction_Release(pi); + } + } + + IXMLDOMNode_Release(node); + } + + return encoding; +} + static HRESULT WINAPI domdoc_save( IXMLDOMDocument3 *iface, VARIANT destination ) @@ -2566,8 +2623,12 @@ static HRESULT WINAPI domdoc_save( ret = IUnknown_QueryInterface(pUnk, &IID_IStream, (void**)&stream); if(ret == S_OK) { + char *encoding = xmldoc_encoding(iface); + + TRACE("using encoding %s\n", encoding ? debugstr_a(encoding) : "default"); ctx = xmlSaveToIO(domdoc_stream_save_writecallback, - domdoc_stream_save_closecallback, stream, NULL, XML_SAVE_NO_DECL); + domdoc_stream_save_closecallback, stream, encoding, XML_SAVE_NO_DECL); + heap_free(encoding); if(!ctx) { @@ -2581,6 +2642,7 @@ static HRESULT WINAPI domdoc_save( case VT_BSTR: case VT_BSTR | VT_BYREF: { + char *encoding; /* save with file path */ HANDLE handle = CreateFileW( (V_VT(&destination) & VT_BYREF)? *V_BSTRREF(&destination) : V_BSTR(&destination), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); @@ -2590,8 +2652,12 @@ static HRESULT WINAPI domdoc_save( return E_FAIL; } + encoding = xmldoc_encoding(iface); + TRACE("using encoding %s\n", encoding ? debugstr_a(encoding) : "default"); ctx = xmlSaveToIO(domdoc_save_writecallback, domdoc_save_closecallback, - handle, NULL, XML_SAVE_NO_DECL); + handle, encoding, XML_SAVE_NO_DECL); + heap_free(encoding); + if (!ctx) { CloseHandle(handle); -- 2.31.1

2 1

[PATCH 3/4] msxml3: Implement IXMLDOMNamedNodeMap::getNamedItem() for a processing instruction node.
by Dmitry Timoshkov 26 Apr '21

26 Apr '21

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/pi.c | 45 +++++++++++++++++++++++++++++++++++--- dlls/msxml3/tests/domdoc.c | 6 +---- 2 files changed, 43 insertions(+), 8 deletions(-) diff --git a/dlls/msxml3/pi.c b/dlls/msxml3/pi.c index fe291e72af8..59ceee767a1 100644 --- a/dlls/msxml3/pi.c +++ b/dlls/msxml3/pi.c @@ -813,6 +813,27 @@ static const struct IXMLDOMProcessingInstructionVtbl dom_pi_vtbl = dom_pi_put_data }; +static xmlAttrPtr node_has_prop(const xmlNode *node, const xmlChar *name) +{ + xmlAttrPtr prop; + + /* xmlHasNsProp accepts only nodes of type XML_ELEMENT_NODE, + * so we have to look for an attribute in the node by hand. + */ + + prop = node->properties; + + while (prop) + { + if (xmlStrEqual(prop->name, name)) + return prop; + + prop = prop->next; + } + + return NULL; +} + static HRESULT dom_pi_get_qualified_item(const xmlNodePtr node, BSTR name, BSTR uri, IXMLDOMNode **item) { @@ -822,10 +843,28 @@ static HRESULT dom_pi_get_qualified_item(const xmlNodePtr node, BSTR name, BSTR static HRESULT dom_pi_get_named_item(const xmlNodePtr node, BSTR name, IXMLDOMNode **item) { - FIXME("(%p)->(%s %p): stub\n", node, debugstr_w(name), item ); - if (item) + xmlChar *nameA; + xmlAttrPtr attr; + + TRACE("(%p)->(%s %p)\n", node, debugstr_w(name), item); + + if (!item) return E_POINTER; + + nameA = xmlchar_from_wchar(name); + if (!nameA) return E_OUTOFMEMORY; + + attr = node_has_prop(node, nameA); + heap_free(nameA); + + if (!attr) + { *item = NULL; - return S_FALSE; + return S_FALSE; + } + + *item = create_node((xmlNodePtr)attr); + + return S_OK; } static HRESULT dom_pi_set_named_item(xmlNodePtr node, IXMLDOMNode *newItem, IXMLDOMNode **namedItem) diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 51980afb2d7..abe36c1fae4 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -8579,13 +8579,9 @@ todo_wine item = NULL; hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, _bstr_("encoding"), &item); -todo_wine ok(hr == S_OK, "got 0x%08x\n", hr); -todo_wine ok(item != NULL, "got NULL\n"); -if (hr == S_OK) -{ hr = IXMLDOMNode_get_nodeName(item, &bstr); ok(!lstrcmpW(bstr, L"encoding"), "got %s\n", wine_dbgstr_w(bstr)); SysFreeString(bstr); @@ -8595,7 +8591,7 @@ if (hr == S_OK) ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&var) == VT_BSTR, "got %u\n", V_VT(&var)); ok(!lstrcmpW(V_BSTR(&var), L"windows-1252"), "got %s\n", wine_dbgstr_w(V_BSTR(&var))); -} + IXMLDOMNamedNodeMap_Release(node_map); IXMLDOMNode_Release(node); IXMLDOMProcessingInstruction_Release(pi); -- 2.31.1

2 1

[PATCH 1/4] msxml3/tests: Add more tests for processing instruction attributes.
by Dmitry Timoshkov 26 Apr '21

26 Apr '21

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/tests/domdoc.c | 40 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 38 insertions(+), 2 deletions(-) diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 6f8e2b44ed3..51980afb2d7 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -46,6 +46,8 @@ #include "wine/heap.h" #include "wine/test.h" +#define XML_E_UNEXPECTED_ATTRIBUTE 0xC00CE56C + /* undef the #define in msxml2 so that we can access all versions */ #undef CLSID_DOMDocument @@ -8529,10 +8531,11 @@ static void test_createProcessingInstruction(void) static const char xml3_wine[] = "<?xml version=\"1.0\" standalone=\"yes\"?>\n<test/>\n"; IXMLDOMProcessingInstruction *pi; IXMLDOMDocument *doc; - IXMLDOMNode *node; + IXMLDOMNode *node, *item; + IXMLDOMNamedNodeMap *node_map; IXMLDOMElement *element; WCHAR buff[10]; - BSTR xml; + BSTR xml, bstr; VARIANT var; HRESULT hr; IStream *stream; @@ -8543,6 +8546,10 @@ static void test_createProcessingInstruction(void) doc = create_document(&IID_IXMLDOMDocument); + hr = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\" encoding=\"windows-1252\" dummy=\"value\""), &pi); +todo_wine + ok(hr == XML_E_UNEXPECTED_ATTRIBUTE, "got 0x%08x\n", hr); + /* test for BSTR handling, pass broken BSTR */ memcpy(&buff[2], L"test", 5 * sizeof(WCHAR)); /* just a big length */ @@ -8561,6 +8568,35 @@ static void test_createProcessingInstruction(void) ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXMLDOMDocument_appendChild(doc, node, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = IXMLDOMNode_get_attributes(node, &node_map); + ok(hr == S_OK, "got 0x%08x\n", hr); + + item = (void *)0xdeadbeef; + hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, _bstr_("xml"), &item); + ok(hr == S_FALSE, "got 0x%08x\n", hr); + ok(!item, "got %p\n", item); + + item = NULL; + hr = IXMLDOMNamedNodeMap_getNamedItem(node_map, _bstr_("encoding"), &item); +todo_wine + ok(hr == S_OK, "got 0x%08x\n", hr); +todo_wine + ok(item != NULL, "got NULL\n"); + +if (hr == S_OK) +{ + hr = IXMLDOMNode_get_nodeName(item, &bstr); + ok(!lstrcmpW(bstr, L"encoding"), "got %s\n", wine_dbgstr_w(bstr)); + SysFreeString(bstr); + + VariantInit(&var); + hr = IXMLDOMNode_get_nodeValue(item, &var); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(V_VT(&var) == VT_BSTR, "got %u\n", V_VT(&var)); + ok(!lstrcmpW(V_BSTR(&var), L"windows-1252"), "got %s\n", wine_dbgstr_w(V_BSTR(&var))); +} + IXMLDOMNamedNodeMap_Release(node_map); IXMLDOMNode_Release(node); IXMLDOMProcessingInstruction_Release(pi); -- 2.31.1

2 1

[PATCH 2/4] msxml3: Implement ::get_attributes() for "xml" processing instruction node.
by Dmitry Timoshkov 26 Apr '21

26 Apr '21

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/pi.c | 140 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 139 insertions(+), 1 deletion(-) diff --git a/dlls/msxml3/pi.c b/dlls/msxml3/pi.c index cea95708087..fe291e72af8 100644 --- a/dlls/msxml3/pi.c +++ b/dlls/msxml3/pi.c @@ -34,6 +34,7 @@ #include "ole2.h" #include "msxml6.h" +#include "xmlparser.h" #include "msxml_private.h" #include "wine/debug.h" @@ -287,6 +288,138 @@ static HRESULT WINAPI dom_pi_get_nextSibling( return node_get_next_sibling(&This->node, domNode); } +static HRESULT xml_get_value(xmlChar **p, xmlChar **value) +{ + xmlChar *v; + int len; + + while (isspace(**p)) *p += 1; + if (**p != '=') return XML_E_MISSINGEQUALS; + *p += 1; + + while (isspace(**p)) *p += 1; + if (**p != '"') return XML_E_MISSINGQUOTE; + *p += 1; + + v = *p; + while (**p && **p != '"') *p += 1; + if (!**p) return XML_E_EXPECTINGCLOSEQUOTE; + len = *p - v; + if (!len) return XML_E_MISSINGNAME; + *p += 1; + + *value = heap_alloc(len + 1); + if (!*value) return E_OUTOFMEMORY; + memcpy(*value, v, len); + *(*value + len) = 0; + + return S_OK; +} + +static void set_prop(xmlNodePtr node, xmlAttrPtr attr) +{ + xmlAttrPtr prop; + + if (!node->properties) + { + node->properties = attr; + return; + } + + prop = node->properties; + while (prop->next) prop = prop->next; + + prop->next = attr; +} + +static HRESULT parse_xml_decl(xmlNodePtr node) +{ + xmlChar *version, *encoding, *standalone, *p; + xmlAttrPtr attr; + HRESULT hr = S_OK; + + if (!node->content) return S_OK; + + version = encoding = standalone = NULL; + + p = node->content; + + while (*p) + { + while (isspace(*p)) p++; + if (!*p) break; + + if (!strncmp((const char *)p, "version", 7)) + { + p += 7; + if ((hr = xml_get_value(&p, &version)) != S_OK) goto fail; + } + else if (!strncmp((const char *)p, "encoding", 8)) + { + p += 8; + if ((hr = xml_get_value(&p, &encoding)) != S_OK) goto fail; + } + else if (!strncmp((const char *)p, "standalone", 10)) + { + p += 10; + if ((hr = xml_get_value(&p, &standalone)) != S_OK) goto fail; + } + else + { + FIXME("unexpected XML attribute %s\n", debugstr_a((const char *)p)); + hr = XML_E_UNEXPECTED_ATTRIBUTE; + goto fail; + } + } + + /* xmlSetProp/xmlSetNsProp accept only nodes of type XML_ELEMENT_NODE, + * so we have to create and assign attributes to a node by hand. + */ + + if (version) + { + attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"version", version); + if (attr) + { + attr->doc = node->doc; + set_prop(node, attr); + } + else hr = E_OUTOFMEMORY; + } + if (encoding) + { + attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"encoding", encoding); + if (attr) + { + attr->doc = node->doc; + set_prop(node, attr); + } + else hr = E_OUTOFMEMORY; + } + if (standalone) + { + attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"standalone", standalone); + if (attr) + { + attr->doc = node->doc; + set_prop(node, attr); + } + else hr = E_OUTOFMEMORY; + } + +fail: + if (hr != S_OK) + { + xmlFreePropList(node->properties); + node->properties = NULL; + } + + heap_free(version); + heap_free(encoding); + heap_free(standalone); + return hr; +} + static HRESULT WINAPI dom_pi_get_attributes( IXMLDOMProcessingInstruction *iface, IXMLDOMNamedNodeMap** map) @@ -307,7 +440,12 @@ static HRESULT WINAPI dom_pi_get_attributes( if (!strcmpW(name, xmlW)) { - FIXME("created dummy map for <?xml ?>\n"); + if (!This->node.node->properties) + { + hr = parse_xml_decl(This->node.node); + if (hr != S_OK) return S_FALSE; + } + *map = create_nodemap(This->node.node, &dom_pi_attr_map); SysFreeString(name); return S_OK; -- 2.31.1

1 0

[PATCH resend3] kernel32: Print processor group in Get(Active|Maximum)ProcessorCount
by Alex Henrie 26 Apr '21

26 Apr '21

Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/kernel32/process.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/kernel32/process.c b/dlls/kernel32/process.c index f07a997bea3..b31d73bc5a5 100644 --- a/dlls/kernel32/process.c +++ b/dlls/kernel32/process.c @@ -620,7 +620,7 @@ DWORD WINAPI GetActiveProcessorCount(WORD group) { DWORD cpus = system_info.NumberOfProcessors; - FIXME("semi-stub, returning %u\n", cpus); + FIXME("(0x%x): semi-stub, returning %u\n", group, cpus); return cpus; } @@ -631,7 +631,7 @@ DWORD WINAPI GetMaximumProcessorCount(WORD group) { DWORD cpus = system_info.NumberOfProcessors; - FIXME("semi-stub, returning %u\n", cpus); + FIXME("(0x%x): semi-stub, returning %u\n", group, cpus); return cpus; } -- 2.31.1

1 0

[PATCH] shcore/stream: Implement generic CopyTo().
by Nikolay Sivov 26 Apr '21

26 Apr '21

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- Duplicated from HGLOBAL stream. dlls/shcore/main.c | 48 +++++++++++++++++++++++++++++++++++++++------- 1 file changed, 41 insertions(+), 7 deletions(-) diff --git a/dlls/shcore/main.c b/dlls/shcore/main.c index fd21db423ea..82b236bb47d 100644 --- a/dlls/shcore/main.c +++ b/dlls/shcore/main.c @@ -695,20 +695,54 @@ static HRESULT WINAPI memstream_SetSize(IStream *iface, ULARGE_INTEGER new_size) return S_OK; } -static HRESULT WINAPI shstream_CopyTo(IStream *iface, IStream *pstm, ULARGE_INTEGER size, ULARGE_INTEGER *read_len, ULARGE_INTEGER *written) +static HRESULT WINAPI shstream_CopyTo(IStream *iface, IStream *dest, ULARGE_INTEGER size, + ULARGE_INTEGER *read_len, ULARGE_INTEGER *written) { struct shstream *stream = impl_from_IStream(iface); + ULARGE_INTEGER total_read, total_written; + HRESULT hr = S_OK; + BYTE buffer[0x400]; - TRACE("(%p)\n", stream); + TRACE("(%p, %p, %s, %p, %p)\n", stream, dest, wine_dbgstr_longlong(size.QuadPart), read_len, written); - if (read_len) - read_len->QuadPart = 0; + if (!dest) + return E_POINTER; + + total_read.QuadPart = 0; + total_written.QuadPart = 0; + + while (size.QuadPart > 0) + { + ULONG chunk_size = size.QuadPart >= sizeof(buffer) ? sizeof(buffer) : size.u.LowPart; + ULONG chunk_read, chunk_written; + + hr = IStream_Read(iface, buffer, chunk_size, &chunk_read); + if (FAILED(hr)) + break; + total_read.QuadPart += chunk_read; + + if (chunk_read) + { + hr = IStream_Write(dest, buffer, chunk_read, &chunk_written); + if (FAILED(hr)) + break; + + total_written.QuadPart += chunk_written; + } + + if (chunk_read != chunk_size) + size.QuadPart = 0; + else + size.QuadPart -= chunk_read; + } + + if (read_len) + read_len->QuadPart = total_read.QuadPart; if (written) - written->QuadPart = 0; + written->QuadPart = total_written.QuadPart; - /* TODO implement */ - return E_NOTIMPL; + return hr; } static HRESULT WINAPI shstream_Commit(IStream *iface, DWORD flags) -- 2.30.2

1 0

[PATCH] winevulkan: Override VK_USE_64_BIT_PTR_DEFINES instead of handle definition.
by Georg Lehmann 25 Apr '21

25 Apr '21

A bit simpler and more consistent because currently VK_USE_64_BIT_PTR_DEFINES can be 1 but non dipatchable handles are always unit64_t. Signed-off-by: Georg Lehmann <dadschoorse(a)gmail.com> --- dlls/winevulkan/make_vulkan | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 66b28bf13df..fc6aa4de7db 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -319,15 +319,11 @@ class VkDefine(object): # <type category="define" name="some_name">some_value</type> name = define.attrib.get("name") - # We override behavior of VK_DEFINE_NON_DISPATCHABLE handle as the default + # We override behavior of VK_USE_64_BIT_PTR_DEFINES as the default non-dispatchable handle # definition various between 64-bit (uses pointers) and 32-bit (uses uint64_t). # This complicates TRACEs in the thunks, so just use uint64_t. - if name == "VK_DEFINE_NON_DISPATCHABLE_HANDLE": - value = "#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;" - # As VK_DEFINE_NON_DISPATCHABLE handle is overriden above, we must also override - # VK_NULL_HANDLE so that its type will match. - elif name == "VK_NULL_HANDLE": - value = "#define VK_NULL_HANDLE 0ULL" + if name == "VK_USE_64_BIT_PTR_DEFINES": + value = "#define VK_USE_64_BIT_PTR_DEFINES 0" else: value = define.text return VkDefine(name, value) -- 2.31.1

1 0

[PATCH] kernelbase: Always remove trailing spaces in PathRemoveBlanks.
by Esme Povirk 24 Apr '21

24 Apr '21

Signed-off-by: Esme Povirk <esme(a)codeweavers.com> --- The intent of the changed if statement was probably to prevent reading past the start of a string consisting only of spaces, but it didn't account for path being changed. In practice, this meant that trailing spaces would only be removed if there were leading spaces, and it would read past the start of a string containing only spaces. dlls/kernelbase/path.c | 12 ++++++----- dlls/shlwapi/tests/path.c | 45 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 5 deletions(-) diff --git a/dlls/kernelbase/path.c b/dlls/kernelbase/path.c index f0c79bcc94c..14e892bcc42 100644 --- a/dlls/kernelbase/path.c +++ b/dlls/kernelbase/path.c @@ -1902,14 +1902,14 @@ BOOL WINAPI PathIsUNCServerW(const WCHAR *path) void WINAPI PathRemoveBlanksA(char *path) { - char *start; + char *start, *first; TRACE("%s\n", wine_dbgstr_a(path)); if (!path || !*path) return; - start = path; + start = first = path; while (*path == ' ') path = CharNextA(path); @@ -1917,7 +1917,7 @@ void WINAPI PathRemoveBlanksA(char *path) while (*path) *start++ = *path++; - if (start != path) + if (start != first) while (start[-1] == ' ') start--; @@ -1926,20 +1926,22 @@ void WINAPI PathRemoveBlanksA(char *path) void WINAPI PathRemoveBlanksW(WCHAR *path) { - WCHAR *start = path; + WCHAR *start, *first; TRACE("%s\n", wine_dbgstr_w(path)); if (!path || !*path) return; + start = first = path; + while (*path == ' ') path++; while (*path) *start++ = *path++; - if (start != path) + if (start != first) while (start[-1] == ' ') start--; diff --git a/dlls/shlwapi/tests/path.c b/dlls/shlwapi/tests/path.c index c5142b992aa..e9f08a902b0 100644 --- a/dlls/shlwapi/tests/path.c +++ b/dlls/shlwapi/tests/path.c @@ -1712,6 +1712,50 @@ static void test_PathUndecorate(void) PathUndecorateW(NULL); } +static void test_PathRemoveBlanks(void) +{ + struct remove_blanks_test { + const char* input; + const char* expected; + }; + struct remove_blanks_test tests[] = { + {"", ""}, + {" ", ""}, + {"test", "test"}, + {" test", "test"}, + {" test", "test"}, + {"test ", "test"}, + {"test ", "test"}, + {" test ", "test"}, + {" test ", "test"}}; + char pathA[MAX_PATH]; + WCHAR pathW[MAX_PATH]; + int i, ret; + const UINT CP_ASCII = 20127; + + PathRemoveBlanksW(NULL); + PathRemoveBlanksA(NULL); + + for (i=0; i < ARRAY_SIZE(tests); i++) + { + strcpy(pathA, tests[i].input); + PathRemoveBlanksA(pathA); + ok(strcmp(pathA, tests[i].expected) == 0, "input string '%s', expected '%s', got '%s'\n", + tests[i].input, tests[i].expected, pathA); + + ret = MultiByteToWideChar(CP_ASCII, MB_ERR_INVALID_CHARS, tests[i].input, -1, pathW, MAX_PATH); + ok(ret != 0, "MultiByteToWideChar failed for '%s'\n", tests[i].input); + + PathRemoveBlanksW(pathW); + + ret = WideCharToMultiByte(CP_ASCII, 0, pathW, -1, pathA, MAX_PATH, NULL, NULL); + ok(ret != 0, "WideCharToMultiByte failed for %s from test string '%s'\n", wine_dbgstr_w(pathW), tests[i].input); + + ok(strcmp(pathA, tests[i].expected) == 0, "input string '%s', expected '%s', got '%s'\n", + tests[i].input, tests[i].expected, pathA); + } +} + START_TEST(path) { HMODULE hShlwapi = GetModuleHandleA("shlwapi.dll"); @@ -1759,4 +1803,5 @@ START_TEST(path) test_PathIsRelativeW(); test_PathStripPathA(); test_PathUndecorate(); + test_PathRemoveBlanks(); } -- 2.25.1

1 0

Wine staging 6.7 release
by Alistair Leslie-Hughes 24 Apr '21

24 Apr '21

Binary packages for various distributions will be available from: https://www.winehq.org/download Summary since last release * Rebased to current wine 6.7 (643 patches are applied to wine vanilla) Upstreamed (Either directly from staging or fixed with a similar patch). * winegstreamer: Set MF_MT_ALL_SAMPLES_INDEPENDENT attribute on raw video media types. * ntdll: Allow special characters in pipe names. * user32/tests: Add more SendInput tests. * user32: Implement SendInput INPUT_HARDWARE check. * user32: Add RAWINPUT parameter to __wine_send_input. * hidclass.sys: Assign rawinput device handle in HID_LinkDevice. * wineboot: Init system32/drivers/etc/{host,networks,protocol,services}. * include: Add xact2wb.h * include: Add xact.h * xactengine2_0: Add new dll. * xactengine2_4: Add new dll. * xactengine2_7: Add new dll. * xactengine2_10: Add new dll. * wineboot: Assign a drive serial number during prefix creation/update. * server: Map group SIDs to Unix groups even if the owner doesn't match the current user. Added: * [51049] Create a new Context when the input object is NULL (Sea of Thieves) Updated: * user32-rawinput-mouse Where can you help * Run Steam/Battle.net/GOG/UPlay/Epic * Test your favorite game. * Test your favorite applications. * Improve staging patches and get them accepted upstream. As always, if you find a bug, please report it via https://bugs.winehq.org Best Regards Alistair.

1 0

[PATCH 4/4] mshtml: Use Gecko attributes for getAttribute, setAttribute and removeAttribute implementation in IE8+ mode.
by Jacek Caban 23 Apr '21

23 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/mshtml/htmlelem.c | 31 +++++++++++++++++++++++++++++++ dlls/mshtml/tests/documentmode.js | 30 ++++++++++++++++++++++++++++++ dlls/mshtml/tests/dom.js | 8 -------- 3 files changed, 61 insertions(+), 8 deletions(-)

2 1

[PATCH 2/4] mshtml: Add IHTMLElement6::hasAttribute implementation.
by Jacek Caban 23 Apr '21

23 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/mshtml/htmlelem.c | 25 ++++++++++++++++++++++--- dlls/mshtml/tests/dom.js | 20 ++++++++++++++++++++ 2 files changed, 42 insertions(+), 3 deletions(-)

2 1

[PATCH 1/4] mshtml: Use Gecko attributes for non-HTML elements IHTMLElement::title implementation.
by Jacek Caban 23 Apr '21

23 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/mshtml/htmlelem.c | 10 ++++++++-- dlls/mshtml/tests/documentmode.js | 1 + dlls/mshtml/tests/dom.js | 10 ++++++++++ 3 files changed, 19 insertions(+), 2 deletions(-)

2 1

[PATCH 3/4] mshtml: Reimplement IHTMLElement3::disabled property on top of Gecko attributes.
by Jacek Caban 23 Apr '21

23 Apr '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/mshtml/htmlelem.c | 45 +++++++++++++++++----------------------- dlls/mshtml/tests/dom.js | 28 +++++++++++++++++++++++++ 2 files changed, 47 insertions(+), 26 deletions(-)

1 0

[PATCH] user32: Don't set maximized position placement for toplevel windows covering the entire work area.
by Gabriel Ivăncescu 23 Apr '21

23 Apr '21

The game "Imperiums: Greek Wars" depends on this to display its window properly. It also fixes the todo_wine in test_window_placement, along with a few new tests that show exactly the threshold at which the "transition" happens. Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/user32/tests/win.c | 54 ++++++++++++++++++++++++++++++++--------- dlls/user32/winpos.c | 39 ++++++++++++++++++++++++++++- 2 files changed, 80 insertions(+), 13 deletions(-) diff --git a/dlls/user32/tests/win.c b/dlls/user32/tests/win.c index dbb5f4c..fcb2398 100644 --- a/dlls/user32/tests/win.c +++ b/dlls/user32/tests/win.c @@ -11360,8 +11360,9 @@ static void test_IsWindowEnabled(void) static void test_window_placement(void) { - RECT orig = {100, 200, 300, 400}, orig2 = {200, 300, 400, 500}, rect; + RECT orig = {100, 200, 300, 400}, orig2 = {200, 300, 400, 500}, rect, work_rect; WINDOWPLACEMENT wp = {sizeof(wp)}; + MONITORINFO mon_info; HWND hwnd; BOOL ret; @@ -11369,6 +11370,10 @@ static void test_window_placement(void) orig.left, orig.top, orig.right - orig.left, orig.bottom - orig.top, 0, 0, 0, 0); ok(!!hwnd, "failed to create window, error %u\n", GetLastError()); + mon_info.cbSize = sizeof(mon_info); + GetMonitorInfoW(MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY), &mon_info); + work_rect = mon_info.rcWork; + ret = GetWindowPlacement(hwnd, &wp); ok(ret, "failed to get window placement, error %u\n", GetLastError()); ok(wp.showCmd == SW_SHOWNORMAL, "got show cmd %u\n", wp.showCmd); @@ -11411,7 +11416,6 @@ static void test_window_placement(void) ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", @@ -11429,6 +11433,42 @@ todo_wine ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", wine_dbgstr_rect(&wp.rcNormalPosition)); + SetWindowPos(hwnd, 0, work_rect.left, work_rect.top, work_rect.right - work_rect.left, + work_rect.bottom - work_rect.top, SWP_NOZORDER | SWP_NOACTIVATE); + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %u\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, + "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); + ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, + "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + + SetWindowPos(hwnd, 0, work_rect.left, work_rect.top, work_rect.right - work_rect.left - 1, + work_rect.bottom - work_rect.top, SWP_NOZORDER | SWP_NOACTIVATE); + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %u\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, + "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); + ok(wp.ptMaxPosition.x == work_rect.left && wp.ptMaxPosition.y == work_rect.top, + "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + + SetWindowPos(hwnd, 0, work_rect.left, work_rect.top, work_rect.right - work_rect.left, + work_rect.bottom - work_rect.top - 1, SWP_NOZORDER | SWP_NOACTIVATE); + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %u\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, + "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); + ok(wp.ptMaxPosition.x == work_rect.left && wp.ptMaxPosition.y == work_rect.top, + "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + ShowWindow(hwnd, SW_MINIMIZE); ret = GetWindowPlacement(hwnd, &wp); @@ -11437,7 +11477,6 @@ todo_wine ok(wp.showCmd == SW_SHOWMINIMIZED, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", @@ -11450,7 +11489,6 @@ todo_wine ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", @@ -11463,7 +11501,6 @@ todo_wine ok(wp.showCmd == SW_SHOWNORMAL, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", @@ -11481,7 +11518,6 @@ todo_wine ok(wp.showCmd == SW_SHOWNORMAL, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == 100 && wp.ptMinPosition.y == 100, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig2), "got normal pos %s\n", @@ -11497,7 +11533,6 @@ todo_wine ok(wp.showCmd == SW_SHOWMINIMIZED, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig2), "got normal pos %s\n", @@ -11519,7 +11554,6 @@ todo_wine ok(wp.showCmd == SW_SHOWMINIMIZED, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", @@ -11540,7 +11574,6 @@ todo_wine ok(wp.showCmd == SW_SHOWMAXIMIZED, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == 100 && wp.ptMinPosition.y == 100, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", @@ -11561,7 +11594,6 @@ todo_wine ok(wp.showCmd == SW_SHOWMINIMIZED, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", @@ -11575,7 +11607,6 @@ todo_wine ok(wp.showCmd == SW_SHOWMINIMIZED, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", @@ -11590,7 +11621,6 @@ todo_wine ok(wp.showCmd == SW_NORMAL, "got show cmd %u\n", wp.showCmd); ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); -todo_wine ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", diff --git a/dlls/user32/winpos.c b/dlls/user32/winpos.c index c6f806f..6e727ce 100644 --- a/dlls/user32/winpos.c +++ b/dlls/user32/winpos.c @@ -915,6 +915,42 @@ static POINT get_minimized_pos( HWND hwnd, POINT pt ) return pt; } +static POINT get_maximized_pos( WND *wnd, POINT pos ) +{ + MONITORINFO mon_info; + HMONITOR monitor; + RECT rc_work; + + /* top level windows covering the working area are not set, + to avoid situations where the border style changes and + the window is in the wrong position outside the screen */ + if (!wnd->parent || wnd->parent == GetDesktopWindow()) + { + if (wnd->dwStyle & WS_MAXIMIZE) + { + if ((monitor = MonitorFromWindow( wnd->obj.handle, MONITOR_DEFAULTTOPRIMARY ))) + { + mon_info.cbSize = sizeof(mon_info); + GetMonitorInfoW( monitor, &mon_info ); + rc_work = mon_info.rcMonitor; + + if ((wnd->dwStyle & WS_CAPTION) == WS_CAPTION || !(wnd->dwStyle & (WS_CHILD | WS_POPUP))) + rc_work = mon_info.rcWork; + } + else + SetRect( &rc_work, 0, 0, GetSystemMetrics( SM_CXSCREEN ), GetSystemMetrics( SM_CYSCREEN ) ); + + if (wnd->window_rect.left <= rc_work.left && wnd->window_rect.top <= rc_work.top && + wnd->window_rect.right >= rc_work.right && wnd->window_rect.bottom >= rc_work.bottom) + pos.x = pos.y = -1; + } + else + pos.x = pos.y = -1; + } + + return pos; +} + /*********************************************************************** * WINPOS_MinMaximize @@ -1325,6 +1361,7 @@ BOOL WINAPI GetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *wndpl ) { pWnd->normal_rect = pWnd->window_rect; } + pWnd->max_pos = get_maximized_pos( pWnd, pWnd->max_pos ); wndpl->length = sizeof(*wndpl); if( pWnd->dwStyle & WS_MINIMIZE ) @@ -1413,7 +1450,7 @@ static BOOL WINPOS_SetPlacement( HWND hwnd, const WINDOWPLACEMENT *wndpl, UINT f if (!pWnd || pWnd == WND_OTHER_PROCESS || pWnd == WND_DESKTOP) return FALSE; if (flags & PLACE_MIN) pWnd->min_pos = point_thread_to_win_dpi( hwnd, wp.ptMinPosition ); - if (flags & PLACE_MAX) pWnd->max_pos = point_thread_to_win_dpi( hwnd, wp.ptMaxPosition ); + if (flags & PLACE_MAX) pWnd->max_pos = get_maximized_pos( pWnd, point_thread_to_win_dpi( hwnd, wp.ptMaxPosition ) ); if (flags & PLACE_RECT) pWnd->normal_rect = rect_thread_to_win_dpi( hwnd, wp.rcNormalPosition ); style = pWnd->dwStyle; -- 2.30.0

1 0

[PATCH v6 1/4] kernel32/tests: Test renaming a file/directory to a different casing of itself or existing target.
by Gabriel Ivăncescu 23 Apr '21

23 Apr '21

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/kernel32/tests/file.c | 64 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/dlls/kernel32/tests/file.c b/dlls/kernel32/tests/file.c index 5deed96..bb05188 100644 --- a/dlls/kernel32/tests/file.c +++ b/dlls/kernel32/tests/file.c @@ -1954,6 +1954,7 @@ static void test_MoveFileA(void) char tempdir[MAX_PATH]; char source[MAX_PATH], dest[MAX_PATH]; static const char prefix[] = "pfx"; + WIN32_FIND_DATAA find_data; HANDLE hfile; HANDLE hmapfile; DWORD ret; @@ -2023,9 +2024,72 @@ static void test_MoveFileA(void) ok(ret, "MoveFileA: failed, error %d\n", GetLastError()); lstrcatA(tempdir, "Remove Me"); + + /* test renaming a file "Remove Me" to itself but in lowercase "me" */ + lstrcpyA(source, tempdir); + tempdir[lstrlenA(tempdir) - 2] = 'm'; + + hfile = CreateFileA(source, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0); + ok(hfile != INVALID_HANDLE_VALUE, "failed to create %s\n", source); + CloseHandle(hfile); + + ret = MoveFileA(source, tempdir); + ok(ret, "MoveFileA: failed, error %d\n", GetLastError()); + + hfile = FindFirstFileA(tempdir, &find_data); + ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); + if (hfile != INVALID_HANDLE_VALUE) + { + todo_wine ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), + "MoveFile failed to change casing on same file: got %s\n", find_data.cFileName); + } + CloseHandle(hfile); + + /* test renaming another file "Remove Be" to "Remove Me", which replaces the existing "Remove me" */ + tempdir[lstrlenA(tempdir) - 2] = 'B'; + + hfile = CreateFileA(tempdir, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0); + ok(hfile != INVALID_HANDLE_VALUE, "failed to create %s\n", tempdir); + CloseHandle(hfile); + + ret = MoveFileA(tempdir, source); + ok(!ret, "MoveFileA: expected failure\n"); + ok(GetLastError() == ERROR_ALREADY_EXISTS, "MoveFileA: expected ERROR_ALREADY_EXISTS, got %d\n", GetLastError()); + ret = MoveFileExA(tempdir, source, MOVEFILE_REPLACE_EXISTING); + ok(ret, "MoveFileExA: failed, error %d\n", GetLastError()); + + tempdir[lstrlenA(tempdir) - 2] = 'm'; + + hfile = FindFirstFileA(tempdir, &find_data); + ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); + if (hfile != INVALID_HANDLE_VALUE) + { + ok(!lstrcmpA(strrchr(source, '\\') + 1, find_data.cFileName), + "MoveFile failed to change casing on existing target file: got %s\n", find_data.cFileName); + } + CloseHandle(hfile); + + ret = DeleteFileA(tempdir); + ok(ret, "DeleteFileA: error %d\n", GetLastError()); + + /* now test a directory from "Remove me" to uppercase "Me" */ ret = CreateDirectoryA(tempdir, NULL); ok(ret == TRUE, "CreateDirectoryA failed\n"); + lstrcpyA(source, tempdir); + tempdir[lstrlenA(tempdir) - 2] = 'M'; + ret = MoveFileA(source, tempdir); + ok(ret, "MoveFileA: failed, error %d\n", GetLastError()); + + hfile = FindFirstFileA(tempdir, &find_data); + ok(hfile != INVALID_HANDLE_VALUE, "FindFirstFileA: failed, error %d\n", GetLastError()); + if (hfile != INVALID_HANDLE_VALUE) + { + todo_wine ok(!lstrcmpA(strrchr(tempdir, '\\') + 1, find_data.cFileName), + "MoveFile failed to change casing on same directory: got %s\n", find_data.cFileName); + } + CloseHandle(hfile); + lstrcpyA(source, dest); lstrcpyA(dest, tempdir); lstrcatA(dest, "\\wild?.*"); -- 2.30.0

2 5

[PATCH] mfplat/tests: Fix an event queue refcounting test on Vista.
by Francois Gouget 23 Apr '21

23 Apr '21

Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- > That means Vista leaks it, not something we want to do. I'd rather > skip all tests on Vista. That seems a bit radical. As far as this failure is concerned, this patch should be sufficient. dlls/mfplat/tests/mfplat.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c index caf6f78d9e9..fbac078bed3 100644 --- a/dlls/mfplat/tests/mfplat.c +++ b/dlls/mfplat/tests/mfplat.c @@ -3129,7 +3129,9 @@ static void test_event_queue(void) EXPECT_REF(&callback.IMFAsyncCallback_iface, 2); IMFMediaEventQueue_Release(queue); - EXPECT_REF(&callback.IMFAsyncCallback_iface, 1); + ret = get_refcount(&callback.IMFAsyncCallback_iface); + ok(ret == 1 || broken(ret == 2) /* Vista */, + "Unexpected refcount %d, expected 1.\n", ret); hr = MFShutdown(); ok(hr == S_OK, "Failed to shut down, hr %#x.\n", hr); -- 2.20.1

2 1

[PATCH] comctl32: send DTN_DATETIMECHANGE when the checkbox changes too
by Damjan Jovanovic 23 Apr '21

23 Apr '21

Currently the date time picker only sends DTN_DATETIMECHANGE when a date is selected by the user, but it should be sent when the checkbox is changed too. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=19756 Signed-off-by: Damjan Jovanovic <damjan.jov(a)gmail.com> --- dlls/comctl32/datetime.c | 1 + 1 file changed, 1 insertion(+)

2 1

[PATCH] dwrite: Fix misplaced parentheses.
by Andrey Gusev 23 Apr '21

23 Apr '21

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- dlls/dwrite/opentype.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/dwrite/opentype.c b/dlls/dwrite/opentype.c index 717550acf38..9830937231d 100644 --- a/dlls/dwrite/opentype.c +++ b/dlls/dwrite/opentype.c @@ -2101,7 +2101,7 @@ void opentype_get_font_properties(struct file_stream_desc *stream_desc, struct d props->lf.lfWeight = props->weight; /* FONT_IS_SYMBOL */ - if (!(is_symbol = props->panose.familyKind == DWRITE_PANOSE_FAMILY_SYMBOL)) + if (!(is_symbol = props->panose.familyKind) == DWRITE_PANOSE_FAMILY_SYMBOL) { struct dwrite_fonttable cmap; int i, offset, num_tables; @@ -2133,7 +2133,7 @@ void opentype_get_font_properties(struct file_stream_desc *stream_desc, struct d props->flags |= FONT_IS_SYMBOL; /* FONT_IS_MONOSPACED */ - if (!(is_monospaced = props->panose.text.proportion == DWRITE_PANOSE_PROPORTION_MONOSPACED)) + if (!(is_monospaced = props->panose.text.proportion) == DWRITE_PANOSE_PROPORTION_MONOSPACED) { struct dwrite_fonttable post; @@ -4634,7 +4634,7 @@ static void opentype_layout_collect_lookups(struct scriptshaping_context *contex feature_index = GET_BE_WORD(langsys->feature_index[j]); if (feature_index >= total_feature_count) continue; - if ((found = feature_list->features[feature_index].tag == feature->tag)) + if ((found = feature_list->features[feature_index].tag) == feature->tag) { feature->index = feature_index; break; -- 2.30.2

4 7

[PATCH 1/6] user32: Add nulldrv dummy english keyboard layout.
by Rémi Bernon 23 Apr '21

23 Apr '21

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- This supersedes 203899-203901 in a sense that they will conflict with the patches. The previous series was anyway not doing much and I intend to resend the surface patches later, making all user32 tests pass with null driver progressively. As a starting point, this series makes all the user32 input tests pass with null graphics driver. dlls/user32/driver.c | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/dlls/user32/driver.c b/dlls/user32/driver.c index 7ac77141696..8060baa5df1 100644 --- a/dlls/user32/driver.c +++ b/dlls/user32/driver.c @@ -35,6 +35,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(user); WINE_DECLARE_DEBUG_CHANNEL(winediag); +WINE_DECLARE_DEBUG_CHANNEL(keyboard); static USER_DRIVER null_driver, lazy_load_driver; @@ -187,9 +188,12 @@ void USER_unload_driver(void) * These are fallbacks for entry points that are not implemented in the real driver. */ +static HKL nulldrv_keyboard_layout = (HKL)MAKELONG(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT)); + static HKL CDECL nulldrv_ActivateKeyboardLayout( HKL layout, UINT flags ) { - return 0; + TRACE_(keyboard)( "layout %p, flags %x.\n", layout, flags ); + return nulldrv_keyboard_layout; } static void CDECL nulldrv_Beep(void) @@ -260,17 +264,24 @@ static INT CDECL nulldrv_GetKeyNameText( LONG lparam, LPWSTR buffer, INT size ) static HKL CDECL nulldrv_GetKeyboardLayout( DWORD thread_id ) { - return 0; + TRACE_(keyboard)( "thread_id %u.\n", thread_id ); + return nulldrv_keyboard_layout; } static BOOL CDECL nulldrv_GetKeyboardLayoutName( LPWSTR name ) { - return FALSE; + DWORD layout; + TRACE_(keyboard)( "name %p.\n", name ); + layout = HandleToUlong( nulldrv_keyboard_layout ); + if (HIWORD(layout) == LOWORD(layout)) layout = LOWORD(layout); + swprintf( name, KL_NAMELENGTH, L"%08x", layout ); + return TRUE; } static HKL CDECL nulldrv_LoadKeyboardLayout( LPCWSTR name, UINT flags ) { - return 0; + TRACE_(keyboard)( "name %s, flags %x.\n", debugstr_w(name), flags ); + return nulldrv_keyboard_layout; } static UINT CDECL nulldrv_MapVirtualKeyEx( UINT code, UINT type, HKL layout ) -- 2.31.0

3 12

[PATCH] iphlpapi: Fix misplaced parentheses.
by Andrey Gusev 23 Apr '21

23 Apr '21

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- dlls/iphlpapi/ipstats.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/dlls/iphlpapi/ipstats.c b/dlls/iphlpapi/ipstats.c index a15a0abad22..3cf0e811437 100644 --- a/dlls/iphlpapi/ipstats.c +++ b/dlls/iphlpapi/ipstats.c @@ -2620,10 +2620,10 @@ static int compare_tcp6_basic_rows(const void *a, const void *b) const MIB_TCP6ROW *rowB = b; int ret; - if ((ret = memcmp(&rowA->LocalAddr, &rowB->LocalAddr, sizeof(rowA->LocalAddr)) != 0)) return ret; + if ((ret = memcmp(&rowA->LocalAddr, &rowB->LocalAddr, sizeof(rowA->LocalAddr))) != 0) return ret; if ((ret = rowA->dwLocalScopeId - rowB->dwLocalScopeId) != 0) return ret; if ((ret = rowA->dwLocalPort - rowB->dwLocalPort) != 0) return ret; - if ((ret = memcmp(&rowA->RemoteAddr, &rowB->RemoteAddr, sizeof(rowA->RemoteAddr)) != 0)) return ret; + if ((ret = memcmp(&rowA->RemoteAddr, &rowB->RemoteAddr, sizeof(rowA->RemoteAddr))) != 0) return ret; if ((ret = rowA->dwRemoteScopeId - rowB->dwRemoteScopeId) != 0) return ret; return rowA->dwRemotePort - rowB->dwRemotePort; } @@ -2634,10 +2634,10 @@ static int compare_tcp6_owner_rows(const void *a, const void *b) const MIB_TCP6ROW_OWNER_PID *rowB = b; int ret; - if ((ret = memcmp(&rowA->ucLocalAddr, &rowB->ucLocalAddr, sizeof(rowA->ucLocalAddr)) != 0)) return ret; + if ((ret = memcmp(&rowA->ucLocalAddr, &rowB->ucLocalAddr, sizeof(rowA->ucLocalAddr))) != 0) return ret; if ((ret = rowA->dwLocalScopeId - rowB->dwLocalScopeId) != 0) return ret; if ((ret = rowA->dwLocalPort - rowB->dwLocalPort) != 0) return ret; - if ((ret = memcmp(&rowA->ucRemoteAddr, &rowB->ucRemoteAddr, sizeof(rowA->ucRemoteAddr)) != 0)) return ret; + if ((ret = memcmp(&rowA->ucRemoteAddr, &rowB->ucRemoteAddr, sizeof(rowA->ucRemoteAddr))) != 0) return ret; if ((ret = rowA->dwRemoteScopeId - rowB->dwRemoteScopeId) != 0) return ret; return rowA->dwRemotePort - rowB->dwRemotePort; } @@ -2679,7 +2679,7 @@ static int compare_udp6_rows(const void *a, const void *b) const MIB_UDP6ROW *rowB = b; int ret; - if ((ret = memcmp(&rowA->dwLocalAddr, &rowB->dwLocalAddr, sizeof(rowA->dwLocalAddr)) != 0)) return ret; + if ((ret = memcmp(&rowA->dwLocalAddr, &rowB->dwLocalAddr, sizeof(rowA->dwLocalAddr))) != 0) return ret; if ((ret = rowA->dwLocalScopeId - rowB->dwLocalScopeId) != 0) return ret; return rowA->dwLocalPort - rowB->dwLocalPort; } -- 2.30.2

1 0

[PATCH v2] gdi32: fix PatBlt() drawing with negative width/height
by Damjan Jovanovic 23 Apr '21

23 Apr '21

In a (x, y, w, h) rectangle passed to PatBlt(), a negative w results in the rectangle drawn being (x+w, y, -w, h), and negative h results in (x, y+h, w, -h). Wine instead does (x+w+1, y, -w, h) and (x, y+h+1, w, -h), so the rectangle drawn is misplaced: Windows (0,0) +------+ |+-----++ || || ++-----+| +------+ Wine This patch recalculates the rectangle dimensions correctly. Try 2 tests brush patterns and multiple DIB/DDB formats. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=27584 Signed-off-by: Damjan Jovanovic <damjan.jov(a)gmail.com> --- dlls/gdi32/bitblt.c | 11 ++++++ dlls/gdi32/tests/dib.c | 86 ++++++++++++++++++++++++------------------ 2 files changed, 61 insertions(+), 36 deletions(-)

1 0

[tools] winetest/gather: Show skipped dlls on the index pages.
by Francois Gouget 23 Apr '21

23 Apr '21

Sucessful tests are omitted from the index pages except if they skipped some checks. So it makes sense to also show test units that were skipped entirely. Note also that their label (skipped instead of 0) makes it possible to distinguish the two cases. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- winetest/gather | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/winetest/gather b/winetest/gather index 2a23f0a59..fa5525b88 100755 --- a/winetest/gather +++ b/winetest/gather @@ -505,7 +505,7 @@ foreach my $group (@groups) { merge_status( $test_results{$testname}->{$group->{name}}, $report->{$testname} ); } $group->{$testname} = $group_result; - if ($group_result->{status} =~ /^(?:missing(?:dll|sxs)|skipped|stub)$/ or + if ($group_result->{status} =~ /^(?:missing(?:dll|sxs)|stub)$/ or ($group_result->{status} eq "run" and $group_result->{errors}->[1] == 0 and $group_result->{todos}->[1] == 0 and -- 2.20.1

1 0

[PATCH] po: Update German translation.
by Julian Rüger 23 Apr '21

23 Apr '21

Signed-off-by: Julian Rüger <jr98(a)gmx.net>

1 0

[PATCH v4] msxml3: Don't unlink the XML declaration when saving document.
by Dmitry Timoshkov 23 Apr '21

23 Apr '21

v3: Treat standalone == -1 and standalone == -2 same way when saving XML. v4: XML loading code always creates its own XML declaration, so always specify XML_SAVE_NO_DECL when asking libxml2 to generate XML. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/domdoc.c | 11 ++------ dlls/msxml3/tests/domdoc.c | 53 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 53 insertions(+), 11 deletions(-) diff --git a/dlls/msxml3/domdoc.c b/dlls/msxml3/domdoc.c index 80c32e9ba99..cf4f0433218 100644 --- a/dlls/msxml3/domdoc.c +++ b/dlls/msxml3/domdoc.c @@ -2534,7 +2534,6 @@ static HRESULT WINAPI domdoc_save( { domdoc *This = impl_from_IXMLDOMDocument3( iface ); xmlSaveCtxtPtr ctx = NULL; - xmlNodePtr xmldecl; HRESULT ret = S_OK; TRACE("(%p)->(%s)\n", This, debugstr_variant(&destination)); @@ -2567,9 +2566,8 @@ static HRESULT WINAPI domdoc_save( ret = IUnknown_QueryInterface(pUnk, &IID_IStream, (void**)&stream); if(ret == S_OK) { - int options = get_doc(This)->standalone == -1 ? XML_SAVE_NO_DECL : 0; ctx = xmlSaveToIO(domdoc_stream_save_writecallback, - domdoc_stream_save_closecallback, stream, NULL, options); + domdoc_stream_save_closecallback, stream, NULL, XML_SAVE_NO_DECL); if(!ctx) { @@ -2583,8 +2581,6 @@ static HRESULT WINAPI domdoc_save( case VT_BSTR: case VT_BSTR | VT_BYREF: { - int options = get_doc(This)->standalone == -1 ? XML_SAVE_NO_DECL : 0; - /* save with file path */ HANDLE handle = CreateFileW( (V_VT(&destination) & VT_BYREF)? *V_BSTRREF(&destination) : V_BSTR(&destination), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); @@ -2594,9 +2590,8 @@ static HRESULT WINAPI domdoc_save( return E_FAIL; } - /* disable top XML declaration */ ctx = xmlSaveToIO(domdoc_save_writecallback, domdoc_save_closecallback, - handle, NULL, options); + handle, NULL, XML_SAVE_NO_DECL); if (!ctx) { CloseHandle(handle); @@ -2610,9 +2605,7 @@ static HRESULT WINAPI domdoc_save( return S_FALSE; } - xmldecl = xmldoc_unlink_xmldecl(get_doc(This)); if (xmlSaveDoc(ctx, get_doc(This)) == -1) ret = S_FALSE; - xmldoc_link_xmldecl(get_doc(This), xmldecl); /* will release resources through close callback */ xmlSaveClose(ctx); diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 5bc2fe1d5c3..6f8e2b44ed3 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -8524,6 +8524,9 @@ static void test_createProcessingInstruction(void) { static const WCHAR xml1[] = L"<?xml version=\"1.0\"?>\r\n<test/>\r\n"; static const char xml2[] = "<?xml version=\"1.0\" encoding=\"windows-1252\"?>\r\n<test/>\r\n"; + static const char xml2_wine[] = "<?xml version=\"1.0\" encoding=\"windows-1252\"?>\n<test/>\n"; + static const char xml3[] = "<?xml version=\"1.0\" standalone=\"yes\"?>\r\n<test/>\r\n"; + static const char xml3_wine[] = "<?xml version=\"1.0\" standalone=\"yes\"?>\n<test/>\n"; IXMLDOMProcessingInstruction *pi; IXMLDOMDocument *doc; IXMLDOMNode *node; @@ -8533,6 +8536,8 @@ static void test_createProcessingInstruction(void) VARIANT var; HRESULT hr; IStream *stream; + LARGE_INTEGER off; + VARIANT_BOOL b; HGLOBAL global; char *p; @@ -8582,11 +8587,55 @@ todo_wine ok(hr == S_OK, "got 0x%08x\n", hr); p = GlobalLock(global); p[GlobalSize(global)] = 0; -todo_wine - ok(!strcmp(p, xml2), "got %s\n", wine_dbgstr_a(p)); + ok(!strcmp(p, xml2) || !strcmp(p, xml2_wine), "got %s\n", wine_dbgstr_a(p)); + GlobalUnlock(global); + + /* Verify the result after load+save */ + off.QuadPart = 0; + hr = IStream_Seek(stream, off, STREAM_SEEK_SET, NULL); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = IXMLDOMDocument_load(doc, var, &b); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(b == VARIANT_TRUE, "got %d\n", b); + + off.QuadPart = 0; + hr = IStream_Seek(stream, off, STREAM_SEEK_SET, NULL); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = IXMLDOMDocument_save(doc, var); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = GetHGlobalFromStream(stream, &global); + ok(hr == S_OK, "got 0x%08x\n", hr); + p = GlobalLock(global); + p[GlobalSize(global)] = 0; + ok(!strcmp(p, xml2) || !strcmp(p, xml2_wine), "got %s\n", wine_dbgstr_a(p)); GlobalUnlock(global); + IStream_Release(stream); + hr = IXMLDOMDocument_loadXML(doc, _bstr_("<?xml version=\"1.0\" standalone=\"yes\"?>\r\n<test/>\r\n"), &b); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(b == VARIANT_TRUE, "got %d\n", b); + + hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); + ok(hr == S_OK, "got 0x%08x\n", hr); + + V_VT(&var) = VT_UNKNOWN; + V_UNKNOWN(&var) = (IUnknown*)stream; + hr = IXMLDOMDocument_save(doc, var); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = GetHGlobalFromStream(stream, &global); + ok(hr == S_OK, "got 0x%08x\n", hr); + + p = GlobalLock(global); + p[GlobalSize(global)] = 0; + ok(!strcmp(p, xml3) || !strcmp(p, xml3_wine), "got %s\n", wine_dbgstr_a(p)); + GlobalUnlock(global); + + IStream_Release(stream); IXMLDOMDocument_Release(doc); } -- 2.31.1

2 2

[PATCH v3 2/2] winex11.drv: Correct a full screen condition.
by Ziqing Hui 23 Apr '21

23 Apr '21

The if condition here came from 47c54c4ae7f235780a55ddf670503db4afc11055, which is to detect full screen window. However, according to tests in previous commit, there is possibility that a window without setting WS_CAPTION is not full screen, for example, main window of Tencent WeChat. And windows like this can also be maximized or restored. So that we can not treat WS_CAPTION as our full screen condition. This fixes maximizing Tencent WeChat by dragging it to screen edge. Signed-off-by: Ziqing Hui <zhui(a)codeweavers.com> --- v2: Change commit message. v3: Fix a typo in title (conditon -> condition). dlls/winex11.drv/event.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

1 0

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 April 2021