wine-devel October 2018

wine-devel@winehq.org

60 participants
608 discussions

[PATCH 1/3 v2] ntdll/tests: Add more I/O blocking and completion tests.
by Jacek Caban 31 Oct '18

31 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- v2: Fixed uninitialized memory access. dlls/ntdll/tests/pipe.c | 319 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 318 insertions(+), 1 deletion(-)

2 2

[PATCH 2/6] webservices: Try to receive the whole message at once.
by Hans Leidekker 31 Oct '18

31 Oct '18

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 36 +++++++++++++++++++++++++++++++++--- 1 file changed, 33 insertions(+), 3 deletions(-) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index 464645b095..91ffe5be00 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -1137,9 +1137,39 @@ done: return hr; } +static void set_blocking( SOCKET socket, BOOL blocking ) +{ + ULONG state = !blocking; + ioctlsocket( socket, FIONBIO, &state ); +} + +static int sock_peek( SOCKET socket ) +{ + int ret; + char byte; + + set_blocking( socket, FALSE ); + ret = recv( socket, &byte, 1, MSG_PEEK ); + set_blocking( socket, TRUE ); + return ret; +} + +static int sock_recv( SOCKET socket, char *buf, int len ) +{ + int count, ret = 0; + for (;;) + { + if ((count = recv( socket, buf + ret, len, 0 )) <= 0) break; + ret += count; + len -= count; + if (sock_peek( socket ) != 1) break; + } + return ret; +} + static HRESULT receive_bytes( struct channel *channel, unsigned char *bytes, int len ) { - int count = recv( channel->u.tcp.socket, (char *)bytes, len, 0 ); + int count = sock_recv( channel->u.tcp.socket, (char *)bytes, len ); if (count < 0) return HRESULT_FROM_WIN32( WSAGetLastError() ); if (count != len) return WS_E_INVALID_FORMAT; return S_OK; @@ -1494,7 +1524,7 @@ static HRESULT receive_message_unsized( struct channel *channel, SOCKET socket ) if ((hr = resize_read_buffer( channel, max_len )) != S_OK) return hr; channel->read_size = 0; - if ((bytes_read = recv( socket, channel->read_buf, max_len, 0 )) < 0) + if ((bytes_read = sock_recv( socket, channel->read_buf, max_len )) < 0) { return HRESULT_FROM_WIN32( WSAGetLastError() ); } @@ -1513,7 +1543,7 @@ static HRESULT receive_message_sized( struct channel *channel, unsigned int size channel->read_size = 0; while (channel->read_size < size) { - if ((bytes_read = recv( channel->u.tcp.socket, channel->read_buf + offset, to_read, 0 )) < 0) + if ((bytes_read = sock_recv( channel->u.tcp.socket, channel->read_buf + offset, to_read )) < 0) { return HRESULT_FROM_WIN32( WSAGetLastError() ); } -- 2.11.0

2 1

[PATCH vkd3d 5/5] tests: Add test for shader input/output components.
by Józef Kucia 31 Oct '18

31 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 260 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 260 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index 47591948ce4d..9832cd8cabda 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -8356,6 +8356,265 @@ static void test_shader_interstage_interface(void) destroy_test_context(&context); } +static void test_shader_input_output_components(void) +{ + D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc; + ID3D12GraphicsCommandList *command_list; + D3D12_INPUT_LAYOUT_DESC input_layout; + D3D12_CPU_DESCRIPTOR_HANDLE rtvs[2]; + ID3D12Resource *uint_render_target; + struct test_context_desc desc; + D3D12_VERTEX_BUFFER_VIEW vbv; + struct test_context context; + ID3D12CommandQueue *queue; + ID3D12Resource *vb; + HRESULT hr; + + static const DWORD vs1_code[] = + { +#if 0 + void main(float4 in_position : POSITION, uint4 in_uint : UINT, + out float4 out_position : SV_POSITION, out uint out_uint : UINT, + out float3 out_float : FLOAT) + { + out_position = in_position; + out_uint = in_uint.y; + out_float = float3(1, 2, 3); + } +#endif + 0x43425844, 0x0521bc60, 0xd39733a4, 0x1522eea3, 0x0c741ea3, 0x00000001, 0x0000018c, 0x00000003, + 0x0000002c, 0x0000007c, 0x000000ec, 0x4e475349, 0x00000048, 0x00000002, 0x00000008, 0x00000038, + 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x00000041, 0x00000000, 0x00000000, + 0x00000001, 0x00000001, 0x0000020f, 0x49534f50, 0x4e4f4954, 0x4e495500, 0xabab0054, 0x4e47534f, + 0x00000068, 0x00000003, 0x00000008, 0x00000050, 0x00000000, 0x00000001, 0x00000003, 0x00000000, + 0x0000000f, 0x0000005c, 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000e01, 0x00000061, + 0x00000000, 0x00000000, 0x00000003, 0x00000002, 0x00000807, 0x505f5653, 0x5449534f, 0x004e4f49, + 0x544e4955, 0x4f4c4600, 0xab005441, 0x58454853, 0x00000098, 0x00010050, 0x00000026, 0x0100086a, + 0x0300005f, 0x001010f2, 0x00000000, 0x0300005f, 0x00101022, 0x00000001, 0x04000067, 0x001020f2, + 0x00000000, 0x00000001, 0x03000065, 0x00102012, 0x00000001, 0x03000065, 0x00102072, 0x00000002, + 0x05000036, 0x001020f2, 0x00000000, 0x00101e46, 0x00000000, 0x05000036, 0x00102012, 0x00000001, + 0x0010101a, 0x00000001, 0x08000036, 0x00102072, 0x00000002, 0x00004002, 0x3f800000, 0x40000000, + 0x40400000, 0x00000000, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE vs1 = {vs1_code, sizeof(vs1_code)}; + static const DWORD ps1_code[] = + { +#if 0 + void main(float4 position : SV_POSITION, uint in_uint : UINT, + float3 in_float : FLOAT, out float4 out_float : SV_TARGET0, + out uint4 out_uint : SV_TARGET1) + { + out_float.x = position.w; + out_float.y = in_uint; + out_float.z = in_float.z; + out_float.w = 0; + out_uint.x = 0xdeadbeef; + out_uint.y = 0; + out_uint.z = in_uint; + out_uint.w = in_float.z; + } +#endif + 0x43425844, 0x762dbf5e, 0x2cc83972, 0x60c7aa48, 0xbca6118a, 0x00000001, 0x000001d4, 0x00000003, + 0x0000002c, 0x0000009c, 0x000000e8, 0x4e475349, 0x00000068, 0x00000003, 0x00000008, 0x00000050, + 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000080f, 0x0000005c, 0x00000000, 0x00000000, + 0x00000001, 0x00000001, 0x00000101, 0x00000061, 0x00000000, 0x00000000, 0x00000003, 0x00000002, + 0x00000407, 0x505f5653, 0x5449534f, 0x004e4f49, 0x544e4955, 0x4f4c4600, 0xab005441, 0x4e47534f, + 0x00000044, 0x00000002, 0x00000008, 0x00000038, 0x00000000, 0x00000000, 0x00000003, 0x00000000, + 0x0000000f, 0x00000038, 0x00000001, 0x00000000, 0x00000001, 0x00000001, 0x0000000f, 0x545f5653, + 0x45475241, 0xabab0054, 0x52444853, 0x000000e4, 0x00000040, 0x00000039, 0x04002064, 0x00101082, + 0x00000000, 0x00000001, 0x03000862, 0x00101012, 0x00000001, 0x03001062, 0x00101042, 0x00000002, + 0x03000065, 0x001020f2, 0x00000000, 0x03000065, 0x001020f2, 0x00000001, 0x05000056, 0x00102022, + 0x00000000, 0x0010100a, 0x00000001, 0x05000036, 0x00102012, 0x00000000, 0x0010103a, 0x00000000, + 0x05000036, 0x00102042, 0x00000000, 0x0010102a, 0x00000002, 0x05000036, 0x00102082, 0x00000000, + 0x00004001, 0x00000000, 0x0500001c, 0x00102082, 0x00000001, 0x0010102a, 0x00000002, 0x08000036, + 0x00102032, 0x00000001, 0x00004002, 0xdeadbeef, 0x00000000, 0x00000000, 0x00000000, 0x05000036, + 0x00102042, 0x00000001, 0x0010100a, 0x00000001, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps1 = {ps1_code, sizeof(ps1_code)}; + static const DWORD vs2_code[] = + { +#if 0 + void main(float4 in_position : POSITION, + float4 in_texcoord0 : TEXCOORD0, float4 in_texcoord1 : TEXCOORD1, + float4 in_texcoord2 : TEXCOORD2, + out float4 position : Sv_Position, + out float2 texcoord0 : TEXCOORD0, out float2 texcoord1 : TEXCOORD1, + out float4 texcoord2 : TEXCOORD2, out float3 texcoord3 : TEXCOORD3) + { + position = in_position; + texcoord0 = in_texcoord0.yx; + texcoord1 = in_texcoord0.wz; + texcoord2 = in_texcoord1; + texcoord3 = in_texcoord2.yzx; + } +#endif + 0x43425844, 0x6721613b, 0xb997c7e4, 0x8bc3df4d, 0x813c93b9, 0x00000001, 0x00000224, 0x00000003, + 0x0000002c, 0x000000b0, 0x00000150, 0x4e475349, 0x0000007c, 0x00000004, 0x00000008, 0x00000068, + 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x00000071, 0x00000000, 0x00000000, + 0x00000003, 0x00000001, 0x00000f0f, 0x00000071, 0x00000001, 0x00000000, 0x00000003, 0x00000002, + 0x00000f0f, 0x00000071, 0x00000002, 0x00000000, 0x00000003, 0x00000003, 0x0000070f, 0x49534f50, + 0x4e4f4954, 0x58455400, 0x524f4f43, 0xabab0044, 0x4e47534f, 0x00000098, 0x00000005, 0x00000008, + 0x00000080, 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000000f, 0x0000008c, 0x00000000, + 0x00000000, 0x00000003, 0x00000001, 0x00000c03, 0x0000008c, 0x00000001, 0x00000000, 0x00000003, + 0x00000001, 0x0000030c, 0x0000008c, 0x00000002, 0x00000000, 0x00000003, 0x00000002, 0x0000000f, + 0x0000008c, 0x00000003, 0x00000000, 0x00000003, 0x00000003, 0x00000807, 0x505f7653, 0x7469736f, + 0x006e6f69, 0x43584554, 0x44524f4f, 0xababab00, 0x52444853, 0x000000cc, 0x00010040, 0x00000033, + 0x0300005f, 0x001010f2, 0x00000000, 0x0300005f, 0x001010f2, 0x00000001, 0x0300005f, 0x001010f2, + 0x00000002, 0x0300005f, 0x00101072, 0x00000003, 0x04000067, 0x001020f2, 0x00000000, 0x00000001, + 0x03000065, 0x00102032, 0x00000001, 0x03000065, 0x001020c2, 0x00000001, 0x03000065, 0x001020f2, + 0x00000002, 0x03000065, 0x00102072, 0x00000003, 0x05000036, 0x001020f2, 0x00000000, 0x00101e46, + 0x00000000, 0x05000036, 0x001020f2, 0x00000001, 0x00101b16, 0x00000001, 0x05000036, 0x001020f2, + 0x00000002, 0x00101e46, 0x00000002, 0x05000036, 0x00102072, 0x00000003, 0x00101496, 0x00000003, + 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE vs2 = {vs2_code, sizeof(vs2_code)}; + static const DWORD ps2_code[] = + { +#if 0 + void main(float4 position : Sv_Position, + float2 texcoord0 : TEXCOORD0, float2 texcoord1 : TEXCOORD1, + float4 texcoord2 : TEXCOORD2, float3 texcoord3 : TEXCOORD3, + out float4 target0 : Sv_Target0, out uint4 target1 : SV_Target1) + { + target0.x = texcoord0.x + texcoord0.y; + target0.y = texcoord1.x; + target0.z = texcoord3.z; + target0.w = texcoord1.y; + + target1.x = texcoord2.x; + target1.y = texcoord2.y; + target1.w = texcoord2.w; + target1.z = 0; + } +#endif + 0x43425844, 0xa6c0df60, 0x5bf34683, 0xa0093595, 0x98cca724, 0x00000001, 0x000001e8, 0x00000003, + 0x0000002c, 0x000000cc, 0x00000120, 0x4e475349, 0x00000098, 0x00000005, 0x00000008, 0x00000080, + 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000000f, 0x0000008c, 0x00000000, 0x00000000, + 0x00000003, 0x00000001, 0x00000303, 0x0000008c, 0x00000001, 0x00000000, 0x00000003, 0x00000001, + 0x00000c0c, 0x0000008c, 0x00000002, 0x00000000, 0x00000003, 0x00000002, 0x00000b0f, 0x0000008c, + 0x00000003, 0x00000000, 0x00000003, 0x00000003, 0x00000407, 0x505f7653, 0x7469736f, 0x006e6f69, + 0x43584554, 0x44524f4f, 0xababab00, 0x4e47534f, 0x0000004c, 0x00000002, 0x00000008, 0x00000038, + 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x0000000f, 0x00000042, 0x00000001, 0x00000000, + 0x00000001, 0x00000001, 0x0000000f, 0x545f7653, 0x65677261, 0x56530074, 0x7261545f, 0x00746567, + 0x52444853, 0x000000c0, 0x00000040, 0x00000030, 0x03001062, 0x00101032, 0x00000001, 0x03001062, + 0x001010c2, 0x00000001, 0x03001062, 0x001010b2, 0x00000002, 0x03001062, 0x00101042, 0x00000003, + 0x03000065, 0x001020f2, 0x00000000, 0x03000065, 0x001020f2, 0x00000001, 0x07000000, 0x00102012, + 0x00000000, 0x0010101a, 0x00000001, 0x0010100a, 0x00000001, 0x05000036, 0x001020a2, 0x00000000, + 0x00101ea6, 0x00000001, 0x05000036, 0x00102042, 0x00000000, 0x0010102a, 0x00000003, 0x0500001c, + 0x001020b2, 0x00000001, 0x00101c46, 0x00000002, 0x05000036, 0x00102042, 0x00000001, 0x00004001, + 0x00000000, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps2 = {ps2_code, sizeof(ps2_code)}; + static const D3D12_INPUT_ELEMENT_DESC layout_desc[] = + { + {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, + {"UINT", 0, DXGI_FORMAT_R32G32B32A32_UINT, 0, 16, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, + {"TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 32, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, + {"TEXCOORD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 48, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, + {"TEXCOORD", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 64, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, + }; + static const struct + { + struct vec4 position; + struct uvec4 u; + struct vec4 t0; + struct vec4 t1; + struct vec4 t2; + } + quad[] = + { + {{-1.0f, -1.0f}, {1, 2, 3, 4}, {3.0f, 3.0f, 8.0f, 4.0f}, {9.0f, 5.0f, 3.0f, 1.0f}, {7.0f, 2.0f}}, + {{-1.0f, 1.0f}, {1, 2, 3, 4}, {3.0f, 3.0f, 8.0f, 4.0f}, {9.0f, 5.0f, 3.0f, 1.0f}, {7.0f, 2.0f}}, + {{ 1.0f, -1.0f}, {1, 2, 3, 4}, {3.0f, 3.0f, 8.0f, 4.0f}, {9.0f, 5.0f, 3.0f, 1.0f}, {7.0f, 2.0f}}, + {{ 1.0f, 1.0f}, {1, 2, 3, 4}, {3.0f, 3.0f, 8.0f, 4.0f}, {9.0f, 5.0f, 3.0f, 1.0f}, {7.0f, 2.0f}}, + }; + static const struct vec4 expected_vec4[] = {{1.0f, 2.0f, 3.0f, 0.0f}, {6.0f, 4.0f, 7.0f, 8.0f}}; + static const struct uvec4 expected_uvec4[] = {{0xdeadbeef, 0, 2, 3}, {9, 5, 0, 1}}; + + memset(&desc, 0, sizeof(desc)); + desc.rt_format = DXGI_FORMAT_R32G32B32A32_FLOAT; + desc.rt_descriptor_count = 2; + desc.no_root_signature = true; + if (!init_test_context(&context, &desc)) + return; + command_list = context.list; + queue = context.queue; + + context.root_signature = create_empty_root_signature(context.device, + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT); + + input_layout.pInputElementDescs = layout_desc; + input_layout.NumElements = ARRAY_SIZE(layout_desc); + init_pipeline_state_desc(&pso_desc, context.root_signature, desc.rt_format, &vs1, &ps1, &input_layout); + pso_desc.NumRenderTargets = 2; + pso_desc.RTVFormats[1] = DXGI_FORMAT_R32G32B32A32_UINT; + hr = ID3D12Device_CreateGraphicsPipelineState(context.device, &pso_desc, + &IID_ID3D12PipelineState, (void **)&context.pipeline_state); + ok(hr == S_OK, "Failed to create graphics pipeline state, hr %#x.\n", hr); + + rtvs[0] = context.rtv; + rtvs[1] = get_cpu_rtv_handle(&context, context.rtv_heap, 1); + desc.rt_format = pso_desc.RTVFormats[1]; + create_render_target(&context, &desc, &uint_render_target, &rtvs[1]); + + vb = create_upload_buffer(context.device, sizeof(quad), quad); + + vbv.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(vb); + vbv.StrideInBytes = sizeof(*quad); + vbv.SizeInBytes = sizeof(quad); + + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 2, &context.rtv, TRUE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + ID3D12GraphicsCommandList_IASetVertexBuffers(command_list, 0, 1, &vbv); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 4, 1, 0, 0); + + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + check_sub_resource_vec4(context.render_target, 0, queue, command_list, &expected_vec4[0], 0); + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, uint_render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + check_sub_resource_uvec4(uint_render_target, 0, queue, command_list, &expected_uvec4[0]); + + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET); + transition_resource_state(command_list, uint_render_target, + D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET); + + ID3D12PipelineState_Release(context.pipeline_state); + pso_desc.VS = vs2; + pso_desc.PS = ps2; + hr = ID3D12Device_CreateGraphicsPipelineState(context.device, &pso_desc, + &IID_ID3D12PipelineState, (void **)&context.pipeline_state); + ok(hr == S_OK, "Failed to create graphics pipeline state, hr %#x.\n", hr); + + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 2, &context.rtv, TRUE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + ID3D12GraphicsCommandList_IASetVertexBuffers(command_list, 0, 1, &vbv); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 4, 1, 0, 0); + + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + check_sub_resource_vec4(context.render_target, 0, queue, command_list, &expected_vec4[1], 0); + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, uint_render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + check_sub_resource_uvec4(uint_render_target, 0, queue, command_list, &expected_uvec4[1]); + + ID3D12Resource_Release(vb); + ID3D12Resource_Release(uint_render_target); + destroy_test_context(&context); +} + static void test_incompletely_initialized_shader_outputs(void) { static const float white[] = {1.0f, 1.0f, 1.0f, 1.0f}; @@ -20914,6 +21173,7 @@ START_TEST(d3d12) run_test(test_compute_shader_instructions); run_test(test_discard_instruction); run_test(test_shader_interstage_interface); + run_test(test_shader_input_output_components); run_test(test_incompletely_initialized_shader_outputs); run_test(test_root_signature_byte_code); run_test(test_cs_constant_buffer); -- 2.18.1

1 0

[PATCH 3/3] server: Use file mode flags in async_handoff to decide if request is blocking.
by Jacek Caban 31 Oct '18

31 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/ntdll/tests/pipe.c | 20 +++++++------------- server/async.c | 4 ++-- server/fd.c | 8 ++++---- server/file.h | 2 +- 4 files changed, 14 insertions(+), 20 deletions(-)

1 0

[PATCH 2/3] server: Introduce is_fd_synchronous helper.
by Jacek Caban 31 Oct '18

31 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- server/fd.c | 10 ++++++++-- server/file.c | 7 +------ server/file.h | 1 + 3 files changed, 10 insertions(+), 8 deletions(-)

1 0

[PATCH 6/6] webservices: Implement WsRequestReply.
by Hans Leidekker 31 Oct '18

31 Oct '18

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 115 +++++++++++++++++++++ dlls/webservices/tests/channel.c | 205 ++++++++++++++++++++++++++------------ dlls/webservices/webservices.spec | 2 +- include/webservices.h | 3 + 4 files changed, 262 insertions(+), 63 deletions(-) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index de84b0e66f..94c3dc1e99 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -2007,6 +2007,121 @@ HRESULT WINAPI WsReceiveMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_M return hr; } +static HRESULT request_reply( struct channel *channel, WS_MESSAGE *request, + const WS_MESSAGE_DESCRIPTION *request_desc, WS_WRITE_OPTION write_option, + const void *request_body, ULONG request_size, WS_MESSAGE *reply, + const WS_MESSAGE_DESCRIPTION *reply_desc, WS_READ_OPTION read_option, + WS_HEAP *heap, void *value, ULONG size ) +{ + HRESULT hr; + WsInitializeMessage( request, WS_REQUEST_MESSAGE, NULL, NULL ); + if ((hr = WsAddressMessage( request, &channel->addr, NULL )) != S_OK) return hr; + if ((hr = message_set_action( request, request_desc->action )) != S_OK) return hr; + + if ((hr = init_writer( channel )) != S_OK) return hr; + if ((hr = write_message( channel, request, request_desc->bodyElementDescription, write_option, request_body, + request_size )) != S_OK) return hr; + if ((hr = send_message( channel, request )) != S_OK) return hr; + + return receive_message( channel, reply, &reply_desc, 1, WS_RECEIVE_OPTIONAL_MESSAGE, read_option, heap, + value, size, NULL ); +} + +struct request_reply +{ + struct task task; + struct channel *channel; + WS_MESSAGE *request; + const WS_MESSAGE_DESCRIPTION *request_desc; + WS_WRITE_OPTION write_option; + const void *request_body; + ULONG request_size; + WS_MESSAGE *reply; + const WS_MESSAGE_DESCRIPTION *reply_desc; + WS_READ_OPTION read_option; + WS_HEAP *heap; + void *value; + ULONG size; + WS_ASYNC_CONTEXT ctx; +}; + +static void request_reply_proc( struct task *task ) +{ + struct request_reply *r = (struct request_reply *)task; + HRESULT hr; + + hr = request_reply( r->channel, r->request, r->request_desc, r->write_option, r->request_body, r->request_size, + r->reply, r->reply_desc, r->read_option, r->heap, r->value, r->size ); + + TRACE( "calling %p(%08x)\n", r->ctx.callback, hr ); + r->ctx.callback( hr, WS_LONG_CALLBACK, r->ctx.callbackState ); + TRACE( "%p returned\n", r->ctx.callback ); +} + +static HRESULT queue_request_reply( struct channel *channel, WS_MESSAGE *request, + const WS_MESSAGE_DESCRIPTION *request_desc, WS_WRITE_OPTION write_option, + const void *request_body, ULONG request_size, WS_MESSAGE *reply, + const WS_MESSAGE_DESCRIPTION *reply_desc, WS_READ_OPTION read_option, + WS_HEAP *heap, void *value, ULONG size, const WS_ASYNC_CONTEXT *ctx ) +{ + struct request_reply *r; + + if (!(r = heap_alloc( sizeof(*r) ))) return E_OUTOFMEMORY; + r->task.proc = request_reply_proc; + r->channel = channel; + r->request = request; + r->request_desc = request_desc; + r->write_option = write_option; + r->request_body = request_body; + r->request_size = request_size; + r->reply = reply; + r->reply_desc = reply_desc; + r->read_option = read_option; + r->heap = heap; + r->value = value; + r->size = size; + r->ctx = *ctx; + return queue_task( &channel->recv_q, &r->task ); +} + +/************************************************************************** + * WsRequestReply [webservices.@] + */ +HRESULT WINAPI WsRequestReply( WS_CHANNEL *handle, WS_MESSAGE *request, const WS_MESSAGE_DESCRIPTION *request_desc, + WS_WRITE_OPTION write_option, const void *request_body, ULONG request_size, + WS_MESSAGE *reply, const WS_MESSAGE_DESCRIPTION *reply_desc, WS_READ_OPTION read_option, + WS_HEAP *heap, void *value, ULONG size, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error ) +{ + struct channel *channel = (struct channel *)handle; + HRESULT hr; + + TRACE( "%p %p %p %08x %p %u %p %p %08x %p %p %u %p %p\n", handle, request, request_desc, write_option, + request_body, request_size, reply, reply_desc, read_option, heap, value, size, ctx, error ); + if (error) FIXME( "ignoring error parameter\n" ); + if (ctx) FIXME( "ignoring ctx parameter\n" ); + + if (!channel || !request || !reply) return E_INVALIDARG; + + EnterCriticalSection( &channel->cs ); + + if (channel->magic != CHANNEL_MAGIC) + { + LeaveCriticalSection( &channel->cs ); + return E_INVALIDARG; + } + + if (ctx) + hr = queue_request_reply( channel, request, request_desc, write_option, request_body, request_size, reply, + reply_desc, read_option, heap, value, size, ctx ); + else + hr = request_reply( channel, request, request_desc, write_option, request_body, request_size, reply, + reply_desc, read_option, heap, value, size ); + + LeaveCriticalSection( &channel->cs ); + TRACE( "returning %08x\n", hr ); + return hr; +} + /************************************************************************** * WsReadMessageStart [webservices.@] */ diff --git a/dlls/webservices/tests/channel.c b/dlls/webservices/tests/channel.c index db17893138..6a45671057 100644 --- a/dlls/webservices/tests/channel.c +++ b/dlls/webservices/tests/channel.c @@ -433,16 +433,21 @@ static void test_WsResetListener(void) WsFreeListener( listener ); } +static const WCHAR fmt_soap_udp[] = + {'s','o','a','p','.','u','d','p',':','/','/','l','o','c','a','l','h','o','s','t',':','%','u',0}; +static const WCHAR fmt_net_tcp[] = + {'n','e','t','.','t','c','p',':','/','/','l','o','c','a','l','h','o','s','t',':','%','u',0}; + struct listener_info { int port; HANDLE wait; WS_CHANNEL_BINDING binding; WS_CHANNEL_TYPE type; - void (*test_func)( WS_CHANNEL * ); + void (*server_func)( WS_CHANNEL * ); }; -static void client_message_read_write( WS_CHANNEL *channel ) +static void server_message_read_write( WS_CHANNEL *channel ) { WS_MESSAGE *msg; HRESULT hr; @@ -476,10 +481,8 @@ static void client_message_read_write( WS_CHANNEL *channel ) WsFreeMessage( msg ); } -static void test_message_read_write( const struct listener_info *info ) +static void client_message_read_write( const struct listener_info *info ) { - static const WCHAR fmt[] = - {'s','o','a','p','.','u','d','p',':','/','/','l','o','c','a','l','h','o','s','t',':','%','u',0}; WS_ENDPOINT_ADDRESS addr; WCHAR buf[64]; WS_CHANNEL *channel; @@ -491,7 +494,7 @@ static void test_message_read_write( const struct listener_info *info ) ok( hr == S_OK, "got %08x\n", hr ); memset( &addr, 0, sizeof(addr) ); - addr.url.length = wsprintfW( buf, fmt, info->port ); + addr.url.length = wsprintfW( buf, fmt_soap_udp, info->port ); addr.url.chars = buf; hr = WsOpenChannel( channel, &addr, NULL, NULL ); ok( hr == S_OK, "got %08x\n", hr ); @@ -545,7 +548,7 @@ struct async_test HANDLE wait; }; -static void CALLBACK callback_duplex_session( HRESULT hr, WS_CALLBACK_MODEL model, void *state ) +static void CALLBACK async_callback( HRESULT hr, WS_CALLBACK_MODEL model, void *state ) { struct async_test *test = state; @@ -555,7 +558,7 @@ static void CALLBACK callback_duplex_session( HRESULT hr, WS_CALLBACK_MODEL mode SetEvent( test->wait ); } -static void client_duplex_session( WS_CHANNEL *channel ) +static void server_duplex_session( WS_CHANNEL *channel ) { WS_XML_STRING action = {6, (BYTE *)"action"}, localname = {9, (BYTE *)"localname"}, ns = {2, (BYTE *)"ns"}; WS_ELEMENT_DESCRIPTION desc_body; @@ -580,7 +583,7 @@ static void client_duplex_session( WS_CHANNEL *channel ) test.call_count = 0; test.wait = CreateEventW( NULL, FALSE, FALSE, NULL ); - ctx.callback = callback_duplex_session; + ctx.callback = async_callback; ctx.callbackState = &test; hr = WsReceiveMessage( channel, msg, desc, 1, WS_RECEIVE_OPTIONAL_MESSAGE, WS_READ_REQUIRED_VALUE, @@ -612,10 +615,8 @@ static void client_duplex_session( WS_CHANNEL *channel ) WsFreeMessage( msg2 ); } -static void test_duplex_session( const struct listener_info *info ) +static void client_duplex_session( const struct listener_info *info ) { - static const WCHAR fmt[] = - {'n','e','t','.','t','c','p',':','/','/','l','o','c','a','l','h','o','s','t',':','%','u',0}; WS_XML_STRING action = {6, (BYTE *)"action"}, localname = {9, (BYTE *)"localname"}, ns = {2, (BYTE *)"ns"}; WS_ELEMENT_DESCRIPTION desc_body; WS_MESSAGE_DESCRIPTION desc; @@ -634,7 +635,7 @@ static void test_duplex_session( const struct listener_info *info ) ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr ); memset( &addr, 0, sizeof(addr) ); - addr.url.length = wsprintfW( buf, fmt, info->port ); + addr.url.length = wsprintfW( buf, fmt_net_tcp, info->port ); addr.url.chars = buf; hr = WsOpenChannel( channel, &addr, NULL, NULL ); ok( hr == S_OK, "got %08x\n", hr ); @@ -675,7 +676,7 @@ static void test_duplex_session( const struct listener_info *info ) WsFreeChannel( channel ); } -static void client_accept_channel( WS_CHANNEL *channel ) +static void server_accept_channel( WS_CHANNEL *channel ) { WS_XML_STRING localname = {9, (BYTE *)"localname"}, ns = {2, (BYTE *)"ns"}, action = {6, (BYTE *)"action"}; WS_ELEMENT_DESCRIPTION body; @@ -704,13 +705,9 @@ static void client_accept_channel( WS_CHANNEL *channel ) WsFreeMessage( msg ); } -static void test_WsAcceptChannel( const struct listener_info *info ) +static void client_accept_channel( const struct listener_info *info ) { - static const WCHAR fmt_tcp[] = - {'n','e','t','.','t','c','p',':','/','/','l','o','c','a','l','h','o','s','t',':','%','u',0}; - static const WCHAR fmt_udp[] = - {'s','o','a','p','.','u','d','p',':','/','/','l','o','c','a','l','h','o','s','t',':','%','u',0}; - const WCHAR *fmt = (info->binding == WS_TCP_CHANNEL_BINDING) ? fmt_tcp : fmt_udp; + const WCHAR *fmt = (info->binding == WS_TCP_CHANNEL_BINDING) ? fmt_net_tcp : fmt_soap_udp; WS_XML_STRING localname = {9, (BYTE *)"localname"}, ns = {2, (BYTE *)"ns"}, action = {6, (BYTE *)"action"}; WCHAR buf[64]; WS_LISTENER *listener; @@ -773,14 +770,104 @@ static void test_WsAcceptChannel( const struct listener_info *info ) WsFreeChannel( channel ); } +static void server_request_reply( WS_CHANNEL *channel ) +{ + WS_XML_STRING localname = {9, (BYTE *)"localname"}, ns = {2, (BYTE *)"ns"}; + WS_XML_STRING req_action = {7, (BYTE *)"request"}, reply_action= {5, (BYTE *)"reply"}; + WS_ELEMENT_DESCRIPTION body; + WS_MESSAGE_DESCRIPTION in_desc, out_desc; + const WS_MESSAGE_DESCRIPTION *desc[1]; + WS_MESSAGE *msg; + INT32 val = 0; + HRESULT hr; + + hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + body.elementLocalName = &localname; + body.elementNs = &ns; + body.type = WS_INT32_TYPE; + body.typeDescription = NULL; + + in_desc.action = &req_action; + in_desc.bodyElementDescription = &body; + desc[0] = &in_desc; + + hr = WsReceiveMessage( channel, msg, desc, 1, WS_RECEIVE_REQUIRED_MESSAGE, WS_READ_REQUIRED_VALUE, + NULL, &val, sizeof(val), NULL, NULL, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + ok( val == -1, "got %d\n", val ); + WsFreeMessage( msg ); + + hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + out_desc.action = &reply_action; + out_desc.bodyElementDescription = &body; + + hr = WsSendMessage( channel, msg, &out_desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + WsFreeMessage( msg ); +} + +static void client_request_reply( const struct listener_info *info ) +{ + WS_XML_STRING localname = {9, (BYTE *)"localname"}, ns = {2, (BYTE *)"ns"}; + WS_XML_STRING req_action = {7, (BYTE *)"request"}, reply_action= {5, (BYTE *)"reply"}; + WCHAR buf[64]; + WS_CHANNEL *channel; + WS_MESSAGE *req, *reply; + WS_ENDPOINT_ADDRESS addr; + WS_ELEMENT_DESCRIPTION body; + WS_MESSAGE_DESCRIPTION req_desc, reply_desc; + INT32 val_in = -1, val_out = 0; + HRESULT hr; + + hr = WsCreateChannel( info->type, info->binding, NULL, 0, NULL, &channel, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + memset( &addr, 0, sizeof(addr) ); + addr.url.length = wsprintfW( buf, fmt_net_tcp, info->port ); + addr.url.chars = buf; + hr = WsOpenChannel( channel, &addr, NULL, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsCreateMessageForChannel( channel, NULL, 0, &req, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsCreateMessageForChannel( channel, NULL, 0, &reply, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsInitializeMessage( req, WS_BLANK_MESSAGE, NULL, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + body.elementLocalName = &localname; + body.elementNs = &ns; + body.type = WS_INT32_TYPE; + body.typeDescription = NULL; + + req_desc.action = &req_action; + req_desc.bodyElementDescription = &body; + + reply_desc.action = &reply_action; + reply_desc.bodyElementDescription = &body; + + hr = WsRequestReply( channel, req, &req_desc, WS_WRITE_REQUIRED_VALUE, &val_in, sizeof(val_in), reply, + &reply_desc, WS_READ_REQUIRED_VALUE, NULL, &val_out, sizeof(val_out), NULL, NULL ); + ok( val_out == -1, "got %d\n", val_out ); + + hr = WsCloseChannel( channel, NULL, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + WsFreeMessage( req ); + WsFreeMessage( reply ); + WsFreeChannel( channel ); +} + static DWORD CALLBACK listener_proc( void *arg ) { - static const WCHAR fmt_tcp[] = - {'n','e','t','.','t','c','p',':','/','/','l','o','c','a','l','h','o','s','t',':','%','u',0}; - static const WCHAR fmt_udp[] = - {'s','o','a','p','.','u','d','p',':','/','/','l','o','c','a','l','h','o','s','t',':','%','u',0}; struct listener_info *info = arg; - const WCHAR *fmt = (info->binding == WS_TCP_CHANNEL_BINDING) ? fmt_tcp : fmt_udp; + const WCHAR *fmt = (info->binding == WS_TCP_CHANNEL_BINDING) ? fmt_net_tcp : fmt_soap_udp; WS_LISTENER *listener; WS_CHANNEL *channel; WCHAR buf[64]; @@ -803,7 +890,7 @@ static DWORD CALLBACK listener_proc( void *arg ) hr = WsAcceptChannel( listener, channel, NULL, NULL ); ok( hr == S_OK, "got %08x\n", hr ); - info->test_func( channel ); + info->server_func( channel ); SetEvent( info->wait ); @@ -956,6 +1043,22 @@ START_TEST(channel) struct listener_info info; HANDLE thread; HRESULT hr; + unsigned int i; + static const struct test + { + WS_CHANNEL_BINDING binding; + WS_CHANNEL_TYPE type; + void (*server_func)( WS_CHANNEL * ); + void (*client_func)( const struct listener_info * ); + } + tests[] = + { + { WS_UDP_CHANNEL_BINDING, WS_CHANNEL_TYPE_DUPLEX, server_message_read_write, client_message_read_write }, + { WS_TCP_CHANNEL_BINDING, WS_CHANNEL_TYPE_DUPLEX_SESSION, server_duplex_session, client_duplex_session }, + { WS_UDP_CHANNEL_BINDING, WS_CHANNEL_TYPE_DUPLEX, server_accept_channel, client_accept_channel }, + { WS_TCP_CHANNEL_BINDING, WS_CHANNEL_TYPE_DUPLEX_SESSION, server_accept_channel, client_accept_channel }, + { WS_TCP_CHANNEL_BINDING, WS_CHANNEL_TYPE_DUPLEX_SESSION, server_request_reply, client_request_reply }, + }; if (firewall_enabled) { @@ -979,42 +1082,20 @@ START_TEST(channel) test_WsCreateChannelForListener(); test_WsResetListener(); - info.port = 7533; - info.wait = CreateEventW( NULL, 0, 0, NULL ); - info.type = WS_CHANNEL_TYPE_DUPLEX; - info.binding = WS_UDP_CHANNEL_BINDING; - info.test_func = client_message_read_write; - - thread = start_listener( &info ); - test_message_read_write( &info ); - WaitForSingleObject( thread, 3000 ); - CloseHandle(thread); - - info.type = WS_CHANNEL_TYPE_DUPLEX_SESSION; - info.binding = WS_TCP_CHANNEL_BINDING; - info.test_func = client_duplex_session; - - thread = start_listener( &info ); - test_duplex_session( &info ); - WaitForSingleObject( thread, 3000 ); - CloseHandle(thread); - - info.type = WS_CHANNEL_TYPE_DUPLEX; - info.binding = WS_UDP_CHANNEL_BINDING; - info.test_func = client_accept_channel; - - thread = start_listener( &info ); - test_WsAcceptChannel( &info ); - WaitForSingleObject( thread, 3000 ); - CloseHandle(thread); - - info.type = WS_CHANNEL_TYPE_DUPLEX_SESSION; - info.binding = WS_TCP_CHANNEL_BINDING; - - thread = start_listener( &info ); - test_WsAcceptChannel( &info ); - WaitForSingleObject( thread, 3000 ); - CloseHandle(thread); + info.port = 7533; + info.wait = CreateEventW( NULL, 0, 0, NULL ); + + for (i = 0; i < ARRAY_SIZE(tests); i++) + { + info.binding = tests[i].binding; + info.type = tests[i].type; + info.server_func = tests[i].server_func; + + thread = start_listener( &info ); + tests[i].client_func( &info ); + WaitForSingleObject( thread, 3000 ); + CloseHandle( thread ); + } if (firewall_enabled) set_firewall( APP_REMOVE ); } diff --git a/dlls/webservices/webservices.spec b/dlls/webservices/webservices.spec index 8ba34b4209..30c97e3473 100644 --- a/dlls/webservices/webservices.spec +++ b/dlls/webservices/webservices.spec @@ -131,7 +131,7 @@ @ stdcall WsRemoveHeader(ptr long ptr) @ stdcall WsRemoveMappedHeader(ptr ptr ptr) @ stub WsRemoveNode -@ stub WsRequestReply +@ stdcall WsRequestReply(ptr ptr ptr long ptr long ptr ptr long ptr ptr long ptr ptr) @ stub WsRequestSecurityToken @ stdcall WsResetChannel(ptr ptr) @ stdcall WsResetError(ptr) diff --git a/include/webservices.h b/include/webservices.h index 928819fc3d..6cafcc63d6 100644 --- a/include/webservices.h +++ b/include/webservices.h @@ -1701,6 +1701,9 @@ HRESULT WINAPI WsRemoveCustomHeader(WS_MESSAGE*, const WS_XML_STRING*, const WS_ HRESULT WINAPI WsRemoveHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_ERROR*); HRESULT WINAPI WsRemoveMappedHeader(WS_MESSAGE*, const WS_XML_STRING*, WS_ERROR*); HRESULT WINAPI WsRemoveNode(const WS_XML_NODE_POSITION*, WS_ERROR*); +HRESULT WINAPI WsRequestReply(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION, + const void*, ULONG, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_READ_OPTION, + WS_HEAP*, void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*); HRESULT WINAPI WsResetChannel(WS_CHANNEL*, WS_ERROR*); HRESULT WINAPI WsResetMessage(WS_MESSAGE*, WS_ERROR*); HRESULT WINAPI WsResetError(WS_ERROR*); -- 2.11.0

1 0

[PATCH 5/6] webservices: Add support for UTF-8 encoded text in read_message_id.
by Hans Leidekker 31 Oct '18

31 Oct '18

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/msg.c | 22 +++++++++++++++++----- dlls/webservices/reader.c | 2 +- dlls/webservices/webservices_private.h | 1 + 3 files changed, 19 insertions(+), 6 deletions(-) diff --git a/dlls/webservices/msg.c b/dlls/webservices/msg.c index 4ccf82eacc..a53fd92e2e 100644 --- a/dlls/webservices/msg.c +++ b/dlls/webservices/msg.c @@ -846,21 +846,33 @@ static HRESULT read_message_id( WS_XML_READER *reader, GUID *ret ) { const WS_XML_NODE *node; const WS_XML_TEXT_NODE *text; - const WS_XML_UNIQUE_ID_TEXT *id; HRESULT hr; if ((hr = WsReadNode( reader, NULL )) != S_OK) return hr; if ((hr = WsGetReaderNode( reader, &node, NULL )) != S_OK) return hr; if (node->nodeType != WS_XML_NODE_TYPE_TEXT) return WS_E_INVALID_FORMAT; text = (const WS_XML_TEXT_NODE *)node; - if (text->text->textType != WS_XML_TEXT_TYPE_UNIQUE_ID) + + switch (text->text->textType) + { + case WS_XML_TEXT_TYPE_UTF8: + { + const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text->text; + if (utf8->value.length != 45 || memcmp( utf8->value.bytes, "urn:uuid:", 9 )) + return WS_E_INVALID_FORMAT; + + return str_to_guid( utf8->value.bytes + 9, utf8->value.length - 9, ret ); + } + case WS_XML_TEXT_TYPE_UNIQUE_ID: { + const WS_XML_UNIQUE_ID_TEXT *id = (const WS_XML_UNIQUE_ID_TEXT *)text->text; + *ret = id->value; + return S_OK; + } + default: FIXME( "unhandled text type %u\n", text->text->textType ); return E_NOTIMPL; } - id = (const WS_XML_UNIQUE_ID_TEXT *)text->text; - *ret = id->value; - return S_OK; } static HRESULT read_envelope_start( struct msg *msg, WS_XML_READER *reader ) diff --git a/dlls/webservices/reader.c b/dlls/webservices/reader.c index a5ff59a417..8cf3f24d29 100644 --- a/dlls/webservices/reader.c +++ b/dlls/webservices/reader.c @@ -3841,7 +3841,7 @@ static HRESULT str_to_float( const unsigned char *str, ULONG len, float *ret ) return S_OK; } -static HRESULT str_to_guid( const unsigned char *str, ULONG len, GUID *ret ) +HRESULT str_to_guid( const unsigned char *str, ULONG len, GUID *ret ) { static const unsigned char hex[] = { diff --git a/dlls/webservices/webservices_private.h b/dlls/webservices/webservices_private.h index d981527bb2..b482b5ba20 100644 --- a/dlls/webservices/webservices_private.h +++ b/dlls/webservices/webservices_private.h @@ -71,6 +71,7 @@ HRESULT read_header( WS_XML_READER *, const WS_XML_STRING *, const WS_XML_STRING HRESULT create_header_buffer( WS_XML_READER *, WS_HEAP *, WS_XML_BUFFER ** ) DECLSPEC_HIDDEN; HRESULT text_to_text( const WS_XML_TEXT *, const WS_XML_TEXT *, ULONG *, WS_XML_TEXT ** ) DECLSPEC_HIDDEN; HRESULT text_to_utf8text( const WS_XML_TEXT *, const WS_XML_UTF8_TEXT *, ULONG *, WS_XML_UTF8_TEXT ** ) DECLSPEC_HIDDEN; +HRESULT str_to_guid( const unsigned char *, ULONG, GUID * ) DECLSPEC_HIDDEN; WS_XML_UTF8_TEXT *alloc_utf8_text( const BYTE *, ULONG ) DECLSPEC_HIDDEN; WS_XML_UTF16_TEXT *alloc_utf16_text( const BYTE *, ULONG ) DECLSPEC_HIDDEN; WS_XML_BASE64_TEXT *alloc_base64_text( const BYTE *, ULONG ) DECLSPEC_HIDDEN; -- 2.11.0

1 0

[PATCH 4/6] webservices: Increase the maximum size of the channel writer buffer.
by Hans Leidekker 31 Oct '18

31 Oct '18

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index b995a86c92..de84b0e66f 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -1316,9 +1316,14 @@ static HRESULT init_writer( struct channel *channel ) WS_XML_WRITER_BUFFER_OUTPUT buf = {{WS_XML_WRITER_OUTPUT_TYPE_BUFFER}}; WS_XML_WRITER_TEXT_ENCODING text = {{WS_XML_WRITER_ENCODING_TYPE_TEXT}, WS_CHARSET_UTF8}; WS_XML_WRITER_BINARY_ENCODING bin = {{WS_XML_WRITER_ENCODING_TYPE_BINARY}}; + WS_XML_WRITER_PROPERTY prop; + ULONG max_size = (1 << 17); HRESULT hr; - if (!channel->writer && (hr = WsCreateWriter( NULL, 0, &channel->writer, NULL )) != S_OK) return hr; + prop.id = WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE; + prop.value = &max_size; + prop.valueSize = sizeof(max_size); + if (!channel->writer && (hr = WsCreateWriter( &prop, 1, &channel->writer, NULL )) != S_OK) return hr; switch (channel->encoding) { -- 2.11.0

1 0

[PATCH 3/6] webservices: Add traces.
by Hans Leidekker 31 Oct '18

31 Oct '18

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index 91ffe5be00..b995a86c92 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -395,6 +395,11 @@ static HRESULT create_channel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding, for (i = 0; i < count; i++) { + TRACE( "property id %u value ptr %p size %u\n", properties[i].id, properties[i].value, + properties[i].valueSize ); + if (properties[i].valueSize == sizeof(ULONG) && properties[i].value) + TRACE( " value %08x\n", *(ULONG *)properties[i].value ); + switch (properties[i].id) { case WS_CHANNEL_PROPERTY_ENCODING: @@ -623,6 +628,8 @@ static HRESULT open_channel( struct channel *channel, const WS_ENDPOINT_ADDRESS return E_NOTIMPL; } + TRACE( "endpoint %s\n", debugstr_wn(endpoint->url.chars, endpoint->url.length) ); + if (!(channel->addr.url.chars = heap_alloc( endpoint->url.length * sizeof(WCHAR) ))) return E_OUTOFMEMORY; memcpy( channel->addr.url.chars, endpoint->url.chars, endpoint->url.length * sizeof(WCHAR) ); channel->addr.url.length = endpoint->url.length; -- 2.11.0

1 0

[PATCH 1/6] webservices: Also trace return values in the URL functions.
by Hans Leidekker 31 Oct '18

31 Oct '18

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/url.c | 67 ++++++++++++++++++++++++++++---------------------- 1 file changed, 38 insertions(+), 29 deletions(-) diff --git a/dlls/webservices/url.c b/dlls/webservices/url.c index 731b74e7b4..fd8d33a8c2 100644 --- a/dlls/webservices/url.c +++ b/dlls/webservices/url.c @@ -192,22 +192,22 @@ HRESULT WINAPI WsDecodeUrl( const WS_STRING *str, ULONG flags, WS_HEAP *heap, WS return E_NOTIMPL; } if (!(decoded = url_decode( str->chars, str->length, heap, &len_decoded )) || - !(url = ws_alloc( heap, sizeof(*url) ))) goto error; + !(url = ws_alloc( heap, sizeof(*url) ))) goto done; hr = WS_E_INVALID_FORMAT; p = q = decoded; len = len_decoded; while (len && *q != ':') { q++; len--; }; - if (*q != ':') goto error; - if ((url->url.scheme = scheme_type( p, q - p )) == ~0u) goto error; + if (*q != ':') goto done; + if ((url->url.scheme = scheme_type( p, q - p )) == ~0u) goto done; - if (!--len || *++q != '/') goto error; - if (!--len || *++q != '/') goto error; + if (!--len || *++q != '/') goto done; + if (!--len || *++q != '/') goto done; p = ++q; len--; while (len && *q != '/' && *q != ':' && *q != '?' && *q != '#') { q++; len--; }; - if (q == p) goto error; + if (q == p) goto done; url->host.length = q - p; url->host.chars = p; @@ -216,7 +216,7 @@ HRESULT WINAPI WsDecodeUrl( const WS_STRING *str, ULONG flags, WS_HEAP *heap, WS p = ++q; len--; while (len && isdigitW( *q )) { - if ((port = port * 10 + *q - '0') > 65535) goto error; + if ((port = port * 10 + *q - '0') > 65535) goto done; q++; len--; }; url->port = port; @@ -258,11 +258,15 @@ HRESULT WINAPI WsDecodeUrl( const WS_STRING *str, ULONG flags, WS_HEAP *heap, WS else url->fragment.length = 0; *ret = (WS_URL *)url; - return S_OK; + hr = S_OK; -error: - if (decoded != str->chars) ws_free( heap, decoded, len_decoded ); - ws_free( heap, url, sizeof(*url) ); +done: + if (hr != S_OK) + { + if (decoded != str->chars) ws_free( heap, decoded, len_decoded ); + ws_free( heap, url, sizeof(*url) ); + } + TRACE( "returning %08x\n", hr ); return hr; } @@ -420,12 +424,12 @@ HRESULT WINAPI WsEncodeUrl( const WS_URL *base, ULONG flags, WS_HEAP *heap, WS_S WS_ERROR *error ) { static const WCHAR fmtW[] = {':','%','u',0}; - ULONG len = 0, len_scheme, len_enc, ret_size; + ULONG len = 0, len_scheme, len_enc, ret_size = 0; const WS_HTTP_URL *url = (const WS_HTTP_URL *)base; const WCHAR *scheme; - WCHAR *str, *p, *q; + WCHAR *str = NULL, *p, *q; ULONG port = 0; - HRESULT hr; + HRESULT hr = WS_E_INVALID_FORMAT; TRACE( "%p %08x %p %p %p\n", base, flags, heap, ret, error ); if (error) FIXME( "ignoring error parameter\n" ); @@ -436,28 +440,32 @@ HRESULT WINAPI WsEncodeUrl( const WS_URL *base, ULONG flags, WS_HEAP *heap, WS_S FIXME( "unimplemented flags %08x\n", flags ); return E_NOTIMPL; } - if (!(scheme = scheme_str( url->url.scheme, &len_scheme ))) return WS_E_INVALID_FORMAT; + if (!(scheme = scheme_str( url->url.scheme, &len_scheme ))) goto done; len = len_scheme + 3; /* '://' */ len += 6; /* ':65535' */ if ((hr = url_encode_size( url->host.chars, url->host.length, "", &len_enc )) != S_OK) - return hr; + goto done; len += len_enc; if ((hr = url_encode_size( url->path.chars, url->path.length, "/", &len_enc )) != S_OK) - return hr; + goto done; len += len_enc; if ((hr = url_encode_size( url->query.chars, url->query.length, "/?", &len_enc )) != S_OK) - return hr; + goto done; len += len_enc + 1; /* '?' */ if ((hr = url_encode_size( url->fragment.chars, url->fragment.length, "/?", &len_enc )) != S_OK) - return hr; + goto done; len += len_enc + 1; /* '#' */ ret_size = len * sizeof(WCHAR); - if (!(str = ws_alloc( heap, ret_size ))) return WS_E_QUOTA_EXCEEDED; + if (!(str = ws_alloc( heap, ret_size ))) + { + hr = WS_E_QUOTA_EXCEEDED; + goto done; + } memcpy( str, scheme, len_scheme * sizeof(WCHAR) ); p = str + len_scheme; @@ -466,7 +474,7 @@ HRESULT WINAPI WsEncodeUrl( const WS_URL *base, ULONG flags, WS_HEAP *heap, WS_S p += 3; if ((hr = url_encode( url->host.chars, url->host.length, p, "", &len_enc )) != S_OK) - goto error; + goto done; p += len_enc; if (url->portAsString.length) @@ -478,14 +486,14 @@ HRESULT WINAPI WsEncodeUrl( const WS_URL *base, ULONG flags, WS_HEAP *heap, WS_S if ((port = port * 10 + *q - '0') > 65535) { hr = WS_E_INVALID_FORMAT; - goto error; + goto done; } q++; len--; } if (url->port && port != url->port) { hr = E_INVALIDARG; - goto error; + goto done; } } else port = url->port; @@ -499,14 +507,14 @@ HRESULT WINAPI WsEncodeUrl( const WS_URL *base, ULONG flags, WS_HEAP *heap, WS_S } if ((hr = url_encode( url->path.chars, url->path.length, p, "/", &len_enc )) != S_OK) - goto error; + goto done; p += len_enc; if (url->query.length) { *p++ = '?'; if ((hr = url_encode( url->query.chars, url->query.length, p, "/?", &len_enc )) != S_OK) - goto error; + goto done; p += len_enc; } @@ -514,15 +522,16 @@ HRESULT WINAPI WsEncodeUrl( const WS_URL *base, ULONG flags, WS_HEAP *heap, WS_S { *p++ = '#'; if ((hr = url_encode( url->fragment.chars, url->fragment.length, p, "/?", &len_enc )) != S_OK) - goto error; + goto done; p += len_enc; } ret->length = p - str; ret->chars = str; - return S_OK; + hr = S_OK; -error: - ws_free( heap, str, ret_size ); +done: + if (hr != S_OK) ws_free( heap, str, ret_size ); + TRACE( "returning %08x\n", hr ); return hr; } -- 2.11.0

1 0

Jump to page:

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 October 2018