[PATCH v20 0/15] MR10611: LPC: Implement proper LPC system
Until now, LPC was just a stub, any application that relied on LPC for communication would fail. This change implements parts of LPC, to allow for IPC between programs. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=30069 - fully fixed, sqlservr is able to run as expected Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=59494 - partially fixed, starmoney doesn't flat out crash anymore, but it doesn't start fully, possibly because it uses the ALPC system which was introduced in Windows Vista, the version Starmoney 10 was advertised for -- v20: wow64: Convert LPC messages. https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Add the basic LPC port object type with support for creating named ports. This implements the server-side create_lpc_port request which will be used by NtCreatePort and NtCreateWaitablePort. The LPC port object supports: - Named ports in the object namespace - Waitable ports (PORT_FLAG_WAITABLE) that can be used with WaitForSingleObject - Maximum message length and connection info size limits --- server/Makefile.in | 1 + server/lpc_port.c | 213 ++++++++++++++++++++++++++++++++++++++++++++ server/protocol.def | 12 +++ 3 files changed, 226 insertions(+) create mode 100644 server/lpc_port.c diff --git a/server/Makefile.in b/server/Makefile.in index 84a6bd74d9d..b6dc080896c 100644 --- a/server/Makefile.in +++ b/server/Makefile.in @@ -18,6 +18,7 @@ SOURCES = \ handle.c \ hook.c \ inproc_sync.c \ + lpc_port.c \ mach.c \ mailslot.c \ main.c \ diff --git a/server/lpc_port.c b/server/lpc_port.c new file mode 100644 index 00000000000..3c4ef23a4fb --- /dev/null +++ b/server/lpc_port.c @@ -0,0 +1,213 @@ +/* + * Server-side LPC port management + * + * Copyright 2026 Wine project + * + * 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 <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <string.h> + +#include "ntstatus.h" +#define WIN32_NO_STATUS +#include "windef.h" +#include "winternl.h" + +#include "handle.h" +#include "thread.h" +#include "process.h" +#include "request.h" +#include "security.h" +#include "object.h" + +/* Port access rights */ +#define PORT_CONNECT 0x0001 +#define PORT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | PORT_CONNECT) + +/* Port types */ +#define PORT_TYPE_SERVER 0x01 /* Named port that server listens on */ + +/* Port flags */ +#define PORT_FLAG_WAITABLE 0x0001 + +/* Maximum message size */ +#define MAX_LPC_MESSAGE_SIZE 0x40000 + +static const WCHAR lpc_port_name[] = {'L','P','C',' ','P','o','r','t'}; + +struct type_descr lpc_port_type = +{ + { lpc_port_name, sizeof(lpc_port_name) }, /* name */ + PORT_ALL_ACCESS, /* valid_access */ + { /* mapping */ + STANDARD_RIGHTS_READ | PORT_CONNECT, + STANDARD_RIGHTS_WRITE, + STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE, + PORT_ALL_ACCESS + }, +}; + +/* LPC port object */ +struct lpc_port +{ + struct object obj; /* object header */ + unsigned int port_type; /* PORT_TYPE_* */ + unsigned int flags; /* PORT_FLAG_* */ + struct list msg_queue; /* list of pending messages */ + struct object *queue_event; /* event signaled when message arrives */ + unsigned int max_msg_len; /* maximum message length */ + unsigned int max_connect_info;/* maximum connection info length */ + struct object *wait_event; /* event for WaitForSingleObject (waitable ports) */ + struct process *server_process; /* server process (for named ports) */ +}; + +static void lpc_port_dump( struct object *obj, int verbose ); +static struct object *lpc_port_get_sync( struct object *obj ); +static void lpc_port_destroy( struct object *obj ); + +static const struct object_ops lpc_port_ops = +{ + sizeof(struct lpc_port), /* size */ + &lpc_port_type, /* type */ + lpc_port_dump, /* dump */ + NULL, /* add_queue */ + NULL, /* remove_queue */ + NULL, /* signaled */ + NULL, /* satisfied */ + no_signal, /* signal */ + no_get_fd, /* get_fd */ + lpc_port_get_sync, /* get_sync */ + default_map_access, /* map_access */ + default_get_sd, /* get_sd */ + default_set_sd, /* set_sd */ + default_get_full_name, /* get_full_name */ + no_lookup_name, /* lookup_name */ + directory_link_name, /* link_name */ + default_unlink_name, /* unlink_name */ + no_open_file, /* open_file */ + no_kernel_obj_list, /* get_kernel_obj_list */ + no_close_handle, /* close_handle */ + lpc_port_destroy /* destroy */ +}; + +static struct lpc_port *create_lpc_port( struct object *root, const struct unicode_str *name, + unsigned int attr, unsigned int flags, + unsigned int max_msg_len, unsigned int max_connect_info, + const struct security_descriptor *sd ) +{ + struct lpc_port *port; + + if (max_msg_len > MAX_LPC_MESSAGE_SIZE) + max_msg_len = MAX_LPC_MESSAGE_SIZE; + if (max_connect_info > MAX_LPC_MESSAGE_SIZE) + max_connect_info = MAX_LPC_MESSAGE_SIZE; + + if ((port = create_named_object( root, &lpc_port_ops, name, attr, sd ))) + { + if (get_error() != STATUS_OBJECT_NAME_EXISTS) + { + port->port_type = PORT_TYPE_SERVER; + port->flags = flags; + list_init( &port->msg_queue ); + port->queue_event = create_internal_sync( 0, 0 ); + port->max_msg_len = max_msg_len ? max_msg_len : MAX_LPC_MESSAGE_SIZE; + port->max_connect_info = max_connect_info ? max_connect_info : 256; + port->wait_event = NULL; + port->server_process = (struct process *)grab_object( current->process ); + + if (!port->queue_event) + { + release_object( port ); + return NULL; + } + + if (flags & PORT_FLAG_WAITABLE) + { + port->wait_event = create_internal_sync( 1, 0 ); + if (!port->wait_event) + { + release_object( port ); + return NULL; + } + } + } + } + return port; +} + +static void lpc_port_dump( struct object *obj, int verbose ) +{ + struct lpc_port *port = (struct lpc_port *)obj; + + assert( obj->ops == &lpc_port_ops ); + fprintf( stderr, "LPC Port type=%s flags=%04x max_msg=%u max_connect=%u\n", + port->port_type == PORT_TYPE_SERVER ? "SERVER" : "?", + port->flags, port->max_msg_len, port->max_connect_info ); +} + +static struct object *lpc_port_get_sync( struct object *obj ) +{ + struct lpc_port *port = (struct lpc_port *)obj; + + if (port->wait_event) + return grab_object( port->wait_event ); + + if (port->queue_event) + return grab_object( port->queue_event ); + + return NULL; +} + +static void lpc_port_destroy( struct object *obj ) +{ + struct lpc_port *port = (struct lpc_port *)obj; + + assert( obj->ops == &lpc_port_ops ); + + if (port->queue_event) release_object( port->queue_event ); + if (port->wait_event) release_object( port->wait_event ); + if (port->server_process) release_object( port->server_process ); +} + +/* Create an LPC port */ +DECL_HANDLER(create_lpc_port) +{ + struct lpc_port *port; + struct unicode_str name; + struct object *root; + const struct security_descriptor *sd; + const struct object_attributes *objattr = get_req_object_attributes( &sd, &name, &root ); + + if (!objattr) return; + + if ((port = create_lpc_port( root, &name, objattr->attributes, req->flags, + req->max_msg_len, req->max_connect_info, sd ))) + { + if (get_error() == STATUS_OBJECT_NAME_EXISTS) + reply->handle = alloc_handle( current->process, port, req->access, objattr->attributes ); + else + reply->handle = alloc_handle_no_access_check( current->process, port, + req->access, objattr->attributes ); + release_object( port ); + } + + if (root) release_object( root ); +} diff --git a/server/protocol.def b/server/protocol.def index e7d966613ac..3bbab48c873 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -4297,3 +4297,15 @@ enum inproc_sync_type data_size_t runtime_size; /* size of client runtime data */ VARARG(runtime,bytes); /* client runtime data */ @END + + +/* Create an LPC port */ +@REQ(create_lpc_port) + unsigned int access; /* desired access */ + unsigned int flags; /* port flags (waitable) */ + unsigned int max_msg_len; /* maximum message length */ + unsigned int max_connect_info; /* maximum connection info length */ + VARARG(objattr,object_attributes);/* object attributes */ +@REPLY + obj_handle_t handle; /* port handle */ +@END -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> These functions create LPC (Local Procedure Call) ports for inter-process communication. NtCreatePort creates a regular port while NtCreateWaitablePort creates a port that can be waited on using WaitForSingleObject. --- dlls/ntdll/ntdll.spec | 4 +-- dlls/ntdll/signal_arm64ec.c | 1 + dlls/ntdll/unix/sync.c | 61 +++++++++++++++++++++++++++++++++++-- dlls/wow64/sync.c | 22 +++++++++++++ include/winternl.h | 1 + 5 files changed, 85 insertions(+), 4 deletions(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 0b6d9b2cbf4..24d6dc99f2b 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -212,7 +212,7 @@ @ stdcall -syscall NtCreateToken(ptr long ptr long ptr ptr ptr ptr ptr ptr ptr ptr ptr) @ stdcall -syscall NtCreateTransaction(ptr long ptr ptr long long long long ptr ptr) @ stdcall -syscall NtCreateUserProcess(ptr ptr long long ptr ptr long long ptr ptr ptr) -# @ stub NtCreateWaitablePort +@ stdcall -syscall NtCreateWaitablePort(ptr ptr long long long) @ stdcall -arch=i386 NtCurrentTeb() @ stdcall -syscall NtDebugActiveProcess(long long) @ stdcall -syscall NtDebugContinue(long ptr long) @@ -1292,7 +1292,7 @@ @ stdcall -private ZwCreateToken(ptr long ptr long ptr ptr ptr ptr ptr ptr ptr ptr ptr) NtCreateToken @ stdcall -private ZwCreateTransaction(ptr long ptr ptr long long long long ptr ptr) NtCreateTransaction @ stdcall -private ZwCreateUserProcess(ptr ptr long long ptr ptr long long ptr ptr ptr) NtCreateUserProcess -# @ stub ZwCreateWaitablePort +@ stdcall -private ZwCreateWaitablePort(ptr ptr long long long) NtCreateWaitablePort @ stdcall -private ZwDebugActiveProcess(long long) NtDebugActiveProcess @ stdcall -private ZwDebugContinue(long ptr long) NtDebugContinue @ stdcall -private ZwDelayExecution(long ptr) NtDelayExecution diff --git a/dlls/ntdll/signal_arm64ec.c b/dlls/ntdll/signal_arm64ec.c index baee1f23722..2bd6014fdb2 100644 --- a/dlls/ntdll/signal_arm64ec.c +++ b/dlls/ntdll/signal_arm64ec.c @@ -415,6 +415,7 @@ DEFINE_SYSCALL(NtCreateTimer, (HANDLE *handle, ACCESS_MASK access, const OBJECT_ DEFINE_SYSCALL(NtCreateToken, (HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr, TOKEN_TYPE type, LUID *token_id, LARGE_INTEGER *expire, TOKEN_USER *user, TOKEN_GROUPS *groups, TOKEN_PRIVILEGES *privs, TOKEN_OWNER *owner, TOKEN_PRIMARY_GROUP *group, TOKEN_DEFAULT_DACL *dacl, TOKEN_SOURCE *source)) DEFINE_SYSCALL(NtCreateTransaction, (HANDLE *handle, ACCESS_MASK mask, OBJECT_ATTRIBUTES *obj_attr, GUID *guid, HANDLE tm, ULONG options, ULONG isol_level, ULONG isol_flags, PLARGE_INTEGER timeout, UNICODE_STRING *description)) DEFINE_SYSCALL(NtCreateUserProcess, (HANDLE *process_handle_ptr, HANDLE *thread_handle_ptr, ACCESS_MASK process_access, ACCESS_MASK thread_access, OBJECT_ATTRIBUTES *process_attr, OBJECT_ATTRIBUTES *thread_attr, ULONG process_flags, ULONG thread_flags, RTL_USER_PROCESS_PARAMETERS *params, PS_CREATE_INFO *info, PS_ATTRIBUTE_LIST *ps_attr)) +DEFINE_SYSCALL(NtCreateWaitablePort, (HANDLE *handle, OBJECT_ATTRIBUTES *attr, ULONG info_lon, ULONG data_len, ULONG reserved)) DEFINE_SYSCALL(NtDebugActiveProcess, (HANDLE process, HANDLE debug)) DEFINE_SYSCALL(NtDebugContinue, (HANDLE handle, CLIENT_ID *client, NTSTATUS status)) DEFINE_SYSCALL(NtDelayExecution, (BOOLEAN alertable, const LARGE_INTEGER *timeout)) diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c index fbf054e9d93..ede54e5944c 100644 --- a/dlls/ntdll/unix/sync.c +++ b/dlls/ntdll/unix/sync.c @@ -3061,14 +3061,71 @@ NTSTATUS WINAPI NtOpenSection( HANDLE *handle, ACCESS_MASK access, const OBJECT_ } +/* LPC port access rights */ +#define PORT_CONNECT 0x0001 +#define PORT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | PORT_CONNECT) + /*********************************************************************** * NtCreatePort (NTDLL.@) */ NTSTATUS WINAPI NtCreatePort( HANDLE *handle, OBJECT_ATTRIBUTES *attr, ULONG info_len, ULONG data_len, ULONG *reserved ) { - FIXME( "(%p,%p,%u,%u,%p),stub!\n", handle, attr, info_len, data_len, reserved ); - return STATUS_NOT_IMPLEMENTED; + unsigned int ret; + data_size_t len; + struct object_attributes *objattr; + + TRACE( "(%p,%p,%u,%u,%p)\n", handle, attr, info_len, data_len, reserved ); + + *handle = 0; + if ((ret = alloc_object_attributes( attr, &objattr, &len ))) + return ret; + + SERVER_START_REQ( create_lpc_port ) + { + req->access = PORT_ALL_ACCESS; + req->flags = 0; + req->max_msg_len = data_len; + req->max_connect_info = info_len; + wine_server_add_data( req, objattr, len ); + if (!(ret = wine_server_call( req ))) + *handle = wine_server_ptr_handle( reply->handle ); + } + SERVER_END_REQ; + free( objattr ); + return ret; +} + + +/*********************************************************************** + * NtCreateWaitablePort (NTDLL.@) + */ +NTSTATUS WINAPI NtCreateWaitablePort( HANDLE *handle, OBJECT_ATTRIBUTES *attr, ULONG info_len, + ULONG data_len, ULONG reserved ) +{ + unsigned int ret; + data_size_t len; + struct object_attributes *objattr; + + TRACE( "(%p,%p,%u,%u,%u)\n", handle, attr, info_len, data_len, reserved ); + + *handle = 0; + if ((ret = alloc_object_attributes( attr, &objattr, &len ))) + return ret; + + SERVER_START_REQ( create_lpc_port ) + { + req->access = PORT_ALL_ACCESS; + req->flags = 0x0001; /* PORT_FLAG_WAITABLE */ + req->max_msg_len = data_len; + req->max_connect_info = info_len; + wine_server_add_data( req, objattr, len ); + if (!(ret = wine_server_call( req ))) + *handle = wine_server_ptr_handle( reply->handle ); + } + SERVER_END_REQ; + free( objattr ); + return ret; } diff --git a/dlls/wow64/sync.c b/dlls/wow64/sync.c index d5b52a5c815..2f0a617b70c 100644 --- a/dlls/wow64/sync.c +++ b/dlls/wow64/sync.c @@ -403,6 +403,28 @@ NTSTATUS WINAPI wow64_NtCreateSection( UINT *args ) } +/********************************************************************** + * wow64_NtCreateWaitablePort + */ +NTSTATUS WINAPI wow64_NtCreateWaitablePort( UINT *args ) +{ + ULONG *handle_ptr = get_ptr( &args ); + OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args ); + ULONG info_len = get_ulong( &args ); + ULONG data_len = get_ulong( &args ); + ULONG reserved = get_ulong( &args ); + + struct object_attr64 attr; + HANDLE handle = 0; + NTSTATUS status; + + *handle_ptr = 0; + status = NtCreateWaitablePort( &handle, objattr_32to64( &attr, attr32 ), info_len, data_len, reserved ); + put_handle( handle_ptr, handle ); + return status; +} + + /********************************************************************** * wow64_NtCreateSemaphore */ diff --git a/include/winternl.h b/include/winternl.h index bed72e83ce4..e87ffcbb22d 100644 --- a/include/winternl.h +++ b/include/winternl.h @@ -4784,6 +4784,7 @@ NTSYSAPI NTSTATUS WINAPI NtCreateTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRI NTSYSAPI NTSTATUS WINAPI NtCreateToken(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,TOKEN_TYPE,PLUID,PLARGE_INTEGER,PTOKEN_USER,PTOKEN_GROUPS,PTOKEN_PRIVILEGES,PTOKEN_OWNER,PTOKEN_PRIMARY_GROUP,PTOKEN_DEFAULT_DACL,PTOKEN_SOURCE); NTSYSAPI NTSTATUS WINAPI NtCreateTransaction(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,LPGUID,HANDLE,ULONG,ULONG,ULONG,PLARGE_INTEGER,PUNICODE_STRING); NTSYSAPI NTSTATUS WINAPI NtCreateUserProcess(HANDLE*,HANDLE*,ACCESS_MASK,ACCESS_MASK,OBJECT_ATTRIBUTES*,OBJECT_ATTRIBUTES*,ULONG,ULONG,RTL_USER_PROCESS_PARAMETERS*,PS_CREATE_INFO*,PS_ATTRIBUTE_LIST*); +NTSYSAPI NTSTATUS WINAPI NtCreateWaitablePort(HANDLE*,OBJECT_ATTRIBUTES*,ULONG,ULONG,ULONG); NTSYSAPI NTSTATUS WINAPI NtDebugActiveProcess(HANDLE,HANDLE); NTSYSAPI NTSTATUS WINAPI NtDebugContinue(HANDLE,CLIENT_ID*,NTSTATUS); NTSYSAPI NTSTATUS WINAPI NtDelayExecution(BOOLEAN,const LARGE_INTEGER*); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Add support for clients to connect to LPC ports and servers to listen for connection requests: - Add lpc_message structure for internal message handling - Add global_pending_connects list to track pending connections - Add connect_lpc_port handler to create client ports and queue connection requests - Add listen_lpc_port handler to retrieve pending connection requests The connection flow works as follows: 1. Client calls connect_lpc_port which creates a client port and queues a connection request message on the server port 2. Server calls listen_lpc_port to receive connection request details 3. Server will accept/reject with accept_lpc_connect (next commit) --- server/lpc_port.c | 271 +++++++++++++++++++++++++++++++++++++++++++- server/protocol.def | 26 +++++ 2 files changed, 295 insertions(+), 2 deletions(-) diff --git a/server/lpc_port.c b/server/lpc_port.c index 3c4ef23a4fb..a6f2649c424 100644 --- a/server/lpc_port.c +++ b/server/lpc_port.c @@ -44,12 +44,23 @@ /* Port types */ #define PORT_TYPE_SERVER 0x01 /* Named port that server listens on */ +#define PORT_TYPE_CLIENT 0x02 /* Client's end of connection */ /* Port flags */ #define PORT_FLAG_WAITABLE 0x0001 +/* LPC message types */ +#define LPC_CONNECTION_REQUEST 10 + /* Maximum message size */ #define MAX_LPC_MESSAGE_SIZE 0x40000 +#define MAX_LPC_DATA_SIZE 0x100000 + +/* Global counter for generating unique message IDs */ +static unsigned int global_msg_id_counter = 0; + +/* Global list of pending connection requests */ +static struct list global_pending_connects = LIST_INIT(global_pending_connects); static const WCHAR lpc_port_name[] = {'L','P','C',' ','P','o','r','t'}; @@ -65,18 +76,40 @@ struct type_descr lpc_port_type = }, }; +/* Internal message structure */ +struct lpc_message +{ + struct list entry; /* queue entry */ + struct list global_entry; /* entry in global_pending_connects */ + struct lpc_port *sender_port; /* port that sent this message */ + struct lpc_port *server_port; /* server port (for connection requests) */ + struct thread *sender_thread; /* thread that sent this message */ + unsigned int msg_id; /* unique message ID */ + unsigned int msg_type; /* LPC message type */ + process_id_t client_pid; /* sender's process ID */ + thread_id_t client_tid; /* sender's thread ID */ + data_size_t data_size; /* size of message data */ + char data[1]; /* variable-length message data */ +}; + /* LPC port object */ struct lpc_port { struct object obj; /* object header */ unsigned int port_type; /* PORT_TYPE_* */ unsigned int flags; /* PORT_FLAG_* */ + struct lpc_port *connection_port; /* reference to connection port */ + struct lpc_port *connected_port; /* paired port: client <-> channel */ struct list msg_queue; /* list of pending messages */ + struct list pending_connects;/* list of pending connection messages */ struct object *queue_event; /* event signaled when message arrives */ unsigned int max_msg_len; /* maximum message length */ unsigned int max_connect_info;/* maximum connection info length */ struct object *wait_event; /* event for WaitForSingleObject (waitable ports) */ struct process *server_process; /* server process (for named ports) */ + struct thread *client_thread; /* client thread (for NtCompleteConnectPort) */ + struct object *connect_event; /* event signaled when connection completes */ + unsigned int connect_status; /* STATUS_SUCCESS or error code from accept */ }; static void lpc_port_dump( struct object *obj, int verbose ); @@ -108,6 +141,58 @@ static const struct object_ops lpc_port_ops = lpc_port_destroy /* destroy */ }; +/* Allocate a new message with the given data size */ +static struct lpc_message *alloc_lpc_message( data_size_t data_size ) +{ + struct lpc_message *msg; + data_size_t alloc_size; + + if (data_size > MAX_LPC_DATA_SIZE) + { + set_error( STATUS_INVALID_PARAMETER ); + return NULL; + } + + alloc_size = max( sizeof(struct lpc_message), offsetof(struct lpc_message, data) + data_size ); + msg = mem_alloc( alloc_size ); + if (msg) + { + memset( msg, 0, alloc_size ); + list_init( &msg->global_entry ); + msg->data_size = data_size; + } + return msg; +} + +/* Free a message */ +static void free_lpc_message( struct lpc_message *msg ) +{ + if (msg) + { + if (!list_empty( &msg->global_entry )) + list_remove( &msg->global_entry ); + if (msg->sender_port) release_object( msg->sender_port ); + if (msg->server_port) release_object( msg->server_port ); + if (msg->sender_thread) release_object( msg->sender_thread ); + free( msg ); + } +} + +/* Get the next globally unique message ID */ +static unsigned int get_next_msg_id( void ) +{ + return ++global_msg_id_counter; +} + +/* Signal the port's queue event to wake waiting threads */ +static void signal_port_queue( struct lpc_port *port ) +{ + if (port->queue_event) + signal_sync( port->queue_event ); + if (port->wait_event) + signal_sync( port->wait_event ); +} + static struct lpc_port *create_lpc_port( struct object *root, const struct unicode_str *name, unsigned int attr, unsigned int flags, unsigned int max_msg_len, unsigned int max_connect_info, @@ -126,12 +211,18 @@ static struct lpc_port *create_lpc_port( struct object *root, const struct unico { port->port_type = PORT_TYPE_SERVER; port->flags = flags; + port->connection_port = (struct lpc_port *)grab_object( port ); + port->connected_port = NULL; list_init( &port->msg_queue ); + list_init( &port->pending_connects ); port->queue_event = create_internal_sync( 0, 0 ); port->max_msg_len = max_msg_len ? max_msg_len : MAX_LPC_MESSAGE_SIZE; port->max_connect_info = max_connect_info ? max_connect_info : 256; port->wait_event = NULL; port->server_process = (struct process *)grab_object( current->process ); + port->client_thread = NULL; + port->connect_event = NULL; + port->connect_status = STATUS_PENDING; if (!port->queue_event) { @@ -153,19 +244,67 @@ static struct lpc_port *create_lpc_port( struct object *root, const struct unico return port; } +/* Create a client port (internal, no name) */ +static struct lpc_port *create_port_internal( unsigned int port_type, struct lpc_port *connection_port ) +{ + struct lpc_port *port; + + port = alloc_object( &lpc_port_ops ); + if (!port) return NULL; + + port->port_type = port_type; + port->flags = 0; + port->connection_port = (struct lpc_port *)grab_object( connection_port ); + port->connected_port = NULL; + list_init( &port->msg_queue ); + list_init( &port->pending_connects ); + port->queue_event = create_internal_sync( 0, 0 ); + port->max_msg_len = connection_port->max_msg_len; + port->max_connect_info = connection_port->max_connect_info; + port->wait_event = NULL; + port->server_process = NULL; + port->client_thread = NULL; + port->connect_event = NULL; + port->connect_status = STATUS_PENDING; + + if (port_type == PORT_TYPE_CLIENT) + { + port->connect_event = (struct object *)create_server_internal_sync( 1, 0 ); + if (!port->connect_event) + { + release_object( port ); + return NULL; + } + } + + if (!port->queue_event) + { + release_object( port ); + return NULL; + } + + return port; +} + static void lpc_port_dump( struct object *obj, int verbose ) { struct lpc_port *port = (struct lpc_port *)obj; + static const char *type_names[] = { "???", "SERVER", "CLIENT", "CHANNEL" }; + const char *type_name = port->port_type < 4 ? type_names[port->port_type] : "???"; assert( obj->ops == &lpc_port_ops ); fprintf( stderr, "LPC Port type=%s flags=%04x max_msg=%u max_connect=%u\n", - port->port_type == PORT_TYPE_SERVER ? "SERVER" : "?", - port->flags, port->max_msg_len, port->max_connect_info ); + type_name, port->flags, port->max_msg_len, port->max_connect_info ); } static struct object *lpc_port_get_sync( struct object *obj ) { struct lpc_port *port = (struct lpc_port *)obj; + assert( obj->ops == &lpc_port_ops ); + + /* For clients with a connect_event, return it for connection wait */ + if (port->port_type == PORT_TYPE_CLIENT && port->connect_event) + return grab_object( port->connect_event ); if (port->wait_event) return grab_object( port->wait_event ); @@ -179,12 +318,31 @@ static struct object *lpc_port_get_sync( struct object *obj ) static void lpc_port_destroy( struct object *obj ) { struct lpc_port *port = (struct lpc_port *)obj; + struct lpc_message *msg, *next_msg; assert( obj->ops == &lpc_port_ops ); + LIST_FOR_EACH_ENTRY_SAFE( msg, next_msg, &port->msg_queue, struct lpc_message, entry ) + { + list_remove( &msg->entry ); + free_lpc_message( msg ); + } + + LIST_FOR_EACH_ENTRY_SAFE( msg, next_msg, &port->pending_connects, struct lpc_message, entry ) + { + list_remove( &msg->entry ); + free_lpc_message( msg ); + } + if (port->queue_event) release_object( port->queue_event ); if (port->wait_event) release_object( port->wait_event ); + if (port->connect_event) release_object( port->connect_event ); + if (port->connection_port && port->connection_port != port) + release_object( port->connection_port ); + if (port->connected_port && port->connected_port != port) + release_object( port->connected_port ); if (port->server_process) release_object( port->server_process ); + if (port->client_thread) release_object( port->client_thread ); } /* Create an LPC port */ @@ -211,3 +369,112 @@ DECL_HANDLER(create_lpc_port) if (root) release_object( root ); } + +/* Connect to an LPC port */ +DECL_HANDLER(connect_lpc_port) +{ + struct lpc_port *connection_port; + struct lpc_port *client_port; + struct lpc_message *msg; + struct unicode_str name; + struct object *root; + const struct security_descriptor *sd; + const struct object_attributes *objattr = get_req_object_attributes( &sd, &name, &root ); + data_size_t info_size = req->info_size; + + if (!objattr) return; + + connection_port = (struct lpc_port *)open_named_object( root, &lpc_port_ops, &name, objattr->attributes ); + if (root) release_object( root ); + + if (!connection_port) + { + set_error( STATUS_OBJECT_NAME_NOT_FOUND ); + return; + } + + if (connection_port->port_type != PORT_TYPE_SERVER) + { + set_error( STATUS_INVALID_PORT_HANDLE ); + release_object( connection_port ); + return; + } + + /* Create client port */ + client_port = create_port_internal( PORT_TYPE_CLIENT, connection_port ); + if (!client_port) + { + release_object( connection_port ); + return; + } + + /* Create connection request message */ + msg = alloc_lpc_message( info_size ); + if (!msg) + { + release_object( client_port ); + release_object( connection_port ); + return; + } + + msg->msg_id = get_next_msg_id(); + msg->msg_type = LPC_CONNECTION_REQUEST; + msg->sender_port = (struct lpc_port *)grab_object( client_port ); + msg->server_port = (struct lpc_port *)grab_object( connection_port ); + msg->sender_thread = (struct thread *)grab_object( current ); + msg->client_pid = current->process->id; + msg->client_tid = current->id; + if (info_size) memcpy( msg->data, get_req_data(), info_size ); + + /* Queue on server's pending_connects list and global list */ + list_add_tail( &connection_port->pending_connects, &msg->entry ); + list_add_tail( &global_pending_connects, &msg->global_entry ); + + /* Signal server that connection request is pending */ + signal_port_queue( connection_port ); + + /* Return handle to client port */ + reply->handle = alloc_handle_no_access_check( current->process, client_port, + req->access, objattr->attributes ); + release_object( client_port ); + release_object( connection_port ); +} + +/* Listen for connection requests */ +DECL_HANDLER(listen_lpc_port) +{ + struct lpc_port *port; + struct lpc_message *msg; + + port = (struct lpc_port *)get_handle_obj( current->process, req->handle, + 0, &lpc_port_ops ); + if (!port) return; + + if (port->port_type != PORT_TYPE_SERVER) + { + set_error( STATUS_INVALID_PORT_HANDLE ); + release_object( port ); + return; + } + + /* Get first pending connection request */ + if (list_empty( &port->pending_connects )) + { + set_error( STATUS_PENDING ); + release_object( port ); + return; + } + + msg = LIST_ENTRY( list_head( &port->pending_connects ), struct lpc_message, entry ); + + reply->msg_size = msg->data_size; + reply->client_pid = msg->client_pid; + reply->client_tid = msg->client_tid; + reply->msg_id = msg->msg_id; + reply->message = 0; + + if (msg->data_size) + set_reply_data( msg->data, min( msg->data_size, get_reply_max_size() ) ); + + release_object( port ); +} diff --git a/server/protocol.def b/server/protocol.def index 3bbab48c873..f611d0ebbb0 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -4309,3 +4309,29 @@ enum inproc_sync_type @REPLY obj_handle_t handle; /* port handle */ @END + + +/* Connect to an LPC port */ +@REQ(connect_lpc_port) + unsigned int access; /* desired access rights */ + data_size_t info_size; /* size of connection info */ + VARARG(objattr,object_attributes);/* object attributes */ + VARARG(info,bytes); /* connection info data */ +@REPLY + obj_handle_t handle; /* handle to client port */ + data_size_t info_size; /* size of returned info */ + VARARG(info,bytes); /* returned connection info */ +@END + + +/* Listen for connection requests */ +@REQ(listen_lpc_port) + obj_handle_t handle; /* handle to server port */ +@REPLY + client_ptr_t message; /* message pointer (unused) */ + data_size_t msg_size; /* size of connection info */ + process_id_t client_pid; /* client process ID */ + thread_id_t client_tid; /* client thread ID */ + unsigned int msg_id; /* message ID for accept */ + VARARG(info,bytes); /* connection info data */ +@END -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Add server-side handlers for accepting connections and completing the handshake: - accept_lpc_connect: Accept or reject a pending connection request and create a communication channel port - complete_lpc_connect: Signal the client that connection is complete - get_lpc_connect_status: Allow client to query connection result This implements the server side of NtAcceptConnectPort, NtCompleteConnectPort, and supports NtConnectPort completion. --- server/lpc_port.c | 132 ++++++++++++++++++++++++++++++++++++++++++++ server/protocol.def | 26 +++++++++ 2 files changed, 158 insertions(+) diff --git a/server/lpc_port.c b/server/lpc_port.c index a6f2649c424..c80d932a776 100644 --- a/server/lpc_port.c +++ b/server/lpc_port.c @@ -45,6 +45,7 @@ /* Port types */ #define PORT_TYPE_SERVER 0x01 /* Named port that server listens on */ #define PORT_TYPE_CLIENT 0x02 /* Client's end of connection */ +#define PORT_TYPE_CHANNEL 0x03 /* Server's per-client communication channel */ /* Port flags */ #define PORT_FLAG_WAITABLE 0x0001 @@ -107,6 +108,7 @@ struct lpc_port unsigned int max_connect_info;/* maximum connection info length */ struct object *wait_event; /* event for WaitForSingleObject (waitable ports) */ struct process *server_process; /* server process (for named ports) */ + client_ptr_t port_context; /* user-defined port context */ struct thread *client_thread; /* client thread (for NtCompleteConnectPort) */ struct object *connect_event; /* event signaled when connection completes */ unsigned int connect_status; /* STATUS_SUCCESS or error code from accept */ @@ -220,6 +222,7 @@ static struct lpc_port *create_lpc_port( struct object *root, const struct unico port->max_connect_info = max_connect_info ? max_connect_info : 256; port->wait_event = NULL; port->server_process = (struct process *)grab_object( current->process ); + port->port_context = 0; port->client_thread = NULL; port->connect_event = NULL; port->connect_status = STATUS_PENDING; @@ -263,6 +266,7 @@ static struct lpc_port *create_port_internal( unsigned int port_type, struct lpc port->max_connect_info = connection_port->max_connect_info; port->wait_event = NULL; port->server_process = NULL; + port->port_context = 0; port->client_thread = NULL; port->connect_event = NULL; port->connect_status = STATUS_PENDING; @@ -478,3 +482,131 @@ DECL_HANDLER(listen_lpc_port) release_object( port ); } + +/* Find a pending connection message by message ID */ +static struct lpc_message *find_pending_connect_global( unsigned int msg_id ) +{ + struct lpc_message *msg; + + LIST_FOR_EACH_ENTRY( msg, &global_pending_connects, struct lpc_message, global_entry ) + { + if (msg->msg_id == msg_id) + return msg; + } + return NULL; +} + +/* Accept or reject a connection */ +DECL_HANDLER(accept_lpc_connect) +{ + struct lpc_port *connection_port; + struct lpc_port *comm_port = NULL; + struct lpc_port *client_port; + struct lpc_message *msg; + + msg = find_pending_connect_global( req->msg_id ); + if (!msg) + { + set_error( STATUS_INVALID_CID ); + return; + } + + connection_port = msg->server_port; + if (!connection_port || connection_port->port_type != PORT_TYPE_SERVER) + { + set_error( STATUS_INVALID_PORT_HANDLE ); + return; + } + + client_port = msg->sender_port; + + /* Remove from port's pending list */ + list_remove( &msg->entry ); + + if (req->accept) + { + comm_port = create_port_internal( PORT_TYPE_CHANNEL, connection_port ); + if (!comm_port) + { + free_lpc_message( msg ); + return; + } + + comm_port->connected_port = (struct lpc_port *)grab_object( client_port ); + client_port->connected_port = (struct lpc_port *)grab_object( comm_port ); + client_port->connect_status = STATUS_SUCCESS; + comm_port->port_context = req->context; + + if (msg->sender_thread) + comm_port->client_thread = (struct thread *)grab_object( msg->sender_thread ); + + reply->handle = alloc_handle_no_access_check( current->process, comm_port, + PORT_ALL_ACCESS, 0 ); + release_object( comm_port ); + } + else + { + client_port->connect_status = STATUS_PORT_CONNECTION_REFUSED; + if (client_port->connect_event) + signal_sync( client_port->connect_event ); + reply->handle = 0; + } + + free_lpc_message( msg ); +} + +/* Complete the connection (wake the client) */ +DECL_HANDLER(complete_lpc_connect) +{ + struct lpc_port *port; + struct lpc_port *client_port; + + port = (struct lpc_port *)get_handle_obj( current->process, req->handle, + PORT_CONNECT, &lpc_port_ops ); + if (!port) return; + + if (port->port_type != PORT_TYPE_CHANNEL) + { + set_error( STATUS_INVALID_PORT_HANDLE ); + release_object( port ); + return; + } + + client_port = port->connected_port; + if (client_port) + { + /* Signal the connect_event to wake the client. */ + if (client_port->connect_event) + { + signal_sync( client_port->connect_event ); + } + } + + if (port->client_thread) + { + release_object( port->client_thread ); + port->client_thread = NULL; + } + + release_object( port ); +} + +/* Get connection status for client port */ +DECL_HANDLER(get_lpc_connect_status) +{ + struct lpc_port *port; + + port = (struct lpc_port *)get_handle_obj( current->process, req->handle, + PORT_CONNECT, &lpc_port_ops ); + if (!port) return; + + if (port->port_type != PORT_TYPE_CLIENT) + { + set_error( STATUS_INVALID_PORT_HANDLE ); + release_object( port ); + return; + } + + reply->status = port->connect_status; + release_object( port ); +} diff --git a/server/protocol.def b/server/protocol.def index f611d0ebbb0..8ca76636faa 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -4335,3 +4335,29 @@ enum inproc_sync_type unsigned int msg_id; /* message ID for accept */ VARARG(info,bytes); /* connection info data */ @END + + +/* Accept or reject an LPC connection */ +@REQ(accept_lpc_connect) + obj_handle_t handle; /* handle (unused, connection found by msg_id) */ + int accept; /* accept or reject */ + unsigned int msg_id; /* message ID from listen */ + client_ptr_t context; /* port context */ + VARARG(info,bytes); /* connection info to return */ +@REPLY + obj_handle_t handle; /* handle to communication port */ +@END + + +/* Complete the connection */ +@REQ(complete_lpc_connect) + obj_handle_t handle; /* handle to communication port */ +@END + + +/* Get connection status for client port */ +@REQ(get_lpc_connect_status) + obj_handle_t handle; /* handle to client port */ +@REPLY + unsigned int status; /* connection status */ +@END -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Implement client-side LPC port connection. The function connects to a named server port, waits for the server to accept/reject the connection, and returns a handle to the client port on success. NtSecureConnectPort is implemented as a wrapper around NtConnectPort with a FIXME for SID verification. --- dlls/ntdll/tests/port.c | 2 +- dlls/ntdll/unix/sync.c | 100 ++++++++++++++++++++++++++++++++++++---- dlls/wow64/sync.c | 23 ++++++--- 3 files changed, 109 insertions(+), 16 deletions(-) diff --git a/dlls/ntdll/tests/port.c b/dlls/ntdll/tests/port.c index 80c60d09683..0b7cd92d739 100644 --- a/dlls/ntdll/tests/port.c +++ b/dlls/ntdll/tests/port.c @@ -239,7 +239,7 @@ static DWORD WINAPI test_ports_client(LPVOID arg) sqos.EffectiveOnly = TRUE; status = pNtConnectPort(&PortHandle, &port, &sqos, 0, 0, &len, NULL, NULL); - todo_wine ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %lx\n", status); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %lx\n", status); if (status != STATUS_SUCCESS) return 1; status = pNtRegisterThreadTerminatePort(PortHandle); diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c index ede54e5944c..f741dbf2ce8 100644 --- a/dlls/ntdll/unix/sync.c +++ b/dlls/ntdll/unix/sync.c @@ -3136,23 +3136,105 @@ NTSTATUS WINAPI NtConnectPort( HANDLE *handle, UNICODE_STRING *name, SECURITY_QU LPC_SECTION_WRITE *write, LPC_SECTION_READ *read, ULONG *max_len, void *info, ULONG *info_len ) { - FIXME( "(%p,%s,%p,%p,%p,%p,%p,%p),stub!\n", handle, debugstr_us(name), qos, - write, read, max_len, info, info_len ); - if (info && info_len) TRACE("msg = %s\n", debugstr_an( info, *info_len )); - return STATUS_NOT_IMPLEMENTED; -} + unsigned int ret; + data_size_t len; + struct object_attributes *objattr; + OBJECT_ATTRIBUTES attr; + ULONG in_len = (info && info_len) ? *info_len : 0; + HANDLE port_handle; + + TRACE( "(%p,%s,%p,%p,%p,%p,%p,%p)\n", handle, debugstr_us(name), qos, write, read, max_len, info, info_len ); + + if (write) + FIXME( "LPC_SECTION_WRITE not supported\n" ); + if (read) + FIXME( "LPC_SECTION_READ not supported\n" ); + + *handle = 0; + attr.Length = sizeof(attr); + attr.RootDirectory = 0; + attr.ObjectName = name; + attr.Attributes = 0; + attr.SecurityDescriptor = NULL; + attr.SecurityQualityOfService = qos; + + if ((ret = alloc_object_attributes( &attr, &objattr, &len ))) + return ret; + + SERVER_START_REQ( connect_lpc_port ) + { + req->access = PORT_ALL_ACCESS; + req->info_size = in_len; + wine_server_add_data( req, objattr, len ); + if (in_len) wine_server_add_data( req, info, in_len ); + if (!(ret = wine_server_call( req ))) + { + port_handle = wine_server_ptr_handle( reply->handle ); + if (info_len) + *info_len = reply->info_size; + } + } + SERVER_END_REQ; + free( objattr ); + + if (ret) return ret; + + /* Wait for the connection to be accepted/rejected by the server */ + for (;;) + { + unsigned int connect_status; + + SERVER_START_REQ( get_lpc_connect_status ) + { + req->handle = wine_server_obj_handle( port_handle ); + ret = wine_server_call( req ); + connect_status = reply->status; + } + SERVER_END_REQ; + + if (ret) + { + NtClose( port_handle ); + return ret; + } + + if (connect_status != STATUS_PENDING) + { + if (connect_status == STATUS_SUCCESS) + { + *handle = port_handle; + return STATUS_SUCCESS; + } + else + { + NtClose( port_handle ); + return connect_status; + } + } + + ret = NtWaitForSingleObject( port_handle, FALSE, NULL ); + if (ret) + { + NtClose( port_handle ); + return ret; + } + } +} /*********************************************************************** - * NtSecureConnectPort (NTDLL.@) + * NtReplyWaitReceivePort (NTDLL.@) */ NTSTATUS WINAPI NtSecureConnectPort( HANDLE *handle, UNICODE_STRING *name, SECURITY_QUALITY_OF_SERVICE *qos, LPC_SECTION_WRITE *write, PSID sid, LPC_SECTION_READ *read, ULONG *max_len, void *info, ULONG *info_len ) { - FIXME( "(%p,%s,%p,%p,%p,%p,%p,%p,%p),stub!\n", handle, debugstr_us(name), qos, - write, sid, read, max_len, info, info_len ); - return STATUS_NOT_IMPLEMENTED; + TRACE( "(%p,%s,%p,%p,%p,%p,%p,%p,%p)\n", handle, debugstr_us(name), qos, write, sid, read, max_len, info, info_len ); + + if (sid) + FIXME( "SID verification not implemented\n" ); + + return NtConnectPort( handle, name, qos, write, read, max_len, info, info_len ); } diff --git a/dlls/wow64/sync.c b/dlls/wow64/sync.c index 2f0a617b70c..f1ddfe5853d 100644 --- a/dlls/wow64/sync.c +++ b/dlls/wow64/sync.c @@ -205,9 +205,15 @@ NTSTATUS WINAPI wow64_NtConnectPort( UINT *args ) void *info = get_ptr( &args ); ULONG *info_len = get_ptr( &args ); - FIXME( "%p %p %p %p %p %p %p %p: stub\n", - handle_ptr, name32, qos, write, read, max_len, info, info_len ); - return STATUS_NOT_IMPLEMENTED; + UNICODE_STRING name; + HANDLE handle = 0; + NTSTATUS status; + + unicode_str_32to64( &name, name32 ); + + status = NtConnectPort( &handle, &name, qos, write, read, max_len, info, info_len ); + put_handle( handle_ptr, handle ); + return status; } @@ -1395,9 +1401,14 @@ NTSTATUS WINAPI wow64_NtSecureConnectPort( UINT *args ) void *info = get_ptr( &args ); ULONG *info_len = get_ptr( &args ); - FIXME( "%p %p %p %p %p %p %p %p %p: stub\n", - handle_ptr, name32, qos, write, sid, read, max_len, info, info_len ); - return STATUS_NOT_IMPLEMENTED; + UNICODE_STRING name; + HANDLE handle = 0; + NTSTATUS status; + + status = NtSecureConnectPort( &handle, unicode_str_32to64( &name, name32 ), + qos, write, sid, read, max_len, info, info_len ); + put_handle( handle_ptr, handle ); + return status; } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Implement server-side LPC connection handling: - NtListenPort: Wait for incoming connection requests on a server port - NtAcceptConnectPort: Accept or reject a connection and create a communication port - NtCompleteConnectPort: Signal the client that connection is complete --- dlls/ntdll/unix/sync.c | 70 ++++++++++++++++++++++++++++++++++++++---- dlls/wow64/sync.c | 11 ++++--- 2 files changed, 71 insertions(+), 10 deletions(-) diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c index f741dbf2ce8..4dad1b8a8e8 100644 --- a/dlls/ntdll/unix/sync.c +++ b/dlls/ntdll/unix/sync.c @@ -3243,8 +3243,37 @@ NTSTATUS WINAPI NtSecureConnectPort( HANDLE *handle, UNICODE_STRING *name, SECUR */ NTSTATUS WINAPI NtListenPort( HANDLE handle, LPC_MESSAGE *msg ) { - FIXME("(%p,%p),stub!\n", handle, msg ); - return STATUS_NOT_IMPLEMENTED; + unsigned int ret; + + TRACE( "(%p,%p)\n", handle, msg ); + + for (;;) + { + SERVER_START_REQ( listen_lpc_port ) + { + req->handle = wine_server_obj_handle( handle ); + wine_server_set_reply( req, msg ? msg->Data : NULL, msg ? 0x1000 : 0 ); + ret = wine_server_call( req ); + if (!ret && msg) + { + msg->DataSize = reply->msg_size; + msg->MessageSize = sizeof(*msg) + reply->msg_size; + msg->MessageType = 10; /* LPC_CONNECTION_REQUEST */ + msg->VirtualRangesOffset = 0; + msg->ClientId.UniqueProcess = ULongToHandle( reply->client_pid ); + msg->ClientId.UniqueThread = ULongToHandle( reply->client_tid ); + msg->MessageId = reply->msg_id; + msg->SectionSize = 0; + } + } + SERVER_END_REQ; + + if (ret != STATUS_PENDING) break; + + ret = NtWaitForSingleObject( handle, FALSE, NULL ); + if (ret) break; + } + return ret; } @@ -3254,8 +3283,28 @@ NTSTATUS WINAPI NtListenPort( HANDLE handle, LPC_MESSAGE *msg ) NTSTATUS WINAPI NtAcceptConnectPort( HANDLE *handle, ULONG id, LPC_MESSAGE *msg, BOOLEAN accept, LPC_SECTION_WRITE *write, LPC_SECTION_READ *read ) { - FIXME("(%p,%u,%p,%d,%p,%p),stub!\n", handle, id, msg, accept, write, read ); - return STATUS_NOT_IMPLEMENTED; + unsigned int ret; + + TRACE( "(%p,%u,%p,%d,%p,%p)\n", handle, id, msg, accept, write, read ); + + if (write) + FIXME( "LPC_SECTION_WRITE not supported\n" ); + if (read) + FIXME( "LPC_SECTION_READ not supported\n" ); + + *handle = 0; + + SERVER_START_REQ( accept_lpc_connect ) + { + req->handle = 0; + req->accept = accept; + req->msg_id = msg ? msg->MessageId : 0; + req->context = id; + if (!(ret = wine_server_call( req )) && accept) + *handle = wine_server_ptr_handle( reply->handle ); + } + SERVER_END_REQ; + return ret; } @@ -3264,8 +3313,17 @@ NTSTATUS WINAPI NtAcceptConnectPort( HANDLE *handle, ULONG id, LPC_MESSAGE *msg, */ NTSTATUS WINAPI NtCompleteConnectPort( HANDLE handle ) { - FIXME( "(%p),stub!\n", handle ); - return STATUS_NOT_IMPLEMENTED; + unsigned int ret; + + TRACE( "(%p)\n", handle ); + + SERVER_START_REQ( complete_lpc_connect ) + { + req->handle = wine_server_obj_handle( handle ); + ret = wine_server_call( req ); + } + SERVER_END_REQ; + return ret; } diff --git a/dlls/wow64/sync.c b/dlls/wow64/sync.c index f1ddfe5853d..fad6e1ca304 100644 --- a/dlls/wow64/sync.c +++ b/dlls/wow64/sync.c @@ -140,8 +140,12 @@ NTSTATUS WINAPI wow64_NtAcceptConnectPort( UINT *args ) LPC_SECTION_WRITE *write = get_ptr( &args ); LPC_SECTION_READ *read = get_ptr( &args ); - FIXME( "%p %lu %p %u %p %p: stub\n", handle_ptr, id, msg, accept, write, read ); - return STATUS_NOT_IMPLEMENTED; + HANDLE handle = 0; + NTSTATUS status; + + status = NtAcceptConnectPort( &handle, id, msg, accept, write, read ); + put_handle( handle_ptr, handle ); + return status; } @@ -569,8 +573,7 @@ NTSTATUS WINAPI wow64_NtListenPort( UINT *args ) HANDLE handle = get_handle( &args ); LPC_MESSAGE *msg = get_ptr( &args ); - FIXME( "%p %p: stub\n", handle, msg ); - return STATUS_NOT_IMPLEMENTED; + return NtListenPort( handle, msg ); } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Add server-side handlers for sending and receiving LPC messages: - request_lpc_reply: Send a request message through a port and track it for reply correlation - reply_wait_receive_lpc: Receive the next message from a port and optionally send a reply to a previous request Also adds tracking for pending requests to route replies back to the correct client port. --- server/lpc_port.c | 223 ++++++++++++++++++++++++++++++++++++++++++++ server/protocol.def | 29 ++++++ 2 files changed, 252 insertions(+) diff --git a/server/lpc_port.c b/server/lpc_port.c index c80d932a776..56723282a7f 100644 --- a/server/lpc_port.c +++ b/server/lpc_port.c @@ -51,6 +51,9 @@ #define PORT_FLAG_WAITABLE 0x0001 /* LPC message types */ +#define LPC_REQUEST 1 +#define LPC_REPLY 2 +#define LPC_DATAGRAM 3 #define LPC_CONNECTION_REQUEST 10 /* Maximum message size */ @@ -63,6 +66,17 @@ static unsigned int global_msg_id_counter = 0; /* Global list of pending connection requests */ static struct list global_pending_connects = LIST_INIT(global_pending_connects); +/* Global list of pending requests awaiting replies */ +static struct list global_pending_requests = LIST_INIT(global_pending_requests); + +/* Pending request tracking for request/reply correlation */ +struct pending_request +{ + struct list entry; /* entry in global_pending_requests */ + unsigned int msg_id; /* message ID waiting for reply */ + struct lpc_port *client_port; /* client port to deliver reply to */ +}; + static const WCHAR lpc_port_name[] = {'L','P','C',' ','P','o','r','t'}; struct type_descr lpc_port_type = @@ -89,6 +103,7 @@ struct lpc_message unsigned int msg_type; /* LPC message type */ process_id_t client_pid; /* sender's process ID */ thread_id_t client_tid; /* sender's thread ID */ + client_ptr_t port_context; /* port context for this message */ data_size_t data_size; /* size of message data */ char data[1]; /* variable-length message data */ }; @@ -195,6 +210,48 @@ static void signal_port_queue( struct lpc_port *port ) signal_sync( port->wait_event ); } +/* Reset the port's queue event after receiving a message */ +static void reset_port_queue( struct lpc_port *port ) +{ + if (list_empty( &port->msg_queue ) && list_empty( &port->pending_connects )) + { + if (port->queue_event) + reset_sync( port->queue_event ); + if (port->wait_event) + reset_sync( port->wait_event ); + } +} + +/* Track a pending request awaiting reply */ +static void track_pending_request( unsigned int msg_id, struct lpc_port *client_port ) +{ + struct pending_request *pr = mem_alloc( sizeof(*pr) ); + if (pr) + { + pr->msg_id = msg_id; + pr->client_port = (struct lpc_port *)grab_object( client_port ); + list_add_tail( &global_pending_requests, &pr->entry ); + } +} + +/* Find and remove a pending request by message ID */ +static struct lpc_port *find_pending_request_client( unsigned int msg_id ) +{ + struct pending_request *pr; + + LIST_FOR_EACH_ENTRY( pr, &global_pending_requests, struct pending_request, entry ) + { + if (pr->msg_id == msg_id) + { + struct lpc_port *client = pr->client_port; + list_remove( &pr->entry ); + free( pr ); + return client; + } + } + return NULL; +} + static struct lpc_port *create_lpc_port( struct object *root, const struct unicode_str *name, unsigned int attr, unsigned int flags, unsigned int max_msg_len, unsigned int max_connect_info, @@ -610,3 +667,169 @@ DECL_HANDLER(get_lpc_connect_status) reply->status = port->connect_status; release_object( port ); } + +/* Send a request message and get a message ID for tracking the reply */ +DECL_HANDLER(request_lpc_reply) +{ + struct lpc_port *port; + struct lpc_port *target_port; + struct lpc_message *msg; + data_size_t data_size = get_req_data_size(); + + port = (struct lpc_port *)get_handle_obj( current->process, req->handle, + PORT_CONNECT, &lpc_port_ops ); + if (!port) return; + + if (port->port_type == PORT_TYPE_CLIENT) + { + if (!port->connected_port || !port->connected_port->connection_port) + { + set_error( STATUS_PORT_DISCONNECTED ); + release_object( port ); + return; + } + target_port = port->connected_port->connection_port; + } + else if (port->port_type == PORT_TYPE_CHANNEL) + { + if (!port->connected_port) + { + set_error( STATUS_PORT_DISCONNECTED ); + release_object( port ); + return; + } + target_port = port->connected_port; + } + else + { + set_error( STATUS_INVALID_PORT_HANDLE ); + release_object( port ); + return; + } + + msg = alloc_lpc_message( data_size ); + if (!msg) + { + release_object( port ); + return; + } + + msg->sender_port = (struct lpc_port *)grab_object( port ); + msg->sender_thread = (struct thread *)grab_object( current ); + msg->msg_id = get_next_msg_id(); + msg->msg_type = req->msg_type ? req->msg_type : LPC_REQUEST; + msg->client_pid = current->process->id; + msg->client_tid = current->id; + msg->port_context = port->port_context; + if (data_size) + memcpy( msg->data, get_req_data(), data_size ); + + if (msg->msg_type == LPC_REQUEST && port->port_type == PORT_TYPE_CLIENT) + track_pending_request( msg->msg_id, port ); + + list_add_tail( &target_port->msg_queue, &msg->entry ); + signal_port_queue( target_port ); + + reply->msg_id = msg->msg_id; + + release_object( port ); +} + +/* Receive a message and optionally reply to a previous message */ +DECL_HANDLER(reply_wait_receive_lpc) +{ + struct lpc_port *port; + struct lpc_port *receive_port; + struct lpc_message *msg; + data_size_t reply_size = get_req_data_size(); + + port = (struct lpc_port *)get_handle_obj( current->process, req->handle, + PORT_CONNECT, &lpc_port_ops ); + if (!port) return; + + /* Handle reply to previous message */ + if (req->reply_msg_id) + { + struct lpc_port *client_port; + struct lpc_message *reply_msg; + + client_port = find_pending_request_client( req->reply_msg_id ); + if (client_port) + { + reply_msg = alloc_lpc_message( reply_size ); + if (reply_msg) + { + reply_msg->msg_type = LPC_REPLY; + reply_msg->msg_id = req->reply_msg_id; + reply_msg->client_pid = current->process->id; + reply_msg->client_tid = current->id; + reply_msg->data_size = reply_size; + if (reply_size) + memcpy( reply_msg->data, get_req_data(), reply_size ); + + list_add_tail( &client_port->msg_queue, &reply_msg->entry ); + signal_port_queue( client_port ); + } + release_object( client_port ); + } + } + + if (port->port_type == PORT_TYPE_CHANNEL || port->port_type == PORT_TYPE_CLIENT) + receive_port = port; + else if (port->port_type == PORT_TYPE_SERVER) + receive_port = port; + else + { + set_error( STATUS_INVALID_PORT_HANDLE ); + release_object( port ); + return; + } + + if (list_empty( &receive_port->msg_queue )) + { + if (port->port_type == PORT_TYPE_SERVER && !list_empty( &port->pending_connects )) + { + msg = LIST_ENTRY( list_head( &port->pending_connects ), struct lpc_message, entry ); + list_remove( &msg->entry ); + + reply->msg_id = msg->msg_id; + reply->msg_type = msg->msg_type; + reply->client_pid = msg->client_pid; + reply->client_tid = msg->client_tid; + reply->context = msg->port_context; + reply->data_size = msg->data_size; + + if (msg->data_size) + set_reply_data( msg->data, min( msg->data_size, get_reply_max_size() ) ); + + reset_port_queue( receive_port ); + release_object( port ); + return; + } + else + { + set_error( STATUS_PENDING ); + release_object( port ); + return; + } + } + else + { + msg = LIST_ENTRY( list_head( &receive_port->msg_queue ), struct lpc_message, entry ); + list_remove( &msg->entry ); + } + + reply->msg_id = msg->msg_id; + reply->msg_type = msg->msg_type; + reply->client_pid = msg->client_pid; + reply->client_tid = msg->client_tid; + reply->context = msg->port_context; + reply->data_size = msg->data_size; + + if (msg->data_size) + set_reply_data( msg->data, min( msg->data_size, get_reply_max_size() ) ); + + free_lpc_message( msg ); + reset_port_queue( receive_port ); + release_object( port ); +} diff --git a/server/protocol.def b/server/protocol.def index 8ca76636faa..46f11a71b3b 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -4361,3 +4361,32 @@ enum inproc_sync_type @REPLY unsigned int status; /* connection status */ @END + + +/* Send request and wait for reply */ +@REQ(request_lpc_reply) + obj_handle_t handle; /* port handle */ + data_size_t data_size; /* size of message data */ + unsigned int msg_type; /* message type */ + VARARG(data,bytes); /* message data */ +@REPLY + unsigned int msg_id; /* assigned message ID */ +@END + + +/* Wait for message and reply to previous */ +@REQ(reply_wait_receive_lpc) + obj_handle_t handle; /* port handle */ + unsigned int reply_msg_id; /* message ID to reply to (0 for no reply) */ + data_size_t reply_size; /* size of reply data */ + timeout_t timeout; /* timeout (unused currently) */ + VARARG(reply,bytes); /* reply data */ +@REPLY + unsigned int msg_id; /* received message ID */ + unsigned int msg_type; /* message type */ + process_id_t client_pid; /* sender's process ID */ + thread_id_t client_tid; /* sender's thread ID */ + client_ptr_t context; /* port context */ + data_size_t data_size; /* size of message data */ + VARARG(data,bytes); /* message data */ +@END -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Implement client-side LPC message sending: - NtRequestPort: Send a datagram message - NtRequestWaitReplyPort: Send a request message and wait for a reply NtRequestWaitReplyPort loops until a reply is received, waiting on the port for message availability. --- dlls/ntdll/ntdll.spec | 4 +- dlls/ntdll/signal_arm64ec.c | 1 + dlls/ntdll/unix/sync.c | 91 ++++++++++++++++++++++++++++++++++--- dlls/wow64/sync.c | 18 ++++++-- 4 files changed, 101 insertions(+), 13 deletions(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 24d6dc99f2b..2f8129efcaf 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -376,7 +376,7 @@ @ stdcall -syscall=0x000b NtReplyWaitReceivePort(ptr ptr ptr ptr) @ stdcall -syscall=0x002b NtReplyWaitReceivePortEx(long ptr ptr ptr ptr) # @ stub NtReplyWaitReplyPort -# @ stub NtRequestPort +@ stdcall -syscall NtRequestPort(ptr ptr) @ stdcall -syscall=0x0022 NtRequestWaitReplyPort(ptr ptr ptr) @ stdcall -syscall NtResetEvent(long ptr) @ stdcall -syscall NtResetWriteWatch(long ptr long) @@ -1454,7 +1454,7 @@ @ stdcall -private ZwReplyWaitReceivePort(ptr ptr ptr ptr) NtReplyWaitReceivePort @ stdcall -private ZwReplyWaitReceivePortEx(long ptr ptr ptr ptr) NtReplyWaitReceivePortEx # @ stub ZwReplyWaitReplyPort -# @ stub ZwRequestPort +@ stdcall -private ZwRequestPort(ptr ptr) NtRequestPort @ stdcall -private ZwRequestWaitReplyPort(ptr ptr ptr) NtRequestWaitReplyPort @ stdcall -private ZwResetEvent(long ptr) NtResetEvent @ stdcall -private ZwResetWriteWatch(long ptr long) NtResetWriteWatch diff --git a/dlls/ntdll/signal_arm64ec.c b/dlls/ntdll/signal_arm64ec.c index 2bd6014fdb2..a02aa021b50 100644 --- a/dlls/ntdll/signal_arm64ec.c +++ b/dlls/ntdll/signal_arm64ec.c @@ -547,6 +547,7 @@ DEFINE_SYSCALL(NtReplaceKey, (OBJECT_ATTRIBUTES *attr, HANDLE key, OBJECT_ATTRIB DEFINE_SYSCALL(NtReplyPort, (HANDLE handle, LPC_MESSAGE *reply)) DEFINE_SYSCALL(NtReplyWaitReceivePort, (HANDLE handle, ULONG *id, LPC_MESSAGE *reply, LPC_MESSAGE *msg)) DEFINE_SYSCALL(NtReplyWaitReceivePortEx, (HANDLE handle, ULONG *id, LPC_MESSAGE *reply, LPC_MESSAGE *msg, LARGE_INTEGER *timeout)) +DEFINE_SYSCALL(NtRequestPort, (HANDLE handle, LPC_MESSAGE *msg)) DEFINE_SYSCALL(NtRequestWaitReplyPort, (HANDLE handle, LPC_MESSAGE *msg_in, LPC_MESSAGE *msg_out)) DEFINE_SYSCALL(NtResetEvent, (HANDLE handle, LONG *prev_state)) DEFINE_SYSCALL(NtResetWriteWatch, (HANDLE process, PVOID base, SIZE_T size)) diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c index 4dad1b8a8e8..7a225ad0499 100644 --- a/dlls/ntdll/unix/sync.c +++ b/dlls/ntdll/unix/sync.c @@ -3363,13 +3363,90 @@ NTSTATUS WINAPI NtRegisterThreadTerminatePort( HANDLE handle ) */ NTSTATUS WINAPI NtRequestWaitReplyPort( HANDLE handle, LPC_MESSAGE *msg_in, LPC_MESSAGE *msg_out ) { - FIXME( "(%p,%p,%p),stub!\n", handle, msg_in, msg_out ); - if (msg_in) - TRACE("datasize %u msgsize %u type %u ranges %u client %p/%p msgid %lu size %lu data %s\n", - msg_in->DataSize, msg_in->MessageSize, msg_in->MessageType, msg_in->VirtualRangesOffset, - msg_in->ClientId.UniqueProcess, msg_in->ClientId.UniqueThread, msg_in->MessageId, - msg_in->SectionSize, debugstr_an( (const char *)msg_in->Data, msg_in->DataSize )); - return STATUS_NOT_IMPLEMENTED; + unsigned int ret; + USHORT data_size; + + TRACE( "(%p,%p,%p)\n", handle, msg_in, msg_out ); + + if (!msg_in || !msg_out) return STATUS_INVALID_PARAMETER; + + data_size = msg_in->DataSize; + + /* Send the request message */ + SERVER_START_REQ( request_lpc_reply ) + { + req->handle = wine_server_obj_handle( handle ); + req->data_size = data_size; + req->msg_type = 1; /* request */ + wine_server_add_data( req, msg_in->Data, data_size ); + ret = wine_server_call( req ); + } + SERVER_END_REQ; + + if (ret) return ret; + + /* Wait for and receive the reply */ + for (;;) + { + SERVER_START_REQ( reply_wait_receive_lpc ) + { + req->handle = wine_server_obj_handle( handle ); + req->reply_msg_id = 0; + req->reply_size = 0; + req->timeout = TIMEOUT_INFINITE; + /* Use a reasonable max size for LPC message data. + * sizeof(msg_out->Data) is just 1 due to ANYSIZE_ARRAY. */ + wine_server_set_reply( req, msg_out->Data, 0x1000 ); + ret = wine_server_call( req ); + if (!ret) + { + msg_out->DataSize = reply->data_size; + msg_out->MessageSize = sizeof(*msg_out) + reply->data_size; + msg_out->MessageType = reply->msg_type; + msg_out->VirtualRangesOffset = 0; + msg_out->ClientId.UniqueProcess = ULongToHandle( reply->client_pid ); + msg_out->ClientId.UniqueThread = ULongToHandle( reply->client_tid ); + msg_out->MessageId = reply->msg_id; + msg_out->SectionSize = 0; + } + } + SERVER_END_REQ; + + if (ret != STATUS_PENDING) break; + + /* Wait on port for message availability */ + ret = NtWaitForSingleObject( handle, FALSE, NULL ); + if (ret) break; + } + return ret; +} + + +/*********************************************************************** + * NtRequestPort (NTDLL.@) + */ +NTSTATUS WINAPI NtRequestPort( HANDLE handle, LPC_MESSAGE *msg ) +{ + unsigned int ret; + USHORT data_size; + + TRACE( "(%p,%p)\n", handle, msg ); + + if (!msg) + return STATUS_INVALID_PARAMETER; + + data_size = msg->DataSize; + + SERVER_START_REQ( request_lpc_reply ) + { + req->handle = wine_server_obj_handle( handle ); + req->data_size = data_size; + req->msg_type = 3; /* datagram */ + wine_server_add_data( req, msg->Data, data_size ); + ret = wine_server_call( req ); + } + SERVER_END_REQ; + return ret; } diff --git a/dlls/wow64/sync.c b/dlls/wow64/sync.c index fad6e1ca304..3b89e633ab1 100644 --- a/dlls/wow64/sync.c +++ b/dlls/wow64/sync.c @@ -1358,8 +1358,19 @@ NTSTATUS WINAPI wow64_NtReplyWaitReceivePortEx( UINT *args ) LPC_MESSAGE *msg = get_ptr( &args ); LARGE_INTEGER *timeout = get_ptr( &args ); - FIXME( "%p %p %p %p %p: stub\n", handle, id, reply, msg, timeout ); - return STATUS_NOT_IMPLEMENTED; + return NtReplyWaitReceivePortEx( handle, id, reply, msg, timeout ); +} + + +/********************************************************************** + * wow64_NtRequestPort + */ +NTSTATUS WINAPI wow64_NtRequestPort( UINT *args ) +{ + HANDLE handle = get_handle( &args ); + LPC_MESSAGE *msg = get_ptr( &args ); + + return NtRequestPort( handle, msg ); } @@ -1372,8 +1383,7 @@ NTSTATUS WINAPI wow64_NtRequestWaitReplyPort( UINT *args ) LPC_MESSAGE *msg_in = get_ptr( &args ); LPC_MESSAGE *msg_out = get_ptr( &args ); - FIXME( "%p %p %p: stub\n", handle, msg_in, msg_out ); - return STATUS_NOT_IMPLEMENTED; + return NtRequestWaitReplyPort( handle, msg_in, msg_out ); } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Implement server-side LPC message receiving and replying: - NtReplyPort: Send a reply to a previous request message - NtReplyWaitReceivePort: Wrapper around NtReplyWaitReceivePortEx - NtReplyWaitReceivePortEx: Optionally reply to a previous message and wait for the next incoming message with optional timeout --- dlls/ntdll/tests/port.c | 5 +-- dlls/ntdll/unix/sync.c | 90 ++++++++++++++++++++++++++++++++++++----- dlls/wow64/sync.c | 6 +-- 3 files changed, 84 insertions(+), 17 deletions(-) diff --git a/dlls/ntdll/tests/port.c b/dlls/ntdll/tests/port.c index 0b7cd92d739..302e766da4e 100644 --- a/dlls/ntdll/tests/port.c +++ b/dlls/ntdll/tests/port.c @@ -322,10 +322,7 @@ static void test_ports_server( HANDLE PortHandle ) while (TRUE) { status = pNtReplyWaitReceivePort(PortHandle, NULL, NULL, &LpcMessage->msg); - todo_wine - { - ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %ld(%lx)\n", status, status); - } + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %ld(%lx)\n", status, status); /* STATUS_INVALID_HANDLE: win2k without admin rights will perform an * endless loop here */ diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c index 7a225ad0499..26a1dad46d5 100644 --- a/dlls/ntdll/unix/sync.c +++ b/dlls/ntdll/unix/sync.c @@ -3453,31 +3453,103 @@ NTSTATUS WINAPI NtRequestPort( HANDLE handle, LPC_MESSAGE *msg ) /*********************************************************************** * NtReplyPort (NTDLL.@) */ -NTSTATUS WINAPI NtReplyPort( HANDLE handle, LPC_MESSAGE *reply ) +NTSTATUS WINAPI NtReplyPort( HANDLE handle, LPC_MESSAGE *reply_msg ) { - FIXME("(%p,%p),stub!\n", handle, reply ); - return STATUS_NOT_IMPLEMENTED; + unsigned int ret; + + TRACE( "(%p,%p)\n", handle, reply_msg ); + + if (!reply_msg) + return STATUS_INVALID_PARAMETER; + + SERVER_START_REQ( reply_wait_receive_lpc ) + { + req->handle = wine_server_obj_handle( handle ); + req->reply_msg_id = reply_msg->MessageId; + req->reply_size = reply_msg->DataSize; + req->timeout = 0; /* Don't wait for a new message */ + wine_server_add_data( req, reply_msg->Data, reply_msg->DataSize ); + ret = wine_server_call( req ); + /* STATUS_PENDING just means no new message, which is fine for NtReplyPort */ + if (ret == STATUS_PENDING) + ret = STATUS_SUCCESS; + } + SERVER_END_REQ; + return ret; } /*********************************************************************** * NtReplyWaitReceivePort (NTDLL.@) */ -NTSTATUS WINAPI NtReplyWaitReceivePort( HANDLE handle, ULONG *id, LPC_MESSAGE *reply, LPC_MESSAGE *msg ) +NTSTATUS WINAPI NtReplyWaitReceivePort( HANDLE handle, ULONG *id, LPC_MESSAGE *reply_msg, LPC_MESSAGE *msg ) { - FIXME("(%p,%p,%p,%p),stub!\n", handle, id, reply, msg ); - return STATUS_NOT_IMPLEMENTED; + return NtReplyWaitReceivePortEx( handle, id, reply_msg, msg, NULL ); } /*********************************************************************** * NtReplyWaitReceivePortEx (NTDLL.@) */ -NTSTATUS WINAPI NtReplyWaitReceivePortEx( HANDLE handle, ULONG *id, LPC_MESSAGE *reply, LPC_MESSAGE *msg, +NTSTATUS WINAPI NtReplyWaitReceivePortEx( HANDLE handle, ULONG *id, LPC_MESSAGE *reply_msg, LPC_MESSAGE *msg, LARGE_INTEGER *timeout ) { - FIXME("(%p,%p,%p,%p,%p),stub!\n", handle, id, reply, msg, timeout ); - return STATUS_NOT_IMPLEMENTED; + unsigned int ret; + timeout_t abs_timeout = timeout ? timeout->QuadPart : TIMEOUT_INFINITE; + unsigned int reply_msg_id = 0; + USHORT reply_size = 0; + + TRACE( "(%p,%p,%p,%p,%p)\n", handle, id, reply_msg, msg, timeout ); + + if (reply_msg) + { + reply_msg_id = reply_msg->MessageId; + reply_size = reply_msg->DataSize; + } + + for (;;) + { + SERVER_START_REQ( reply_wait_receive_lpc ) + { + req->handle = wine_server_obj_handle( handle ); + req->reply_msg_id = reply_msg_id; + req->reply_size = reply_size; + req->timeout = abs_timeout; + if (reply_msg && reply_size) + wine_server_add_data( req, reply_msg->Data, reply_size ); + if (msg) + { + /* Use a reasonable max size for LPC message data. + * sizeof(msg->Data) is just 1 due to ANYSIZE_ARRAY. */ + wine_server_set_reply( req, msg->Data, 0x1000 ); + } + ret = wine_server_call( req ); + if (!ret && msg) + { + msg->DataSize = reply->data_size; + msg->MessageSize = sizeof(*msg) + reply->data_size; + msg->MessageType = reply->msg_type; + msg->VirtualRangesOffset = 0; + msg->ClientId.UniqueProcess = ULongToHandle( reply->client_pid ); + msg->ClientId.UniqueThread = ULongToHandle( reply->client_tid ); + msg->MessageId = reply->msg_id; + msg->SectionSize = 0; + if (id) *id = (ULONG)(ULONG_PTR)reply->context; + } + } + SERVER_END_REQ; + + /* After first iteration, don't send reply again */ + reply_msg_id = 0; + reply_size = 0; + + if (ret != STATUS_PENDING) break; + + /* Wait on port for message availability */ + ret = NtWaitForSingleObject( handle, FALSE, timeout ); + if (ret) break; + } + return ret; } diff --git a/dlls/wow64/sync.c b/dlls/wow64/sync.c index 3b89e633ab1..c4ba357979b 100644 --- a/dlls/wow64/sync.c +++ b/dlls/wow64/sync.c @@ -1327,8 +1327,7 @@ NTSTATUS WINAPI wow64_NtReplyPort( UINT *args ) HANDLE handle = get_handle( &args ); LPC_MESSAGE *reply = get_ptr( &args ); - FIXME( "%p %p: stub\n", handle, reply ); - return STATUS_NOT_IMPLEMENTED; + return NtReplyPort( handle, reply ); } @@ -1342,8 +1341,7 @@ NTSTATUS WINAPI wow64_NtReplyWaitReceivePort( UINT *args ) LPC_MESSAGE *reply = get_ptr( &args ); LPC_MESSAGE *msg = get_ptr( &args ); - FIXME( "%p %p %p %p: stub\n", handle, id, reply, msg ); - return STATUS_NOT_IMPLEMENTED; + return NtReplyWaitReceivePort( handle, id, reply, msg ); } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Add support for sending LPC_CLIENT_DIED messages when a thread terminates: - New lpc_terminate_ports list in thread structure - register_lpc_terminate_port handler to register client ports - lpc_send_client_died function called during thread cleanup to send termination messages to all registered ports --- server/lpc_port.c | 96 +++++++++++++++++++++++++++++++++++++++++++++ server/protocol.def | 6 +++ server/thread.c | 2 + server/thread.h | 5 +++ 4 files changed, 109 insertions(+) diff --git a/server/lpc_port.c b/server/lpc_port.c index 56723282a7f..08b39595bde 100644 --- a/server/lpc_port.c +++ b/server/lpc_port.c @@ -54,6 +54,12 @@ #define LPC_REQUEST 1 #define LPC_REPLY 2 #define LPC_DATAGRAM 3 +#define LPC_LOST_REPLY 4 +#define LPC_PORT_CLOSED 5 +#define LPC_CLIENT_DIED 6 +#define LPC_EXCEPTION 7 +#define LPC_DEBUG_EVENT 8 +#define LPC_ERROR_EVENT 9 #define LPC_CONNECTION_REQUEST 10 /* Maximum message size */ @@ -77,6 +83,13 @@ struct pending_request struct lpc_port *client_port; /* client port to deliver reply to */ }; +/* Entry in thread's list of ports to notify on termination */ +struct lpc_terminate_port_entry +{ + struct list entry; /* entry in thread's lpc_terminate_ports list */ + struct lpc_port *port; /* the LPC port (client port) */ +}; + static const WCHAR lpc_port_name[] = {'L','P','C',' ','P','o','r','t'}; struct type_descr lpc_port_type = @@ -833,3 +846,86 @@ DECL_HANDLER(reply_wait_receive_lpc) reset_port_queue( receive_port ); release_object( port ); } + +/* Register a port for thread termination notification */ +DECL_HANDLER(register_lpc_terminate_port) +{ + struct lpc_port *port; + struct lpc_terminate_port_entry *entry; + + port = (struct lpc_port *)get_handle_obj( current->process, req->handle, + 0, &lpc_port_ops ); + if (!port) return; + + /* Only client ports should be registered for termination */ + if (port->port_type != PORT_TYPE_CLIENT) + { + set_error( STATUS_INVALID_PORT_HANDLE ); + release_object( port ); + return; + } + + /* Check if already registered */ + LIST_FOR_EACH_ENTRY( entry, ¤t->lpc_terminate_ports, struct lpc_terminate_port_entry, entry ) + { + if (entry->port == port) + { + release_object( port ); + return; + } + } + + /* Add to thread's terminate port list */ + entry = mem_alloc( sizeof(*entry) ); + if (entry) + { + entry->port = port; /* transfer the reference */ + list_add_tail( ¤t->lpc_terminate_ports, &entry->entry ); + } + else + { + release_object( port ); + } +} + +/* Send LPC_CLIENT_DIED messages to all registered ports for a thread. + * Called from cleanup_thread in thread.c */ +void lpc_send_client_died( struct thread *thread ) +{ + struct lpc_terminate_port_entry *entry, *next; + + LIST_FOR_EACH_ENTRY_SAFE( entry, next, &thread->lpc_terminate_ports, + struct lpc_terminate_port_entry, entry ) + { + struct lpc_port *client_port = entry->port; + + /* Send LPC_CLIENT_DIED to the server port via the communication channel */ + if (client_port && client_port->connected_port) + { + struct lpc_port *comm_port = client_port->connected_port; + struct lpc_port *server_port = comm_port->connection_port; + + if (server_port && server_port->port_type == PORT_TYPE_SERVER) + { + struct lpc_message *died_msg = alloc_lpc_message( 0 ); + if (died_msg) + { + died_msg->msg_id = get_next_msg_id(); + died_msg->msg_type = LPC_CLIENT_DIED; + died_msg->client_pid = thread->process->id; + died_msg->client_tid = thread->id; + died_msg->port_context = comm_port->port_context; + + /* Queue on server port */ + list_add_tail( &server_port->msg_queue, &died_msg->entry ); + signal_port_queue( server_port ); + } + } + } + + /* Clean up the entry */ + list_remove( &entry->entry ); + release_object( client_port ); + free( entry ); + } +} diff --git a/server/protocol.def b/server/protocol.def index 46f11a71b3b..cd57740700e 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -4390,3 +4390,9 @@ enum inproc_sync_type data_size_t data_size; /* size of message data */ VARARG(data,bytes); /* message data */ @END + + +/* Register port for thread termination notification */ +@REQ(register_lpc_terminate_port) + obj_handle_t handle; /* handle to client port */ +@END diff --git a/server/thread.c b/server/thread.c index 19c928f7bee..a8a31545d88 100644 --- a/server/thread.c +++ b/server/thread.c @@ -439,6 +439,7 @@ static inline void init_thread_structure( struct thread *thread ) list_init( &thread->system_apc ); list_init( &thread->user_apc ); list_init( &thread->kernel_object ); + list_init( &thread->lpc_terminate_ports ); for (i = 0; i < MAX_INFLIGHT_FDS; i++) thread->inflight[i].server = thread->inflight[i].client = -1; @@ -612,6 +613,7 @@ static void cleanup_thread( struct thread *thread ) { int i; + lpc_send_client_died( thread ); cleanup_thread_completion( thread ); if (thread->context) { diff --git a/server/thread.h b/server/thread.h index 96c643c64f1..db835bae077 100644 --- a/server/thread.h +++ b/server/thread.h @@ -100,6 +100,7 @@ struct thread data_size_t desc_len; /* thread description length in bytes */ WCHAR *desc; /* thread description string */ struct completion_wait *completion_wait; /* completion port wait object the thread is associated with */ + struct list lpc_terminate_ports; /* list of ports to notify on thread termination */ }; extern struct thread *current; @@ -145,6 +146,10 @@ extern void get_thread_context( struct thread *thread, struct context_data *cont extern void set_thread_context( struct thread *thread, const struct context_data *context, unsigned int flags ); extern int send_thread_signal( struct thread *thread, int sig ); +/* LPC functions */ + +extern void lpc_send_client_died( struct thread *thread ); + extern unsigned int global_error; /* global error code for when no thread is current */ static inline unsigned int get_error(void) { return current ? current->error : global_error; } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Register a port to receive LPC_CLIENT_DIED messages when the calling thread terminates. --- dlls/ntdll/unix/sync.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c index 26a1dad46d5..bc93e9420c6 100644 --- a/dlls/ntdll/unix/sync.c +++ b/dlls/ntdll/unix/sync.c @@ -3353,8 +3353,17 @@ NTSTATUS WINAPI NtReadRequestData( HANDLE handle, LPC_MESSAGE *request, ULONG id */ NTSTATUS WINAPI NtRegisterThreadTerminatePort( HANDLE handle ) { - FIXME( "(%p),stub!\n", handle ); - return STATUS_NOT_IMPLEMENTED; + unsigned int ret; + + TRACE( "(%p)\n", handle ); + + SERVER_START_REQ( register_lpc_terminate_port ) + { + req->handle = wine_server_obj_handle( handle ); + ret = wine_server_call( req ); + } + SERVER_END_REQ; + return ret; } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> LPC ports have circular references that prevent proper cleanup: - SERVER ports hold a self-reference via connection_port - CLIENT and CHANNEL ports have bidirectional connected_port references - Pending requests hold references to client ports Add a close_handle callback that breaks these circular references when the last handle to a port is closed, allowing the ports to be properly destroyed. --- server/lpc_port.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-) diff --git a/server/lpc_port.c b/server/lpc_port.c index 08b39595bde..28d8fc4bd66 100644 --- a/server/lpc_port.c +++ b/server/lpc_port.c @@ -144,6 +144,7 @@ struct lpc_port static void lpc_port_dump( struct object *obj, int verbose ); static struct object *lpc_port_get_sync( struct object *obj ); +static int lpc_port_close_handle( struct object *obj, struct process *process, obj_handle_t handle ); static void lpc_port_destroy( struct object *obj ); static const struct object_ops lpc_port_ops = @@ -167,7 +168,7 @@ static const struct object_ops lpc_port_ops = default_unlink_name, /* unlink_name */ no_open_file, /* open_file */ no_kernel_obj_list, /* get_kernel_obj_list */ - no_close_handle, /* close_handle */ + lpc_port_close_handle, /* close_handle */ lpc_port_destroy /* destroy */ }; @@ -389,6 +390,60 @@ static struct object *lpc_port_get_sync( struct object *obj ) return NULL; } +/* Break circular references when the last handle to a port is closed */ +static int lpc_port_close_handle( struct object *obj, struct process *process, obj_handle_t handle ) +{ + struct lpc_port *port = (struct lpc_port *)obj; + struct pending_request *pr, *next_pr; + + if (obj->handle_count == 1) + { + /* Clean up any pending requests that reference this port */ + LIST_FOR_EACH_ENTRY_SAFE( pr, next_pr, &global_pending_requests, struct pending_request, entry ) + { + if (pr->client_port == port) + { + list_remove( &pr->entry ); + release_object( pr->client_port ); + free( pr ); + } + } + + /* Break the bidirectional connected_port reference */ + if (port->connected_port) + { + struct lpc_port *peer = port->connected_port; + + /* Clear peer's reference to us first */ + if (peer->connected_port == port) + { + peer->connected_port = NULL; + release_object( port ); + } + + /* Clear our reference to peer */ + port->connected_port = NULL; + release_object( peer ); + } + + /* For SERVER ports, release the self-reference from connection_port */ + if (port->port_type == PORT_TYPE_SERVER && port->connection_port == port) + { + port->connection_port = NULL; + release_object( port ); + } + /* For client/channel ports, release the connection_port reference + * to allow the named server port to be destroyed */ + else if (port->port_type != PORT_TYPE_SERVER && port->connection_port) + { + release_object( port->connection_port ); + port->connection_port = NULL; + } + } + + return 1; +} + static void lpc_port_destroy( struct object *obj ) { struct lpc_port *port = (struct lpc_port *)obj; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Add tests for NtCreatePort and NtConnectPort error paths - NULL/zero-length object attributes - NULL/empty port names - Duplicate port names - Invalid max message/connect info sizes - Non-existent port connections Also add NULL parameter validation to NtConnectPort. --- dlls/ntdll/tests/port.c | 316 ++++++++++++++++++++++++++++++++++++++++ dlls/ntdll/unix/sync.c | 5 + 2 files changed, 321 insertions(+) diff --git a/dlls/ntdll/tests/port.c b/dlls/ntdll/tests/port.c index 302e766da4e..cd62ee4a34c 100644 --- a/dlls/ntdll/tests/port.c +++ b/dlls/ntdll/tests/port.c @@ -119,6 +119,9 @@ static NTSTATUS (WINAPI *pNtAcceptConnectPort)(PHANDLE,ULONG,PLPC_MESSAGE,ULONG, static NTSTATUS (WINAPI *pNtReplyPort)(HANDLE,PLPC_MESSAGE); static NTSTATUS (WINAPI *pNtReplyWaitReceivePort)(PHANDLE,PULONG,PLPC_MESSAGE, PLPC_MESSAGE); +static NTSTATUS (WINAPI *pNtReplyWaitReceivePortEx)(PHANDLE,PULONG,PLPC_MESSAGE, + PLPC_MESSAGE,LARGE_INTEGER*); +static NTSTATUS (WINAPI *pNtListenPort)(HANDLE,PLPC_MESSAGE); static NTSTATUS (WINAPI *pNtCreatePort)(PHANDLE,POBJECT_ATTRIBUTES,ULONG,ULONG,ULONG); static NTSTATUS (WINAPI *pNtRequestWaitReplyPort)(HANDLE,PLPC_MESSAGE,PLPC_MESSAGE); static NTSTATUS (WINAPI *pNtRequestPort)(HANDLE,PLPC_MESSAGE); @@ -143,6 +146,8 @@ static BOOL init_function_ptrs(void) pNtAcceptConnectPort = (void *)GetProcAddress(hntdll, "NtAcceptConnectPort"); pNtReplyPort = (void *)GetProcAddress(hntdll, "NtReplyPort"); pNtReplyWaitReceivePort = (void *)GetProcAddress(hntdll, "NtReplyWaitReceivePort"); + pNtReplyWaitReceivePortEx = (void *)GetProcAddress(hntdll, "NtReplyWaitReceivePortEx"); + pNtListenPort = (void *)GetProcAddress(hntdll, "NtListenPort"); pNtCreatePort = (void *)GetProcAddress(hntdll, "NtCreatePort"); pNtRequestWaitReplyPort = (void *)GetProcAddress(hntdll, "NtRequestWaitReplyPort"); pNtRequestPort = (void *)GetProcAddress(hntdll, "NtRequestPort"); @@ -364,6 +369,279 @@ static void test_ports_server( HANDLE PortHandle ) HeapFree(GetProcessHeap(), 0, LpcMessage); } +static void test_create_port_errors(void) +{ + OBJECT_ATTRIBUTES obj; + HANDLE port_handle; + NTSTATUS status; + UNICODE_STRING name; + static const WCHAR ERR_PORT1[] = {'\\','E','r','r','P','o','r','t','1',0}; + static const WCHAR ERR_PORT2[] = {'\\','E','r','r','P','o','r','t','2',0}; + static const WCHAR ERR_PORT3[] = {'\\','E','r','r','P','o','r','t','3',0}; + + /* Test NULL object attributes - Windows 64-bit returns SUCCESS, Wow64 returns ACCESS_VIOLATION */ + status = pNtCreatePort(&port_handle, NULL, 0, 0, 0); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER || status == STATUS_ACCESS_VIOLATION, + "Expected STATUS_SUCCESS, STATUS_INVALID_PARAMETER or STATUS_ACCESS_VIOLATION, got %08lx\n", status); + if (status == STATUS_SUCCESS) NtClose(port_handle); + + /* Test zero-length object attributes - Windows returns SUCCESS */ + memset(&obj, 0, sizeof(OBJECT_ATTRIBUTES)); + obj.Length = 0; + status = pNtCreatePort(&port_handle, &obj, 0, 0, 0); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER || status == STATUS_INVALID_HANDLE, + "Expected STATUS_SUCCESS, STATUS_INVALID_PARAMETER or STATUS_INVALID_HANDLE, got %08lx\n", status); + if (status == STATUS_SUCCESS) NtClose(port_handle); + + /* Test with valid object attributes but NULL name - Windows returns SUCCESS */ + memset(&obj, 0, sizeof(OBJECT_ATTRIBUTES)); + obj.Length = sizeof(OBJECT_ATTRIBUTES); + obj.ObjectName = NULL; + status = pNtCreatePort(&port_handle, &obj, 0, 0, 0); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER || status == STATUS_OBJECT_NAME_INVALID, + "Expected STATUS_SUCCESS, STATUS_INVALID_PARAMETER or STATUS_OBJECT_NAME_INVALID, got %08lx\n", status); + if (status == STATUS_SUCCESS) NtClose(port_handle); + + /* Test with empty name - Windows returns SUCCESS */ + pRtlInitUnicodeString(&name, L""); + memset(&obj, 0, sizeof(OBJECT_ATTRIBUTES)); + obj.Length = sizeof(OBJECT_ATTRIBUTES); + obj.ObjectName = &name; + status = pNtCreatePort(&port_handle, &obj, 0, 0, 0); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER || status == STATUS_OBJECT_NAME_INVALID, + "Expected STATUS_SUCCESS, STATUS_INVALID_PARAMETER or STATUS_OBJECT_NAME_INVALID, got %08lx\n", status); + if (status == STATUS_SUCCESS) NtClose(port_handle); + + /* Test with max message size too large - use unique name to avoid collision */ + pRtlInitUnicodeString(&name, ERR_PORT1); + memset(&obj, 0, sizeof(OBJECT_ATTRIBUTES)); + obj.Length = sizeof(OBJECT_ATTRIBUTES); + obj.ObjectName = &name; + status = pNtCreatePort(&port_handle, &obj, 0x100001, 0, 0); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER || status == STATUS_SECTION_TOO_BIG || status == STATUS_OBJECT_NAME_COLLISION, + "Expected STATUS_SUCCESS, STATUS_INVALID_PARAMETER, STATUS_SECTION_TOO_BIG or STATUS_OBJECT_NAME_COLLISION, got %08lx\n", status); + if (status == STATUS_SUCCESS) NtClose(port_handle); + + /* Test with max connect info too large - use unique name */ + pRtlInitUnicodeString(&name, ERR_PORT2); + memset(&obj, 0, sizeof(OBJECT_ATTRIBUTES)); + obj.Length = sizeof(OBJECT_ATTRIBUTES); + obj.ObjectName = &name; + status = pNtCreatePort(&port_handle, &obj, 0, 0x100001, 0); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER || status == STATUS_SECTION_TOO_BIG || status == STATUS_OBJECT_NAME_COLLISION, + "Expected STATUS_SUCCESS, STATUS_INVALID_PARAMETER, STATUS_SECTION_TOO_BIG or STATUS_OBJECT_NAME_COLLISION, got %08lx\n", status); + if (status == STATUS_SUCCESS) NtClose(port_handle); + + /* Test creating port with name that already exists */ + pRtlInitUnicodeString(&name, ERR_PORT3); + memset(&obj, 0, sizeof(OBJECT_ATTRIBUTES)); + obj.Length = sizeof(OBJECT_ATTRIBUTES); + obj.ObjectName = &name; + status = pNtCreatePort(&port_handle, &obj, 100, 100, 0); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + if (status == STATUS_SUCCESS) + { + NTSTATUS status2; + HANDLE port_handle2; + status2 = pNtCreatePort(&port_handle2, &obj, 100, 100, 0); + ok(status2 == STATUS_OBJECT_NAME_COLLISION, + "Expected STATUS_OBJECT_NAME_COLLISION, got %08lx\n", status2); + NtClose(port_handle); + } +} + +static void test_connect_port_errors(void) +{ + SECURITY_QUALITY_OF_SERVICE sqos; + HANDLE port_handle; + ULONG len; + NTSTATUS status; + UNICODE_STRING bad_name; + static const WCHAR BAD_NAME[] = {'\\','N','o','n','E','x','i','s','t','e','n','t','P','o','r','t',0}; + + sqos.Length = sizeof(SECURITY_QUALITY_OF_SERVICE); + sqos.ImpersonationLevel = SecurityImpersonation; + sqos.ContextTrackingMode = SECURITY_STATIC_TRACKING; + sqos.EffectiveOnly = TRUE; + + /* Test connecting to non-existent port */ + pRtlInitUnicodeString(&bad_name, BAD_NAME); + status = pNtConnectPort(&port_handle, &bad_name, &sqos, 0, 0, &len, NULL, NULL); + ok(status == STATUS_OBJECT_NAME_NOT_FOUND || status == STATUS_INVALID_PARAMETER, + "Expected STATUS_OBJECT_NAME_NOT_FOUND or STATUS_INVALID_PARAMETER, got %08lx\n", status); + + /* NULL parameter tests crash on Wow64 due to thunking, skip them */ + if (!is_wow64) + { + /* Test with NULL port name - Windows returns STATUS_OBJECT_NAME_INVALID */ + status = pNtConnectPort(&port_handle, NULL, &sqos, 0, 0, &len, NULL, NULL); + ok(status == STATUS_INVALID_PARAMETER || status == STATUS_ACCESS_VIOLATION || status == STATUS_OBJECT_NAME_INVALID, + "Expected STATUS_INVALID_PARAMETER, STATUS_ACCESS_VIOLATION or STATUS_OBJECT_NAME_INVALID, got %08lx\n", status); + + /* Test with NULL handle pointer - Windows returns STATUS_OBJECT_NAME_INVALID */ + status = pNtConnectPort(NULL, &port, &sqos, 0, 0, &len, NULL, NULL); + ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER || status == STATUS_OBJECT_NAME_INVALID, + "Expected STATUS_ACCESS_VIOLATION, STATUS_INVALID_PARAMETER or STATUS_OBJECT_NAME_INVALID, got %08lx\n", status); + } +} + +static void test_zero_length_server(HANDLE PortHandle) +{ + HANDLE AcceptPortHandle; + union lpc_message *LpcMessage; + ULONG size; + NTSTATUS status; + BOOL done = FALSE; + + size = FIELD_OFFSET(LPC_MESSAGE, Data) + MAX_MESSAGE_LEN; + LpcMessage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); + + while (!done) + { + status = pNtReplyWaitReceivePort(PortHandle, NULL, NULL, &LpcMessage->msg); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + if (status != STATUS_SUCCESS) break; + + if (is_wow64) + { + switch (LpcMessage->msg64.MessageType) + { + case LPC_CONNECTION_REQUEST: + status = pNtAcceptConnectPort(&AcceptPortHandle, 0, &LpcMessage->msg, 1, NULL, NULL); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + if (status == STATUS_SUCCESS) + { + status = pNtCompleteConnectPort(AcceptPortHandle); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + } + break; + + case LPC_REQUEST: + /* Reply to zero-length request with zero-length reply */ + LpcMessage->msg64.DataSize = 0; + LpcMessage->msg64.MessageSize = FIELD_OFFSET(LPC_MESSAGE64, Data[0]); + status = pNtReplyPort(PortHandle, &LpcMessage->msg); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + done = TRUE; + break; + + case LPC_DATAGRAM: + /* Zero-length datagram received */ + ok(LpcMessage->msg64.DataSize == 0, "Expected DataSize 0, got %u\n", LpcMessage->msg64.DataSize); + break; + + case LPC_CLIENT_DIED: + done = TRUE; + break; + } + } + else + { + switch (LpcMessage->msg.MessageType) + { + case LPC_CONNECTION_REQUEST: + status = pNtAcceptConnectPort(&AcceptPortHandle, 0, &LpcMessage->msg, 1, NULL, NULL); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + if (status == STATUS_SUCCESS) + { + status = pNtCompleteConnectPort(AcceptPortHandle); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + } + break; + + case LPC_REQUEST: + /* Reply to zero-length request with zero-length reply */ + LpcMessage->msg.DataSize = 0; + LpcMessage->msg.MessageSize = FIELD_OFFSET(LPC_MESSAGE, Data[0]); + status = pNtReplyPort(PortHandle, &LpcMessage->msg); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + done = TRUE; + break; + + case LPC_DATAGRAM: + /* Zero-length datagram received */ + ok(LpcMessage->msg.DataSize == 0, "Expected DataSize 0, got %u\n", LpcMessage->msg.DataSize); + break; + + case LPC_CLIENT_DIED: + done = TRUE; + break; + } + } + } + + HeapFree(GetProcessHeap(), 0, LpcMessage); +} + +static DWORD WINAPI zero_length_client(LPVOID arg) +{ + SECURITY_QUALITY_OF_SERVICE sqos; + HANDLE PortHandle; + ULONG len; + NTSTATUS status; + union lpc_message *LpcMessage, *out; + ULONG size; + + sqos.Length = sizeof(SECURITY_QUALITY_OF_SERVICE); + sqos.ImpersonationLevel = SecurityImpersonation; + sqos.ContextTrackingMode = SECURITY_STATIC_TRACKING; + sqos.EffectiveOnly = TRUE; + + status = pNtConnectPort(&PortHandle, &port, &sqos, 0, 0, &len, NULL, NULL); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + if (status != STATUS_SUCCESS) return 1; + + if (is_wow64) + { + size = FIELD_OFFSET(LPC_MESSAGE64, Data[MAX_MESSAGE_LEN]); + LpcMessage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); + out = HeapAlloc(GetProcessHeap(), 0, size); + + /* Send zero-length datagram */ + LpcMessage->msg64.DataSize = 0; + LpcMessage->msg64.MessageSize = FIELD_OFFSET(LPC_MESSAGE64, Data[0]); + status = pNtRequestPort(PortHandle, &LpcMessage->msg); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER, + "Expected STATUS_SUCCESS or STATUS_INVALID_PARAMETER, got %08lx\n", status); + + /* Send zero-length request and wait for reply */ + LpcMessage->msg64.DataSize = 0; + LpcMessage->msg64.MessageSize = FIELD_OFFSET(LPC_MESSAGE64, Data[0]); + status = pNtRequestWaitReplyPort(PortHandle, &LpcMessage->msg, &out->msg); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER, + "Expected STATUS_SUCCESS or STATUS_INVALID_PARAMETER, got %08lx\n", status); + + HeapFree(GetProcessHeap(), 0, out); + HeapFree(GetProcessHeap(), 0, LpcMessage); + } + else + { + size = FIELD_OFFSET(LPC_MESSAGE, Data[MAX_MESSAGE_LEN]); + LpcMessage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); + out = HeapAlloc(GetProcessHeap(), 0, size); + + /* Send zero-length datagram */ + LpcMessage->msg.DataSize = 0; + LpcMessage->msg.MessageSize = FIELD_OFFSET(LPC_MESSAGE, Data[0]); + status = pNtRequestPort(PortHandle, &LpcMessage->msg); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER, + "Expected STATUS_SUCCESS or STATUS_INVALID_PARAMETER, got %08lx\n", status); + + /* Send zero-length request and wait for reply */ + LpcMessage->msg.DataSize = 0; + LpcMessage->msg.MessageSize = FIELD_OFFSET(LPC_MESSAGE, Data[0]); + status = pNtRequestWaitReplyPort(PortHandle, &LpcMessage->msg, &out->msg); + ok(status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER, + "Expected STATUS_SUCCESS or STATUS_INVALID_PARAMETER, got %08lx\n", status); + + HeapFree(GetProcessHeap(), 0, out); + HeapFree(GetProcessHeap(), 0, LpcMessage); + } + + NtClose(PortHandle); + return 0; +} + START_TEST(port) { OBJECT_ATTRIBUTES obj; @@ -393,5 +671,43 @@ START_TEST(port) ok( WaitForSingleObject( thread, 10000 ) == 0, "thread didn't exit\n" ); CloseHandle(thread); } + + test_create_port_errors(); + test_connect_port_errors(); + + if (status == STATUS_SUCCESS) + { + static const WCHAR ZERO_PORT[] = {'\\','Z','e','r','o','P','o','r','t',0}; + UNICODE_STRING zero_name; + HANDLE zero_port; + DWORD id; + HANDLE thread; + + pRtlInitUnicodeString(&zero_name, ZERO_PORT); + memset(&obj, 0, sizeof(OBJECT_ATTRIBUTES)); + obj.Length = sizeof(OBJECT_ATTRIBUTES); + obj.ObjectName = &zero_name; + + status = pNtCreatePort(&zero_port, &obj, 100, 100, 0); + ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); + if (status == STATUS_SUCCESS) + { + /* Update global port name so client connects to the right port */ + port = zero_name; + thread = CreateThread(NULL, 0, zero_length_client, NULL, 0, &id); + ok(thread != NULL, "Expected non-NULL thread handle!\n"); + + test_zero_length_server(zero_port); + ok(WaitForSingleObject(thread, 10000) == 0, "zero-length thread didn't exit\n"); + CloseHandle(thread); + NtClose(zero_port); + } + } + + + + if (status == STATUS_SUCCESS) + NtClose(port_handle); + FreeLibrary(hntdll); } diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c index bc93e9420c6..93751733f08 100644 --- a/dlls/ntdll/unix/sync.c +++ b/dlls/ntdll/unix/sync.c @@ -3145,6 +3145,11 @@ NTSTATUS WINAPI NtConnectPort( HANDLE *handle, UNICODE_STRING *name, SECURITY_QU TRACE( "(%p,%s,%p,%p,%p,%p,%p,%p)\n", handle, debugstr_us(name), qos, write, read, max_len, info, info_len ); + if (!handle) + return STATUS_ACCESS_VIOLATION; + if (!name) + return STATUS_OBJECT_NAME_INVALID; + if (write) FIXME( "LPC_SECTION_WRITE not supported\n" ); if (read) -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> --- server/lpc_port.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/server/lpc_port.c b/server/lpc_port.c index 28d8fc4bd66..e8c9a18d900 100644 --- a/server/lpc_port.c +++ b/server/lpc_port.c @@ -395,6 +395,7 @@ static int lpc_port_close_handle( struct object *obj, struct process *process, o { struct lpc_port *port = (struct lpc_port *)obj; struct pending_request *pr, *next_pr; + struct lpc_message *msg, *next_msg; if (obj->handle_count == 1) { @@ -409,6 +410,23 @@ static int lpc_port_close_handle( struct object *obj, struct process *process, o } } + /* For SERVER ports, reject all pending connection requests so clients don't hang */ + if (port->port_type == PORT_TYPE_SERVER) + { + LIST_FOR_EACH_ENTRY_SAFE( msg, next_msg, &port->pending_connects, struct lpc_message, entry ) + { + struct lpc_port *client_port = msg->sender_port; + if (client_port) + { + client_port->connect_status = STATUS_PORT_CONNECTION_REFUSED; + if (client_port->connect_event) + signal_sync( client_port->connect_event ); + } + list_remove( &msg->entry ); + free_lpc_message( msg ); + } + } + /* Break the bidirectional connected_port reference */ if (port->connected_port) { @@ -857,8 +875,10 @@ DECL_HANDLER(reply_wait_receive_lpc) { if (port->port_type == PORT_TYPE_SERVER && !list_empty( &port->pending_connects )) { + /* Peek at pending connection request without removing it. + * The message stays in pending_connects until accept_lpc_connect + * is called, which will remove and free it properly. */ msg = LIST_ENTRY( list_head( &port->pending_connects ), struct lpc_message, entry ); - list_remove( &msg->entry ); reply->msg_id = msg->msg_id; reply->msg_type = msg->msg_type; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
From: Rose Hellsing <rose@pinkro.se> Add LPC_MESSAGE32, LPC_SECTION_WRITE32 and LPC_SECTION_READ32 structures and conversion helpers, and use them in the LPC syscall thunks instead of passing 32-bit messages through unchanged. Update the port tests to distinguish between WOW64 detection (which gates NULL parameter tests that crash on Windows due to thunking) and the choice of LPC message layout. On Wine WOW64 the thunks now convert between the 32-bit and 64-bit layouts, so 32-bit callers use the native 24-byte header rather than the 64-bit layout required on Windows WOW64. --- dlls/ntdll/tests/port.c | 30 ++++++---- dlls/wow64/struct32.h | 29 +++++++++ dlls/wow64/sync.c | 120 +++++++++++++++++++++++++++---------- dlls/wow64/wow64_private.h | 90 ++++++++++++++++++++++++++++ 4 files changed, 227 insertions(+), 42 deletions(-) diff --git a/dlls/ntdll/tests/port.c b/dlls/ntdll/tests/port.c index cd62ee4a34c..9e1ec9240c2 100644 --- a/dlls/ntdll/tests/port.c +++ b/dlls/ntdll/tests/port.c @@ -134,6 +134,7 @@ static NTSTATUS (WINAPI *pRtlInitUnicodeString)(PUNICODE_STRING,LPCWSTR); static BOOL (WINAPI *pIsWow64Process)(HANDLE, PBOOL); static BOOL is_wow64; +static BOOL use_msg64; static BOOL init_function_ptrs(void) { @@ -167,6 +168,11 @@ static BOOL init_function_ptrs(void) pIsWow64Process = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsWow64Process"); if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) is_wow64 = FALSE; + /* On Wine WOW64, the wow64.dll thunks convert between 32-bit and 64-bit LPC_MESSAGE + * layouts, so 32-bit code uses the native LPC_MESSAGE (24-byte header). + * On Windows WOW64, the thunks pass through and the 32-bit caller must use the + * 64-bit layout (40-byte header) directly. */ + use_msg64 = is_wow64 && !winetest_platform_is_wine; return TRUE; } @@ -174,7 +180,7 @@ static void ProcessConnectionRequest(union lpc_message *LpcMessage, PHANDLE pAcc { NTSTATUS status; - if (is_wow64) + if (use_msg64) { ok(LpcMessage->msg64.MessageType == LPC_CONNECTION_REQUEST, "Expected LPC_CONNECTION_REQUEST, got %d\n", LpcMessage->msg64.MessageType); @@ -189,7 +195,7 @@ static void ProcessConnectionRequest(union lpc_message *LpcMessage, PHANDLE pAcc status = pNtAcceptConnectPort(pAcceptPortHandle, 0, &LpcMessage->msg, 1, NULL, NULL); ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %lx\n", status); - + status = pNtCompleteConnectPort(*pAcceptPortHandle); ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %lx\n", status); } @@ -198,7 +204,7 @@ static void ProcessLpcRequest(HANDLE PortHandle, union lpc_message *LpcMessage) { NTSTATUS status; - if (is_wow64) + if (use_msg64) { ok(LpcMessage->msg64.MessageType == LPC_REQUEST, "Expected LPC_REQUEST, got %d\n", LpcMessage->msg64.MessageType); @@ -250,7 +256,7 @@ static DWORD WINAPI test_ports_client(LPVOID arg) status = pNtRegisterThreadTerminatePort(PortHandle); ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %lx\n", status); - if (is_wow64) + if (use_msg64) { size = FIELD_OFFSET(LPC_MESSAGE64, Data[MAX_MESSAGE_LEN]); LpcMessage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); @@ -321,7 +327,8 @@ static void test_ports_server( HANDLE PortHandle ) NTSTATUS status; BOOL done = FALSE; - size = FIELD_OFFSET(LPC_MESSAGE, Data) + MAX_MESSAGE_LEN; + size = use_msg64 ? FIELD_OFFSET(LPC_MESSAGE64, Data[MAX_MESSAGE_LEN]) + : FIELD_OFFSET(LPC_MESSAGE, Data[MAX_MESSAGE_LEN]); LpcMessage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); while (TRUE) @@ -334,7 +341,7 @@ static void test_ports_server( HANDLE PortHandle ) if ((status == STATUS_NOT_IMPLEMENTED) || (status == STATUS_INVALID_HANDLE)) return; - switch (is_wow64 ? LpcMessage->msg64.MessageType : LpcMessage->msg.MessageType) + switch (use_msg64 ? LpcMessage->msg64.MessageType : LpcMessage->msg.MessageType) { case LPC_CONNECTION_REQUEST: ProcessConnectionRequest(LpcMessage, &AcceptPortHandle); @@ -346,7 +353,7 @@ static void test_ports_server( HANDLE PortHandle ) break; case LPC_DATAGRAM: - if (is_wow64) + if (use_msg64) ok(!strcmp((LPSTR)LpcMessage->msg64.Data, REQUEST1), "Expected %s, got %s\n", REQUEST1, LpcMessage->msg64.Data); else @@ -361,7 +368,7 @@ static void test_ports_server( HANDLE PortHandle ) default: ok(FALSE, "Unexpected message: %d\n", - is_wow64 ? LpcMessage->msg64.MessageType : LpcMessage->msg.MessageType); + use_msg64 ? LpcMessage->msg64.MessageType : LpcMessage->msg.MessageType); break; } } @@ -493,7 +500,8 @@ static void test_zero_length_server(HANDLE PortHandle) NTSTATUS status; BOOL done = FALSE; - size = FIELD_OFFSET(LPC_MESSAGE, Data) + MAX_MESSAGE_LEN; + size = use_msg64 ? FIELD_OFFSET(LPC_MESSAGE64, Data[MAX_MESSAGE_LEN]) + : FIELD_OFFSET(LPC_MESSAGE, Data[MAX_MESSAGE_LEN]); LpcMessage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); while (!done) @@ -502,7 +510,7 @@ static void test_zero_length_server(HANDLE PortHandle) ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); if (status != STATUS_SUCCESS) break; - if (is_wow64) + if (use_msg64) { switch (LpcMessage->msg64.MessageType) { @@ -591,7 +599,7 @@ static DWORD WINAPI zero_length_client(LPVOID arg) ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status); if (status != STATUS_SUCCESS) return 1; - if (is_wow64) + if (use_msg64) { size = FIELD_OFFSET(LPC_MESSAGE64, Data[MAX_MESSAGE_LEN]); LpcMessage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); diff --git a/dlls/wow64/struct32.h b/dlls/wow64/struct32.h index ba2bc02523f..3c6bcb9a743 100644 --- a/dlls/wow64/struct32.h +++ b/dlls/wow64/struct32.h @@ -803,6 +803,35 @@ typedef struct } DUMMYUNIONNAME4; } ALPC_PORT_MESSAGE32, *PALPC_PORT_MESSAGE32, ALPC_PORT_MESSAGE_HEADER32, *PALPC_PORT_MESSAGE_HEADER32; +typedef struct +{ + USHORT DataSize; + USHORT MessageSize; + USHORT MessageType; + USHORT VirtualRangesOffset; + CLIENT_ID32 ClientId; + ULONG MessageId; + ULONG SectionSize; + UCHAR Data[1]; +} LPC_MESSAGE32, *PLPC_MESSAGE32; + +typedef struct +{ + ULONG Length; + ULONG SectionHandle; + ULONG SectionOffset; + ULONG ViewSize; + ULONG ViewBase; + ULONG TargetViewBase; +} LPC_SECTION_WRITE32, *PLPC_SECTION_WRITE32; + +typedef struct +{ + ULONG Length; + ULONG ViewSize; + ULONG ViewBase; +} LPC_SECTION_READ32, *PLPC_SECTION_READ32; + typedef struct { ULONG AllocatedAttributes; diff --git a/dlls/wow64/sync.c b/dlls/wow64/sync.c index c4ba357979b..0bbf9257359 100644 --- a/dlls/wow64/sync.c +++ b/dlls/wow64/sync.c @@ -135,15 +135,25 @@ NTSTATUS WINAPI wow64_NtAcceptConnectPort( UINT *args ) { ULONG *handle_ptr = get_ptr( &args ); ULONG id = get_ulong( &args ); - LPC_MESSAGE *msg = get_ptr( &args ); + LPC_MESSAGE32 *msg32 = get_ptr( &args ); BOOLEAN accept = get_ulong( &args ); - LPC_SECTION_WRITE *write = get_ptr( &args ); - LPC_SECTION_READ *read = get_ptr( &args ); + LPC_SECTION_WRITE32 *write32 = get_ptr( &args ); + LPC_SECTION_READ32 *read32 = get_ptr( &args ); HANDLE handle = 0; NTSTATUS status; - - status = NtAcceptConnectPort( &handle, id, msg, accept, write, read ); + LPC_MESSAGE *msg; + LPC_SECTION_WRITE write; + LPC_SECTION_READ read; + + status = NtAcceptConnectPort( &handle, id, + lpc_message_32to64( &msg, msg32 ? (sizeof(*msg) + msg32->DataSize) : 0, msg32, TRUE ), + accept, + lpc_section_write_32to64( &write, write32 ), + lpc_section_read_32to64( &read, read32 ) ); + if (msg32 && msg) lpc_message_64to32( msg32, msg ); + if (write32) lpc_section_write_64to32( write32, &write ); + if (read32) lpc_section_read_64to32( read32, &read ); put_handle( handle_ptr, handle ); return status; } @@ -203,8 +213,8 @@ NTSTATUS WINAPI wow64_NtConnectPort( UINT *args ) ULONG *handle_ptr = get_ptr( &args ); UNICODE_STRING32 *name32 = get_ptr( &args ); SECURITY_QUALITY_OF_SERVICE *qos = get_ptr( &args ); - LPC_SECTION_WRITE *write = get_ptr( &args ); - LPC_SECTION_READ *read = get_ptr( &args ); + LPC_SECTION_WRITE32 *write32 = get_ptr( &args ); + LPC_SECTION_READ32 *read32 = get_ptr( &args ); ULONG *max_len = get_ptr( &args ); void *info = get_ptr( &args ); ULONG *info_len = get_ptr( &args ); @@ -212,10 +222,17 @@ NTSTATUS WINAPI wow64_NtConnectPort( UINT *args ) UNICODE_STRING name; HANDLE handle = 0; NTSTATUS status; + LPC_SECTION_WRITE write; + LPC_SECTION_READ read; unicode_str_32to64( &name, name32 ); - status = NtConnectPort( &handle, &name, qos, write, read, max_len, info, info_len ); + status = NtConnectPort( &handle, &name, qos, + lpc_section_write_32to64( &write, write32 ), + lpc_section_read_32to64( &read, read32 ), + max_len, info, info_len ); + if (write32) lpc_section_write_64to32( write32, &write ); + if (read32) lpc_section_read_64to32( read32, &read ); put_handle( handle_ptr, handle ); return status; } @@ -558,10 +575,11 @@ NTSTATUS WINAPI wow64_NtDuplicateObject( UINT *args ) NTSTATUS WINAPI wow64_NtImpersonateClientOfPort( UINT *args ) { HANDLE handle = get_handle( &args ); - LPC_MESSAGE *msg = get_ptr( &args ); + LPC_MESSAGE32 *msg32 = get_ptr( &args ); - FIXME( "%p %p: stub\n", handle, msg ); - return STATUS_NOT_IMPLEMENTED; + LPC_MESSAGE *msg; + + return NtImpersonateClientOfPort( handle, lpc_message_32to64( &msg, msg32 ? (sizeof(*msg) + msg32->DataSize) : 0, msg32, TRUE ) ); } @@ -571,9 +589,14 @@ NTSTATUS WINAPI wow64_NtImpersonateClientOfPort( UINT *args ) NTSTATUS WINAPI wow64_NtListenPort( UINT *args ) { HANDLE handle = get_handle( &args ); - LPC_MESSAGE *msg = get_ptr( &args ); + LPC_MESSAGE32 *msg32 = get_ptr( &args ); + + LPC_MESSAGE *msg; + NTSTATUS status; - return NtListenPort( handle, msg ); + status = NtListenPort( handle, lpc_message_32to64( &msg, sizeof(*msg) + 0x1000, msg32, FALSE ) ); + if (!status && msg32) lpc_message_64to32( msg32, msg ); + return status; } @@ -1308,7 +1331,7 @@ NTSTATUS WINAPI wow64_NtReleaseSemaphore( UINT *args ) NTSTATUS WINAPI wow64_NtReadRequestData( UINT *args ) { HANDLE handle = get_handle( &args ); - LPC_MESSAGE *request = get_ptr( &args ); + LPC_MESSAGE32 *request = get_ptr( &args ); ULONG id = get_ulong( &args ); void *buffer = get_ptr( &args ); ULONG len = get_ulong( &args ); @@ -1325,9 +1348,11 @@ NTSTATUS WINAPI wow64_NtReadRequestData( UINT *args ) NTSTATUS WINAPI wow64_NtReplyPort( UINT *args ) { HANDLE handle = get_handle( &args ); - LPC_MESSAGE *reply = get_ptr( &args ); + LPC_MESSAGE32 *reply32 = get_ptr( &args ); + + LPC_MESSAGE *reply; - return NtReplyPort( handle, reply ); + return NtReplyPort( handle, lpc_message_32to64( &reply, reply32 ? (sizeof(*reply) + reply32->DataSize) : 0, reply32, TRUE ) ); } @@ -1338,10 +1363,18 @@ NTSTATUS WINAPI wow64_NtReplyWaitReceivePort( UINT *args ) { HANDLE handle = get_handle( &args ); ULONG *id = get_ptr( &args ); - LPC_MESSAGE *reply = get_ptr( &args ); - LPC_MESSAGE *msg = get_ptr( &args ); + LPC_MESSAGE32 *reply32 = get_ptr( &args ); + LPC_MESSAGE32 *msg32 = get_ptr( &args ); + + LPC_MESSAGE *reply; + LPC_MESSAGE *msg; + NTSTATUS status; - return NtReplyWaitReceivePort( handle, id, reply, msg ); + status = NtReplyWaitReceivePort( handle, id, + lpc_message_32to64( &reply, reply32 ? (sizeof(*reply) + reply32->DataSize) : 0, reply32, TRUE ), + lpc_message_32to64( &msg, sizeof(*msg) + 0x1000, msg32, FALSE ) ); + if (!status && msg32) lpc_message_64to32( msg32, msg ); + return status; } @@ -1352,11 +1385,20 @@ NTSTATUS WINAPI wow64_NtReplyWaitReceivePortEx( UINT *args ) { HANDLE handle = get_handle( &args ); ULONG *id = get_ptr( &args ); - LPC_MESSAGE *reply = get_ptr( &args ); - LPC_MESSAGE *msg = get_ptr( &args ); + LPC_MESSAGE32 *reply32 = get_ptr( &args ); + LPC_MESSAGE32 *msg32 = get_ptr( &args ); LARGE_INTEGER *timeout = get_ptr( &args ); - return NtReplyWaitReceivePortEx( handle, id, reply, msg, timeout ); + LPC_MESSAGE *reply; + LPC_MESSAGE *msg; + NTSTATUS status; + + status = NtReplyWaitReceivePortEx( handle, id, + lpc_message_32to64( &reply, reply32 ? (sizeof(*reply) + reply32->DataSize) : 0, reply32, TRUE ), + lpc_message_32to64( &msg, sizeof(*msg) + 0x1000, msg32, FALSE ), + timeout ); + if (!status && msg32) lpc_message_64to32( msg32, msg ); + return status; } @@ -1366,9 +1408,11 @@ NTSTATUS WINAPI wow64_NtReplyWaitReceivePortEx( UINT *args ) NTSTATUS WINAPI wow64_NtRequestPort( UINT *args ) { HANDLE handle = get_handle( &args ); - LPC_MESSAGE *msg = get_ptr( &args ); + LPC_MESSAGE32 *msg32 = get_ptr( &args ); - return NtRequestPort( handle, msg ); + LPC_MESSAGE *msg; + + return NtRequestPort( handle, lpc_message_32to64( &msg, msg32 ? (sizeof(*msg) + msg32->DataSize) : 0, msg32, TRUE ) ); } @@ -1378,10 +1422,18 @@ NTSTATUS WINAPI wow64_NtRequestPort( UINT *args ) NTSTATUS WINAPI wow64_NtRequestWaitReplyPort( UINT *args ) { HANDLE handle = get_handle( &args ); - LPC_MESSAGE *msg_in = get_ptr( &args ); - LPC_MESSAGE *msg_out = get_ptr( &args ); + LPC_MESSAGE32 *msg_in32 = get_ptr( &args ); + LPC_MESSAGE32 *msg_out32 = get_ptr( &args ); + + LPC_MESSAGE *msg_in; + LPC_MESSAGE *msg_out; + NTSTATUS status; - return NtRequestWaitReplyPort( handle, msg_in, msg_out ); + status = NtRequestWaitReplyPort( handle, + lpc_message_32to64( &msg_in, msg_in32 ? (sizeof(*msg_in) + msg_in32->DataSize) : 0, msg_in32, TRUE ), + lpc_message_32to64( &msg_out, sizeof(*msg_out) + 0x1000, msg_out32, FALSE ) ); + if (!status && msg_out32) lpc_message_64to32( msg_out32, msg_out ); + return status; } @@ -1405,9 +1457,9 @@ NTSTATUS WINAPI wow64_NtSecureConnectPort( UINT *args ) ULONG *handle_ptr = get_ptr( &args ); UNICODE_STRING32 *name32 = get_ptr( &args ); SECURITY_QUALITY_OF_SERVICE *qos = get_ptr( &args ); - LPC_SECTION_WRITE *write = get_ptr( &args ); + LPC_SECTION_WRITE32 *write32 = get_ptr( &args ); SID *sid = get_ptr( &args ); - LPC_SECTION_READ *read = get_ptr( &args ); + LPC_SECTION_READ32 *read32 = get_ptr( &args ); ULONG *max_len = get_ptr( &args ); void *info = get_ptr( &args ); ULONG *info_len = get_ptr( &args ); @@ -1415,9 +1467,15 @@ NTSTATUS WINAPI wow64_NtSecureConnectPort( UINT *args ) UNICODE_STRING name; HANDLE handle = 0; NTSTATUS status; + LPC_SECTION_WRITE write; + LPC_SECTION_READ read; status = NtSecureConnectPort( &handle, unicode_str_32to64( &name, name32 ), - qos, write, sid, read, max_len, info, info_len ); + qos, lpc_section_write_32to64( &write, write32 ), + sid, lpc_section_read_32to64( &read, read32 ), + max_len, info, info_len ); + if (write32) lpc_section_write_64to32( write32, &write ); + if (read32) lpc_section_read_64to32( read32, &read ); put_handle( handle_ptr, handle ); return status; } @@ -1862,7 +1920,7 @@ NTSTATUS WINAPI wow64_NtWaitForSingleObject( UINT *args ) NTSTATUS WINAPI wow64_NtWriteRequestData( UINT *args ) { HANDLE handle = get_handle( &args ); - LPC_MESSAGE *request = get_ptr( &args ); + LPC_MESSAGE32 *request = get_ptr( &args ); ULONG id = get_ulong( &args ); void *buffer = get_ptr( &args ); ULONG len = get_ulong( &args ); diff --git a/dlls/wow64/wow64_private.h b/dlls/wow64/wow64_private.h index 2ac3e51f1f0..00476b9a71a 100644 --- a/dlls/wow64/wow64_private.h +++ b/dlls/wow64/wow64_private.h @@ -487,6 +487,96 @@ static inline ALPC_MESSAGE_ATTRIBUTES32 *alpc_port_message_attributes_64to32( AL return out; } +static inline LPC_MESSAGE *lpc_message_32to64( LPC_MESSAGE **out, SIZE_T out_msg_size, + const LPC_MESSAGE32 *in, BOOL copy_msg ) +{ + LPC_MESSAGE *msg; + + if (!in || !(msg = Wow64AllocateTemp( out_msg_size ))) + { + *out = NULL; + return NULL; + } + + if (!copy_msg) goto done; + + msg->DataSize = in->DataSize; + msg->MessageSize = FIELD_OFFSET( LPC_MESSAGE, Data ) + in->DataSize; + msg->MessageType = in->MessageType; + msg->VirtualRangesOffset = in->VirtualRangesOffset; + client_id_32to64( &msg->ClientId, &in->ClientId ); + msg->MessageId = in->MessageId; + msg->SectionSize = in->SectionSize; + memcpy( (unsigned char *)msg + FIELD_OFFSET( LPC_MESSAGE, Data ), + (const unsigned char *)in + FIELD_OFFSET( LPC_MESSAGE32, Data ), in->DataSize ); +done: + *out = msg; + return msg; +} + +static inline LPC_MESSAGE32 *lpc_message_64to32( LPC_MESSAGE32 *out, const LPC_MESSAGE *in ) +{ + if (!in) return NULL; + + out->DataSize = in->DataSize; + out->MessageSize = FIELD_OFFSET( LPC_MESSAGE32, Data ) + in->DataSize; + out->MessageType = in->MessageType; + out->VirtualRangesOffset = in->VirtualRangesOffset; + out->ClientId.UniqueProcess = HandleToUlong( in->ClientId.UniqueProcess ); + out->ClientId.UniqueThread = HandleToUlong( in->ClientId.UniqueThread ); + out->MessageId = in->MessageId; + out->SectionSize = in->SectionSize; + memcpy( (unsigned char *)out + FIELD_OFFSET( LPC_MESSAGE32, Data ), + (const unsigned char *)in + FIELD_OFFSET( LPC_MESSAGE, Data ), in->DataSize ); + return out; +} + +static inline LPC_SECTION_WRITE *lpc_section_write_32to64( LPC_SECTION_WRITE *out, + const LPC_SECTION_WRITE32 *in ) +{ + if (!in) return NULL; + out->Length = sizeof(*out); + out->SectionHandle = LongToHandle( in->SectionHandle ); + out->SectionOffset = in->SectionOffset; + out->ViewSize = in->ViewSize; + out->ViewBase = ULongToPtr( in->ViewBase ); + out->TargetViewBase = ULongToPtr( in->TargetViewBase ); + return out; +} + +static inline LPC_SECTION_WRITE32 *lpc_section_write_64to32( LPC_SECTION_WRITE32 *out, + const LPC_SECTION_WRITE *in ) +{ + if (!in) return NULL; + out->Length = sizeof(*out); + out->SectionHandle = HandleToUlong( in->SectionHandle ); + out->SectionOffset = in->SectionOffset; + out->ViewSize = in->ViewSize; + out->ViewBase = PtrToUlong( in->ViewBase ); + out->TargetViewBase = PtrToUlong( in->TargetViewBase ); + return out; +} + +static inline LPC_SECTION_READ *lpc_section_read_32to64( LPC_SECTION_READ *out, + const LPC_SECTION_READ32 *in ) +{ + if (!in) return NULL; + out->Length = sizeof(*out); + out->ViewSize = in->ViewSize; + out->ViewBase = ULongToPtr( in->ViewBase ); + return out; +} + +static inline LPC_SECTION_READ32 *lpc_section_read_64to32( LPC_SECTION_READ32 *out, + const LPC_SECTION_READ *in ) +{ + if (!in) return NULL; + out->Length = sizeof(*out); + out->ViewSize = in->ViewSize; + out->ViewBase = PtrToUlong( in->ViewBase ); + return out; +} + static inline TOKEN_USER *token_user_32to64( TOKEN_USER *out, const TOKEN_USER32 *in ) { out->User.Sid = ULongToPtr( in->User.Sid ); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10611
The LPC tests all pass now across all architectures, from what I can tell the winsqlite3 failure shouldn't be caused by my changes. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/10611#note_142295
participants (2)
-
Rose Hellsing -
Rose Hellsing (＠axtlos)