wine-devel May 2021

wine-devel@winehq.org

86 participants
705 discussions

[PATCH v4 1/6] winex11.drv: Use length returned from sprintfW().
by Zhiyi Zhang 19 May '21

19 May '21

A minor optimization. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- v4: Supersede 204305~204308. Make wineserver calls atomic. dlls/winex11.drv/display.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/dlls/winex11.drv/display.c b/dlls/winex11.drv/display.c index b647455a01f..b3ff213ae89 100644 --- a/dlls/winex11.drv/display.c +++ b/dlls/winex11.drv/display.c @@ -586,6 +586,7 @@ static BOOL X11DRV_InitMonitor(HDEVINFO devinfo, const struct x11drv_monitor *mo { SP_DEVINFO_DATA device_data = {sizeof(SP_DEVINFO_DATA)}; WCHAR bufferW[MAX_PATH]; + DWORD length; HKEY hkey; BOOL ret = FALSE; @@ -629,9 +630,9 @@ static BOOL X11DRV_InitMonitor(HDEVINFO devinfo, const struct x11drv_monitor *mo (const BYTE *)&monitor->rc_work, sizeof(monitor->rc_work), 0)) goto done; /* Adapter name */ - sprintfW(bufferW, adapter_name_fmtW, video_index + 1); + length = sprintfW(bufferW, adapter_name_fmtW, video_index + 1); if (!SetupDiSetDevicePropertyW(devinfo, &device_data, &WINE_DEVPROPKEY_MONITOR_ADAPTERNAME, DEVPROP_TYPE_STRING, - (const BYTE *)bufferW, (strlenW(bufferW) + 1) * sizeof(WCHAR), 0)) + (const BYTE *)bufferW, (length + 1) * sizeof(WCHAR), 0)) goto done; ret = TRUE; -- 2.30.2

1 0

[PATCH 7/7] webservices: Return WS_S_END when we receive an end frame.
by Hans Leidekker 19 May '21

19 May '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index b920f972de3..b894b0f61ba 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -2050,6 +2050,7 @@ static HRESULT receive_sized_envelope( struct channel *channel ) HRESULT hr; if ((hr = receive_bytes( channel, &type, 1 )) != S_OK) return hr; + if (type == FRAME_RECORD_TYPE_END) return WS_S_END; if (type != FRAME_RECORD_TYPE_SIZED_ENVELOPE) return WS_E_INVALID_FORMAT; if ((hr = receive_size( channel, &size )) != S_OK) return hr; if ((hr = receive_message_sized( channel, size )) != S_OK) return hr; -- 2.30.2

1 0

[PATCH 6/7] webservices: Add async support in WsWriteMessageEnd.
by Hans Leidekker 19 May '21

19 May '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 53 +++++++++++++++++++++++++++++++++++--- 1 file changed, 49 insertions(+), 4 deletions(-) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index 9957592f9f7..b920f972de3 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -2733,18 +2733,57 @@ HRESULT WINAPI WsWriteMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const W return hr; } +static HRESULT write_message_end( struct channel *channel, WS_MESSAGE *msg ) +{ + HRESULT hr; + if ((hr = WsWriteEnvelopeEnd( msg, NULL )) == S_OK) hr = send_message_bytes( channel, msg ); + return hr; +} + +struct write_message_end +{ + struct task task; + struct channel *channel; + WS_MESSAGE *msg; + WS_ASYNC_CONTEXT ctx; +}; + +static void write_message_end_proc( struct task *task ) +{ + struct write_message_end *w = (struct write_message_end *)task; + HRESULT hr; + + hr = write_message_end( w->channel, w->msg ); + + TRACE( "calling %p(%08x)\n", w->ctx.callback, hr ); + w->ctx.callback( hr, WS_LONG_CALLBACK, w->ctx.callbackState ); + TRACE( "%p returned\n", w->ctx.callback ); +} + +static HRESULT queue_write_message_end( struct channel *channel, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx ) +{ + struct write_message_start *w; + + if (!(w = heap_alloc( sizeof(*w) ))) return E_OUTOFMEMORY; + w->task.proc = write_message_end_proc; + w->channel = channel; + w->msg = msg; + w->ctx = *ctx; + return queue_task( &channel->send_q, &w->task ); +} + /************************************************************************** * WsWriteMessageEnd [webservices.@] */ -HRESULT WINAPI WsWriteMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx, - WS_ERROR *error ) +HRESULT WINAPI WsWriteMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error ) { struct channel *channel = (struct channel *)handle; + WS_ASYNC_CONTEXT ctx_local; + struct async async; HRESULT hr; TRACE( "%p %p %p %p\n", handle, msg, ctx, error ); if (error) FIXME( "ignoring error parameter\n" ); - if (ctx) FIXME( "ignoring ctx parameter\n" ); if (!channel || !msg) return E_INVALIDARG; @@ -2761,7 +2800,13 @@ HRESULT WINAPI WsWriteMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ return WS_E_INVALID_OPERATION; } - if ((hr = WsWriteEnvelopeEnd( msg, NULL )) == S_OK) hr = send_message_bytes( channel, msg ); + if (!ctx) async_init( &async, &ctx_local ); + hr = queue_write_message_end( channel, msg, ctx ? ctx : &ctx_local ); + if (!ctx) + { + if (hr == WS_S_ASYNC) hr = async_wait( &async ); + CloseHandle( async.done ); + } LeaveCriticalSection( &channel->cs ); TRACE( "returning %08x\n", hr ); -- 2.30.2

1 0

[PATCH 5/7] webservices: Add async support in WsWriteMessageStart.
by Hans Leidekker 19 May '21

19 May '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 57 +++++++++++++++++++++++++++++++++----- 1 file changed, 50 insertions(+), 7 deletions(-) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index c97a0d49a66..9957592f9f7 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -2652,18 +2652,58 @@ HRESULT WINAPI WsReadMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_A return hr; } +static HRESULT write_message_start( struct channel *channel, WS_MESSAGE *msg ) +{ + HRESULT hr; + if ((hr = init_writer( channel )) != S_OK) return hr; + if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) return hr; + return WsWriteEnvelopeStart( msg, channel->writer, NULL, NULL, NULL ); +} + +struct write_message_start +{ + struct task task; + struct channel *channel; + WS_MESSAGE *msg; + WS_ASYNC_CONTEXT ctx; +}; + +static void write_message_start_proc( struct task *task ) +{ + struct write_message_start *w = (struct write_message_start *)task; + HRESULT hr; + + hr = write_message_start( w->channel, w->msg ); + + TRACE( "calling %p(%08x)\n", w->ctx.callback, hr ); + w->ctx.callback( hr, WS_LONG_CALLBACK, w->ctx.callbackState ); + TRACE( "%p returned\n", w->ctx.callback ); +} + +static HRESULT queue_write_message_start( struct channel *channel, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx ) +{ + struct write_message_start *w; + + if (!(w = heap_alloc( sizeof(*w) ))) return E_OUTOFMEMORY; + w->task.proc = write_message_start_proc; + w->channel = channel; + w->msg = msg; + w->ctx = *ctx; + return queue_task( &channel->send_q, &w->task ); +} + /************************************************************************** * WsWriteMessageStart [webservices.@] */ -HRESULT WINAPI WsWriteMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx, - WS_ERROR *error ) +HRESULT WINAPI WsWriteMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error ) { struct channel *channel = (struct channel *)handle; + WS_ASYNC_CONTEXT ctx_local; + struct async async; HRESULT hr; TRACE( "%p %p %p %p\n", handle, msg, ctx, error ); if (error) FIXME( "ignoring error parameter\n" ); - if (ctx) FIXME( "ignoring ctx parameter\n" ); if (!channel || !msg) return E_INVALIDARG; @@ -2680,11 +2720,14 @@ HRESULT WINAPI WsWriteMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const W return WS_E_INVALID_OPERATION; } - if ((hr = init_writer( channel )) != S_OK) goto done; - if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done; - hr = WsWriteEnvelopeStart( msg, channel->writer, NULL, NULL, NULL ); + if (!ctx) async_init( &async, &ctx_local ); + hr = queue_write_message_start( channel, msg, ctx ? ctx : &ctx_local ); + if (!ctx) + { + if (hr == WS_S_ASYNC) hr = async_wait( &async ); + CloseHandle( async.done ); + } -done: LeaveCriticalSection( &channel->cs ); TRACE( "returning %08x\n", hr ); return hr; -- 2.30.2

1 0

[PATCH 4/7] webservices: Add async support in WsReadMessageEnd.
by Hans Leidekker 19 May '21

19 May '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 49 ++++++++++++++++++++++++++++++++++---- 1 file changed, 45 insertions(+), 4 deletions(-) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index 4df761cd5ea..c97a0d49a66 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -2581,18 +2581,53 @@ HRESULT WINAPI WsReadMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS return hr; } +static HRESULT read_message_end( WS_MESSAGE *msg ) +{ + return WsReadEnvelopeEnd( msg, NULL ); +} + +struct read_message_end +{ + struct task task; + WS_MESSAGE *msg; + WS_ASYNC_CONTEXT ctx; +}; + +static void read_message_end_proc( struct task *task ) +{ + struct read_message_end *r = (struct read_message_end *)task; + HRESULT hr; + + hr = read_message_end( r->msg ); + + 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_read_message_end( struct channel *channel, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx ) +{ + struct read_message_end *r; + + if (!(r = heap_alloc( sizeof(*r) ))) return E_OUTOFMEMORY; + r->task.proc = read_message_end_proc; + r->msg = msg; + r->ctx = *ctx; + return queue_task( &channel->recv_q, &r->task ); +} + /************************************************************************** * WsReadMessageEnd [webservices.@] */ -HRESULT WINAPI WsReadMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx, - WS_ERROR *error ) +HRESULT WINAPI WsReadMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error ) { struct channel *channel = (struct channel *)handle; + WS_ASYNC_CONTEXT ctx_local; + struct async async; HRESULT hr; TRACE( "%p %p %p %p\n", handle, msg, ctx, error ); if (error) FIXME( "ignoring error parameter\n" ); - if (ctx) FIXME( "ignoring ctx parameter\n" ); if (!channel || !msg) return E_INVALIDARG; @@ -2604,7 +2639,13 @@ HRESULT WINAPI WsReadMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_A return E_INVALIDARG; } - hr = WsReadEnvelopeEnd( msg, NULL ); + if (!ctx) async_init( &async, &ctx_local ); + hr = queue_read_message_end( channel, msg, ctx ? ctx : &ctx_local ); + if (!ctx) + { + if (hr == WS_S_ASYNC) hr = async_wait( &async ); + CloseHandle( async.done ); + } LeaveCriticalSection( &channel->cs ); TRACE( "returning %08x\n", hr ); -- 2.30.2

1 0

[PATCH 3/7] webservices: Add async support in WsReadMessageStart.
by Hans Leidekker 19 May '21

19 May '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 54 +++++++++++++++++++++++++++++++++----- 1 file changed, 48 insertions(+), 6 deletions(-) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index 430453443d0..4df761cd5ea 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -2500,18 +2500,58 @@ HRESULT WINAPI WsRequestReply( WS_CHANNEL *handle, WS_MESSAGE *request, const WS return hr; } +static HRESULT read_message_start( struct channel *channel, WS_MESSAGE *msg ) +{ + HRESULT hr; + if ((hr = receive_message_bytes( channel, msg )) == S_OK && (hr = init_reader( channel )) == S_OK) + hr = WsReadEnvelopeStart( msg, channel->reader, NULL, NULL, NULL ); + return hr; +} + +struct read_message_start +{ + struct task task; + struct channel *channel; + WS_MESSAGE *msg; + WS_ASYNC_CONTEXT ctx; +}; + +static void read_message_start_proc( struct task *task ) +{ + struct read_message_start *r = (struct read_message_start *)task; + HRESULT hr; + + hr = read_message_start( r->channel, r->msg ); + + 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_read_message_start( struct channel *channel, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx ) +{ + struct read_message_start *r; + + if (!(r = heap_alloc( sizeof(*r) ))) return E_OUTOFMEMORY; + r->task.proc = read_message_start_proc; + r->channel = channel; + r->msg = msg; + r->ctx = *ctx; + return queue_task( &channel->recv_q, &r->task ); +} + /************************************************************************** * WsReadMessageStart [webservices.@] */ -HRESULT WINAPI WsReadMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx, - WS_ERROR *error ) +HRESULT WINAPI WsReadMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error ) { struct channel *channel = (struct channel *)handle; + WS_ASYNC_CONTEXT ctx_local; + struct async async; HRESULT hr; TRACE( "%p %p %p %p\n", handle, msg, ctx, error ); if (error) FIXME( "ignoring error parameter\n" ); - if (ctx) FIXME( "ignoring ctx parameter\n" ); if (!channel || !msg) return E_INVALIDARG; @@ -2528,10 +2568,12 @@ HRESULT WINAPI WsReadMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS return WS_E_INVALID_OPERATION; } - if ((hr = receive_message_bytes( channel, msg )) == S_OK) + if (!ctx) async_init( &async, &ctx_local ); + hr = queue_read_message_start( channel, msg, ctx ? ctx : &ctx_local ); + if (!ctx) { - if ((hr = init_reader( channel )) == S_OK) - hr = WsReadEnvelopeStart( msg, channel->reader, NULL, NULL, NULL ); + if (hr == WS_S_ASYNC) hr = async_wait( &async ); + CloseHandle( async.done ); } LeaveCriticalSection( &channel->cs ); -- 2.30.2

1 0

[PATCH 2/7] webservices: Add async support in WsSendReplyMessage.
by Hans Leidekker 19 May '21

19 May '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 31 ++++++++++++++----------------- 1 file changed, 14 insertions(+), 17 deletions(-) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index 7e576544205..430453443d0 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -1738,12 +1738,13 @@ HRESULT WINAPI WsSendReplyMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error ) { struct channel *channel = (struct channel *)handle; - GUID req_id; + WS_ASYNC_CONTEXT ctx_local; + struct async async; + GUID id; HRESULT hr; TRACE( "%p %p %p %08x %p %u %p %p %p\n", handle, msg, desc, option, body, size, request, ctx, error ); if (error) FIXME( "ignoring error parameter\n" ); - if (ctx) FIXME( "ignoring ctx parameter\n" ); if (!channel || !msg || !desc || !request) return E_INVALIDARG; @@ -1760,15 +1761,16 @@ HRESULT WINAPI WsSendReplyMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS return WS_E_INVALID_OPERATION; } - if ((hr = WsInitializeMessage( msg, WS_REPLY_MESSAGE, NULL, NULL )) != S_OK) goto done; - if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done; - if ((hr = message_set_action( msg, desc->action )) != S_OK) goto done; - if ((hr = message_get_id( request, &req_id )) != S_OK) goto done; - if ((hr = message_set_request_id( msg, &req_id )) != S_OK) goto done; + if ((hr = message_get_id( request, &id )) != S_OK) goto done; + if ((hr = message_set_request_id( msg, &id )) != S_OK) goto done; - if ((hr = init_writer( channel )) != S_OK) goto done; - if ((hr = write_message( channel, msg, desc->bodyElementDescription, option, body, size )) != S_OK) goto done; - hr = send_message_bytes( channel, msg ); + if (!ctx) async_init( &async, &ctx_local ); + hr = queue_send_message( channel, msg, desc, option, body, size, ctx ? ctx : &ctx_local ); + if (!ctx) + { + if (hr == WS_S_ASYNC) hr = async_wait( &async ); + CloseHandle( async.done ); + } done: LeaveCriticalSection( &channel->cs ); @@ -2387,14 +2389,9 @@ static HRESULT request_reply( struct channel *channel, WS_MESSAGE *request, 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_bytes( channel, request )) != S_OK) return hr; + if ((hr = send_message( channel, request, request_desc, write_option, request_body, request_size )) != S_OK) + return hr; return receive_message( channel, reply, &reply_desc, 1, WS_RECEIVE_OPTIONAL_MESSAGE, read_option, heap, value, size, NULL ); -- 2.30.2

1 0

[PATCH 1/7] webservices: Add async support in WsSendMessage.
by Hans Leidekker 19 May '21

19 May '21

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/channel.c | 85 +++++++++++++++++++++++++++++++------- 1 file changed, 69 insertions(+), 16 deletions(-) diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c index bc65f0943bf..7e576544205 100644 --- a/dlls/webservices/channel.c +++ b/dlls/webservices/channel.c @@ -1460,7 +1460,7 @@ static HRESULT open_http_request( struct channel *channel, HINTERNET *req ) return HRESULT_FROM_WIN32( GetLastError() ); } -static HRESULT send_message( struct channel *channel, WS_MESSAGE *msg ) +static HRESULT send_message_bytes( struct channel *channel, WS_MESSAGE *msg ) { WS_XML_WRITER *writer; WS_BYTES buf; @@ -1529,7 +1529,7 @@ HRESULT channel_send_message( WS_CHANNEL *handle, WS_MESSAGE *msg ) return WS_E_INVALID_OPERATION; } - hr = send_message( channel, msg ); + hr = send_message_bytes( channel, msg ); LeaveCriticalSection( &channel->cs ); return hr; @@ -1561,8 +1561,8 @@ static HRESULT CALLBACK dict_cb( void *state, const WS_XML_STRING *str, BOOL *fo return hr; } -static CALLBACK HRESULT write_callback( void *state, const WS_BYTES *buf, ULONG count, - const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error ) +static CALLBACK HRESULT write_callback( void *state, const WS_BYTES *buf, ULONG count, const WS_ASYNC_CONTEXT *ctx, + WS_ERROR *error ) { SOCKET socket = *(SOCKET *)state; if (send( socket, (const char *)buf->bytes, buf->length, 0 ) < 0) @@ -1634,6 +1634,59 @@ static HRESULT write_message( struct channel *channel, WS_MESSAGE *msg, const WS return WsWriteEnvelopeEnd( msg, NULL ); } +static HRESULT send_message( struct channel *channel, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION *desc, + WS_WRITE_OPTION option, const void *body, ULONG size ) +{ + HRESULT hr; + WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL ); + if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) return hr; + if ((hr = message_set_action( msg, desc->action )) != S_OK) return hr; + if ((hr = init_writer( channel )) != S_OK) return hr; + if ((hr = write_message( channel, msg, desc->bodyElementDescription, option, body, size )) != S_OK) return hr; + return send_message_bytes( channel, msg ); +} + +struct send_message +{ + struct task task; + struct channel *channel; + WS_MESSAGE *msg; + const WS_MESSAGE_DESCRIPTION *desc; + WS_WRITE_OPTION option; + const void *body; + ULONG size; + WS_ASYNC_CONTEXT ctx; +}; + +static void send_message_proc( struct task *task ) +{ + struct send_message *s = (struct send_message *)task; + HRESULT hr; + + hr = send_message( s->channel, s->msg, s->desc, s->option, s->body, s->size ); + + TRACE( "calling %p(%08x)\n", s->ctx.callback, hr ); + s->ctx.callback( hr, WS_LONG_CALLBACK, s->ctx.callbackState ); + TRACE( "%p returned\n", s->ctx.callback ); +} + +static HRESULT queue_send_message( struct channel *channel, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION *desc, + WS_WRITE_OPTION option, const void *body, ULONG size, const WS_ASYNC_CONTEXT *ctx ) +{ + struct send_message *s; + + if (!(s = heap_alloc( sizeof(*s) ))) return E_OUTOFMEMORY; + s->task.proc = send_message_proc; + s->channel = channel; + s->msg = msg; + s->desc = desc; + s->option = option; + s->body = body; + s->size = size; + s->ctx = *ctx; + return queue_task( &channel->send_q, &s->task ); +} + /************************************************************************** * WsSendMessage [webservices.@] */ @@ -1642,11 +1695,12 @@ HRESULT WINAPI WsSendMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESS WS_ERROR *error ) { struct channel *channel = (struct channel *)handle; + WS_ASYNC_CONTEXT ctx_local; + struct async async; HRESULT hr; TRACE( "%p %p %p %08x %p %u %p %p\n", handle, msg, desc, option, body, size, ctx, error ); if (error) FIXME( "ignoring error parameter\n" ); - if (ctx) FIXME( "ignoring ctx parameter\n" ); if (!channel || !msg || !desc) return E_INVALIDARG; @@ -1663,15 +1717,14 @@ HRESULT WINAPI WsSendMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESS return WS_E_INVALID_OPERATION; } - if ((hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL )) != S_OK) goto done; - if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done; - if ((hr = message_set_action( msg, desc->action )) != S_OK) goto done; - - if ((hr = init_writer( channel )) != S_OK) goto done; - if ((hr = write_message( channel, msg, desc->bodyElementDescription, option, body, size )) != S_OK) goto done; - hr = send_message( channel, msg ); + if (!ctx) async_init( &async, &ctx_local ); + hr = queue_send_message( channel, msg, desc, option, body, size, ctx ? ctx : &ctx_local ); + if (!ctx) + { + if (hr == WS_S_ASYNC) hr = async_wait( &async ); + CloseHandle( async.done ); + } -done: LeaveCriticalSection( &channel->cs ); TRACE( "returning %08x\n", hr ); return hr; @@ -1715,7 +1768,7 @@ HRESULT WINAPI WsSendReplyMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS if ((hr = init_writer( channel )) != S_OK) goto done; if ((hr = write_message( channel, msg, desc->bodyElementDescription, option, body, size )) != S_OK) goto done; - hr = send_message( channel, msg ); + hr = send_message_bytes( channel, msg ); done: LeaveCriticalSection( &channel->cs ); @@ -2341,7 +2394,7 @@ static HRESULT request_reply( struct channel *channel, WS_MESSAGE *request, 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; + if ((hr = send_message_bytes( channel, request )) != S_OK) return hr; return receive_message( channel, reply, &reply_desc, 1, WS_RECEIVE_OPTIONAL_MESSAGE, read_option, heap, value, size, NULL ); @@ -2585,7 +2638,7 @@ HRESULT WINAPI WsWriteMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_ return WS_E_INVALID_OPERATION; } - if ((hr = WsWriteEnvelopeEnd( msg, NULL )) == S_OK) hr = send_message( channel, msg ); + if ((hr = WsWriteEnvelopeEnd( msg, NULL )) == S_OK) hr = send_message_bytes( channel, msg ); LeaveCriticalSection( &channel->cs ); TRACE( "returning %08x\n", hr ); -- 2.30.2

1 0

[PATCH] msxml3/tests: Execute ProcessingInstruction tests before other tests to avoid crashes under 64-bit Windows.
by Dmitry Timoshkov 19 May '21

19 May '21

It seems that the ProcessingInstruction tests somehow trigger internal inconsistency in 64-bit msxml under Windows, and I haven't found other ways to stop crashes on exit. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/msxml3/tests/domdoc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 59a8a243c87..3dcfdb8fd39 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -13610,6 +13610,7 @@ START_TEST(domdoc) return; } + test_createProcessingInstruction(); test_load_with_site(); test_domdoc(); test_persiststream(); @@ -13651,7 +13652,6 @@ START_TEST(domdoc) test_default_properties(); test_selectSingleNode(); test_events(); - test_createProcessingInstruction(); test_put_nodeTypedValue(); test_get_xml(); test_insertBefore(); -- 2.31.1

2 2

[PATCH 1/6] ws2_32: Do not use SHUT_RD.
by Zebediah Figura 19 May '21

19 May '21

Win32 SD_RECEIVE has the following effects on a TCP or UDP socket: * further calls to recv() et al. fail with ESHUTDOWN. However, Linux and Mac instead return 0. * currently pending calls to recv() are not affected. However, Linux and Mac cause them to return 0. * calls to WSAPoll() are unaffected. However, Linux and Mac instead signal both POLLHUP and POLLIN. * for TCP connections, further data sent by the peer causes the connection to be reset. Mac and BSD will silently drop data, and Linux simply queues it forever. In short, SHUT_RD does nothing that we want it to do on Linux or Mac (and probably also BSD, though I am unable to test this). Most of this impedance mismatch can be worked around in Wine, except for WSAPoll(). Since poll() will always return POLLHUP, we can't safely ask for POLLOUT, which we may need to do. Hence, since we aren't getting any benefit from SHUT_RD, don't use it. Note that this doesn't actually fix any tests, since we have some rather bizarre logic to defer shutdown anyway (for an asynchronous socket, we don't call shutdown(SHUT_RD) until the peer sends data; this is probably an unintended bug, but "fixing" it ends up causing test failures, which is the main impetus for this patch.) Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ws2_32/socket.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c index 889f0327baf..aad92d5d4df 100644 --- a/dlls/ws2_32/socket.c +++ b/dlls/ws2_32/socket.c @@ -2290,7 +2290,7 @@ static NTSTATUS WS2_async_shutdown( void *user, IO_STATUS_BLOCK *iosb, NTSTATUS switch ( wsa->type ) { - case ASYNC_TYPE_READ: err = shutdown( fd, 0 ); break; + case ASYNC_TYPE_READ: break; case ASYNC_TYPE_WRITE: err = shutdown( fd, 1 ); break; } status = err ? wsaErrStatus() : STATUS_SUCCESS; @@ -5550,7 +5550,7 @@ int WINAPI WS_shutdown(SOCKET s, int how) } else /* non-overlapped mode */ { - if ( shutdown( fd, how ) ) + if (how != SD_RECEIVE && shutdown( fd, SHUT_WR )) { err = wsaErrno(); goto error; -- 2.30.2

2 7

← Newer
1
...
30
31
32
33
34
35
36
...
71
Older →

Jump to page:

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