From 0d89ad94cf596828c4b2bf6f6efca17832e1fb5e Mon Sep 17 00:00:00 2001 From: Amine Khaldi Date: Sun, 4 Jun 2017 14:01:54 +0000 Subject: [PATCH] [RPCRT4] Sync with Wine Staging 2.9. CORE-13362 6b53b79 rpcrt4: Use HEAP_ZERO_MEMORY to alloc RpcServerProtseq objects. 28f865b rpcrt4: Add close_read implementation for TCP connections. 29f0b28 rpcrt4: Add close_read implementation for named pipe connections. 42ba4d7 rpcrt4: Introduce op for closing connection read end and use it when shutting down server. ef267f1 rpcrt4: Store all active connections in RpcServerProtseq. dae3065 rpcrt4: Remove connection from list in RPCRT4_ReleaseConnection. 812897c rpcrt4: Use HEAP_ZERO_MEMORY to alloc RpcConnection objects. 13d529a rpcrt4: Renamed connections list to listeners. c953763 rpcrt4: Remove no longer needed helpers. b548338 rpcrt4: Implement cancel_call for named pipes. 372c9e0 rpcrt4: Cache event handle in RpcConnection_np object. 6e7a297 rpcrt4: Use non-blocking listening on named pipes. 4f4ac8c rpcrt4: Use named pipe in overlapped mode. bd6f807 rpcrt4: Simplify rpcrt4_conn_np_read implementation. f62b9d6 rpcrt4: Simplify rpcrt4_conn_np_write implementation. 2035294 rpcrt4: Use standard Wine list to store connections in RpcServerProtseq. e621593 rpcrt4: Always use winsock for networking. d0ed6d1 rpcrt4: Get rid of manual_listen_count and use binary state instead. svn path=/trunk/; revision=74904 --- reactos/dll/win32/rpcrt4/rpc_binding.h | 9 +- reactos/dll/win32/rpcrt4/rpc_server.c | 105 +-- reactos/dll/win32/rpcrt4/rpc_server.h | 3 +- reactos/dll/win32/rpcrt4/rpc_transport.c | 870 ++++++++--------------- reactos/media/doc/README.WINE | 2 +- 5 files changed, 351 insertions(+), 638 deletions(-) diff --git a/reactos/dll/win32/rpcrt4/rpc_binding.h b/reactos/dll/win32/rpcrt4/rpc_binding.h index 4cc2a5ad04c..1f53bac5427 100644 --- a/reactos/dll/win32/rpcrt4/rpc_binding.h +++ b/reactos/dll/win32/rpcrt4/rpc_binding.h @@ -86,7 +86,8 @@ typedef struct _RpcConnection /* The active interface bound to server. */ RPC_SYNTAX_IDENTIFIER ActiveInterface; USHORT NextCallId; - struct _RpcConnection* Next; + struct list protseq_entry; + struct _RpcServerProtseq *protseq; struct _RpcBinding *server_binding; } RpcConnection; @@ -99,6 +100,7 @@ struct connection_ops { int (*read)(RpcConnection *conn, void *buffer, unsigned int len); int (*write)(RpcConnection *conn, const void *buffer, unsigned int len); int (*close)(RpcConnection *conn); + void (*close_read)(RpcConnection *conn); void (*cancel_call)(RpcConnection *conn); RPC_STATUS (*is_server_listening)(const char *endpoint); int (*wait_for_incoming_data)(RpcConnection *conn); @@ -192,6 +194,11 @@ static inline int rpcrt4_conn_close(RpcConnection *Connection) return Connection->ops->close(Connection); } +static inline void rpcrt4_conn_close_read(RpcConnection *connection) +{ + connection->ops->close_read(connection); +} + static inline void rpcrt4_conn_cancel_call(RpcConnection *Connection) { Connection->ops->cancel_call(Connection); diff --git a/reactos/dll/win32/rpcrt4/rpc_server.c b/reactos/dll/win32/rpcrt4/rpc_server.c index f8411356250..2d7c80a2242 100644 --- a/reactos/dll/win32/rpcrt4/rpc_server.c +++ b/reactos/dll/win32/rpcrt4/rpc_server.c @@ -79,11 +79,9 @@ static CRITICAL_SECTION server_auth_info_cs = { &server_auth_info_cs_debug, -1, /* whether the server is currently listening */ static BOOL std_listen; -/* number of manual listeners (calls to RpcServerListen) */ -static LONG manual_listen_count; /* total listeners including auto listeners */ static LONG listen_count; -/* event set once all listening is finished */ +/* event set once all manual listening is finished */ static HANDLE listen_done_event; static UUID uuid_nil; @@ -649,9 +647,12 @@ static DWORD CALLBACK RPCRT4_server_thread(LPVOID the_arg) { /* cleanup */ cps->ops->free_wait_array(cps, objs); + EnterCriticalSection(&cps->cs); - for (conn = cps->conn; conn; conn = conn->Next) + LIST_FOR_EACH_ENTRY(conn, &cps->listeners, RpcConnection, protseq_entry) RPCRT4_CloseConnection(conn); + LIST_FOR_EACH_ENTRY(conn, &cps->connections, RpcConnection, protseq_entry) + rpcrt4_conn_close_read(conn); LeaveCriticalSection(&cps->cs); if (res == 0 && !std_listen) @@ -713,13 +714,16 @@ static RPC_STATUS RPCRT4_start_listen(BOOL auto_listen) TRACE("\n"); EnterCriticalSection(&listen_cs); - if (auto_listen || (manual_listen_count++ == 0)) + if (auto_listen || !listen_done_event) { status = RPC_S_OK; + if(!auto_listen) + listen_done_event = CreateEventW(NULL, TRUE, FALSE, NULL); if (++listen_count == 1) std_listen = TRUE; } LeaveCriticalSection(&listen_cs); + if (status) return status; if (std_listen) { @@ -742,51 +746,53 @@ static RPC_STATUS RPCRT4_start_listen(BOOL auto_listen) static RPC_STATUS RPCRT4_stop_listen(BOOL auto_listen) { + BOOL stop_listen = FALSE; RPC_STATUS status = RPC_S_OK; EnterCriticalSection(&listen_cs); - - if (!std_listen) + if (!std_listen && (auto_listen || !listen_done_event)) { status = RPC_S_NOT_LISTENING; - goto done; } - - if (auto_listen || (--manual_listen_count == 0)) + else { - if (listen_count != 0 && --listen_count == 0) { - RpcServerProtseq *cps; - - std_listen = FALSE; - LeaveCriticalSection(&listen_cs); - - LIST_FOR_EACH_ENTRY(cps, &protseqs, RpcServerProtseq, entry) - RPCRT4_sync_with_server_thread(cps); - - EnterCriticalSection(&listen_cs); - if (listen_done_event) SetEvent( listen_done_event ); - listen_done_event = 0; - goto done; - } + stop_listen = listen_count != 0 && --listen_count == 0; assert(listen_count >= 0); + if (stop_listen) + std_listen = FALSE; + } + LeaveCriticalSection(&listen_cs); + + if (status) return status; + + if (stop_listen) { + RpcServerProtseq *cps; + LIST_FOR_EACH_ENTRY(cps, &protseqs, RpcServerProtseq, entry) + RPCRT4_sync_with_server_thread(cps); } -done: - LeaveCriticalSection(&listen_cs); - return status; + if (!auto_listen) + { + EnterCriticalSection(&listen_cs); + SetEvent( listen_done_event ); + LeaveCriticalSection(&listen_cs); + } + return RPC_S_OK; } static BOOL RPCRT4_protseq_is_endpoint_registered(RpcServerProtseq *protseq, const char *endpoint) { RpcConnection *conn; + BOOL registered = FALSE; EnterCriticalSection(&protseq->cs); - for (conn = protseq->conn; conn; conn = conn->Next) - { - if (!endpoint || !strcmp(endpoint, conn->Endpoint)) + LIST_FOR_EACH_ENTRY(conn, &protseq->listeners, RpcConnection, protseq_entry) { + if (!endpoint || !strcmp(endpoint, conn->Endpoint)) { + registered = TRUE; break; + } } LeaveCriticalSection(&protseq->cs); - return (conn != NULL); + return registered; } static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq* ps, const char *endpoint) @@ -835,7 +841,7 @@ RPC_STATUS WINAPI RpcServerInqBindings( RPC_BINDING_VECTOR** BindingVector ) count = 0; LIST_FOR_EACH_ENTRY(ps, &protseqs, RpcServerProtseq, entry) { EnterCriticalSection(&ps->cs); - for (conn = ps->conn; conn; conn = conn->Next) + LIST_FOR_EACH_ENTRY(conn, &ps->listeners, RpcConnection, protseq_entry) count++; LeaveCriticalSection(&ps->cs); } @@ -848,7 +854,7 @@ RPC_STATUS WINAPI RpcServerInqBindings( RPC_BINDING_VECTOR** BindingVector ) count = 0; LIST_FOR_EACH_ENTRY(ps, &protseqs, RpcServerProtseq, entry) { EnterCriticalSection(&ps->cs); - for (conn = ps->conn; conn; conn = conn->Next) { + LIST_FOR_EACH_ENTRY(conn, &ps->listeners, RpcConnection, protseq_entry) { RPCRT4_MakeBinding((RpcBinding**)&(*BindingVector)->BindingH[count], conn); count++; @@ -919,13 +925,10 @@ static RPC_STATUS alloc_serverprotoseq(UINT MaxCalls, const char *Protseq, RpcSe (*ps)->MaxCalls = MaxCalls; (*ps)->Protseq = RPCRT4_strdupA(Protseq); (*ps)->ops = ops; - (*ps)->MaxCalls = 0; - (*ps)->conn = NULL; + list_init(&(*ps)->listeners); + list_init(&(*ps)->connections); InitializeCriticalSection(&(*ps)->cs); (*ps)->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RpcServerProtseq.cs"); - (*ps)->is_listening = FALSE; - (*ps)->mgr_mutex = NULL; - (*ps)->server_ready_event = NULL; list_add_head(&protseqs, &(*ps)->entry); @@ -1505,25 +1508,23 @@ RPC_STATUS WINAPI RpcMgmtWaitServerListen( void ) TRACE("()\n"); EnterCriticalSection(&listen_cs); - - if (!std_listen) { - LeaveCriticalSection(&listen_cs); - return RPC_S_NOT_LISTENING; - } - if (listen_done_event) { - LeaveCriticalSection(&listen_cs); - return RPC_S_ALREADY_LISTENING; - } - event = CreateEventW( NULL, TRUE, FALSE, NULL ); - listen_done_event = event; - + event = listen_done_event; LeaveCriticalSection(&listen_cs); + if (!event) + return RPC_S_NOT_LISTENING; + TRACE( "waiting for server calls to finish\n" ); WaitForSingleObject( event, INFINITE ); TRACE( "done waiting\n" ); - CloseHandle( event ); + EnterCriticalSection(&listen_cs); + if (listen_done_event == event) + { + listen_done_event = NULL; + CloseHandle( event ); + } + LeaveCriticalSection(&listen_cs); return RPC_S_OK; } @@ -1649,7 +1650,7 @@ RPC_STATUS WINAPI RpcMgmtIsServerListening(RPC_BINDING_HANDLE Binding) status = RPCRT4_IsServerListening(rpc_binding->Protseq, rpc_binding->Endpoint); }else { EnterCriticalSection(&listen_cs); - if (manual_listen_count > 0) status = RPC_S_OK; + if (listen_done_event && std_listen) status = RPC_S_OK; LeaveCriticalSection(&listen_cs); } diff --git a/reactos/dll/win32/rpcrt4/rpc_server.h b/reactos/dll/win32/rpcrt4/rpc_server.h index 04f32dff019..72e73e2a89a 100644 --- a/reactos/dll/win32/rpcrt4/rpc_server.h +++ b/reactos/dll/win32/rpcrt4/rpc_server.h @@ -32,7 +32,8 @@ typedef struct _RpcServerProtseq LPSTR Protseq; /* RO */ UINT MaxCalls; /* RO */ /* list of listening connections */ - RpcConnection* conn; /* CS cs */ + struct list listeners; /* CS cs */ + struct list connections; /* CS cs */ CRITICAL_SECTION cs; /* is the server currently listening? */ diff --git a/reactos/dll/win32/rpcrt4/rpc_transport.c b/reactos/dll/win32/rpcrt4/rpc_transport.c index 462fe3ad404..ed080fb64b7 100644 --- a/reactos/dll/win32/rpcrt4/rpc_transport.c +++ b/reactos/dll/win32/rpcrt4/rpc_transport.c @@ -25,58 +25,15 @@ #include "precomp.h" -#if defined(__MINGW32__) || defined (_MSC_VER) -# include -# ifndef EADDRINUSE -# define EADDRINUSE WSAEADDRINUSE -# endif -# ifndef EAGAIN -# define EAGAIN WSAEWOULDBLOCK -# endif -# undef errno -# define errno WSAGetLastError() -#else -# include -# ifdef HAVE_UNISTD_H -# include -# endif -# include -# ifdef HAVE_SYS_SOCKET_H -# include -# endif -# ifdef HAVE_NETINET_IN_H -# include -# endif -# ifdef HAVE_NETINET_TCP_H -# include -# endif -# ifdef HAVE_ARPA_INET_H -# include -# endif -# ifdef HAVE_NETDB_H -# include -# endif -# ifdef HAVE_SYS_POLL_H -# include -# endif -# ifdef HAVE_SYS_FILIO_H -# include -# endif -# ifdef HAVE_SYS_IOCTL_H -# include -# endif -# define closesocket close -# define ioctlsocket ioctl -#endif /* defined(__MINGW32__) || defined (_MSC_VER) */ +#include "ntstatus.h" +#define WIN32_NO_STATUS +#include #include +#include #include "epm_towers.h" -#ifndef SOL_TCP -# define SOL_TCP IPPROTO_TCP -#endif - #define DEFAULT_NCACN_HTTP_TIMEOUT (60 * 1000) #undef ARRAYSIZE @@ -84,78 +41,53 @@ WINE_DEFAULT_DEBUG_CHANNEL(rpc); -static RPC_STATUS RPCRT4_SpawnConnection(RpcConnection** Connection, RpcConnection* OldConnection); +#ifdef __REACTOS__ /* FIXME: Inspect */ +BOOL WINAPI CancelIoEx(HANDLE handle, LPOVERLAPPED lpOverlapped) +{ + IO_STATUS_BLOCK io_status; + + NtCancelIoFile(handle, &io_status); + if (io_status.u.Status) + { + SetLastError( RtlNtStatusToDosError( io_status.u.Status ) ); + return FALSE; + } + return TRUE; +} +#endif + +static RpcConnection *rpcrt4_spawn_connection(RpcConnection *old_connection); /**** ncacn_np support ****/ typedef struct _RpcConnection_np { - RpcConnection common; - HANDLE pipe; - OVERLAPPED ovl; - BOOL listening; + RpcConnection common; + HANDLE pipe; + HANDLE listen_event; + IO_STATUS_BLOCK io_status; + HANDLE event_cache; + BOOL read_closed; } RpcConnection_np; static RpcConnection *rpcrt4_conn_np_alloc(void) { RpcConnection_np *npc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcConnection_np)); - if (npc) - { - npc->pipe = NULL; - memset(&npc->ovl, 0, sizeof(npc->ovl)); - npc->listening = FALSE; - } return &npc->common; } -static RPC_STATUS rpcrt4_conn_listen_pipe(RpcConnection_np *npc) +static HANDLE get_np_event(RpcConnection_np *connection) { - if (npc->listening) - return RPC_S_OK; - - npc->listening = TRUE; - for (;;) - { - if (ConnectNamedPipe(npc->pipe, &npc->ovl)) - return RPC_S_OK; - - switch(GetLastError()) - { - case ERROR_PIPE_CONNECTED: - SetEvent(npc->ovl.hEvent); - return RPC_S_OK; - case ERROR_IO_PENDING: - /* will be completed in rpcrt4_protseq_np_wait_for_new_connection */ - return RPC_S_OK; - case ERROR_NO_DATA_DETECTED: - /* client has disconnected, retry */ - DisconnectNamedPipe( npc->pipe ); - break; - default: - npc->listening = FALSE; - WARN("Couldn't ConnectNamedPipe (error was %d)\n", GetLastError()); - return RPC_S_OUT_OF_RESOURCES; - } - } + HANDLE event = InterlockedExchangePointer(&connection->event_cache, NULL); + return event ? event : CreateEventW(NULL, TRUE, FALSE, NULL); } -#ifndef __REACTOS__ -static RPC_STATUS rpcrt4_conn_listen_pipe(RpcConnection_np *npc) +static void release_np_event(RpcConnection_np *connection, HANDLE event) { - if (npc->listening) - return RPC_S_OK; - - npc->listening = TRUE; - npc->listen_thread = CreateThread(NULL, 0, listen_thread, npc, 0, NULL); - if (!npc->listen_thread) - { - npc->listening = FALSE; - ERR("Couldn't create listen thread (error was %d)\n", GetLastError()); - return RPC_S_OUT_OF_RESOURCES; - } - return RPC_S_OK; + event = InterlockedExchangePointer(&connection->event_cache, event); + if (event) + CloseHandle(event); } -#endif static RPC_STATUS rpcrt4_conn_create_pipe(RpcConnection *Connection, LPCSTR pname) { @@ -174,9 +106,6 @@ static RPC_STATUS rpcrt4_conn_create_pipe(RpcConnection *Connection, LPCSTR pnam return RPC_S_CANT_CREATE_ENDPOINT; } - memset(&npc->ovl, 0, sizeof(npc->ovl)); - npc->ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL); - /* Note: we don't call ConnectNamedPipe here because it must be done in the * server thread as the thread must be alertable */ return RPC_S_OK; @@ -217,15 +146,12 @@ static RPC_STATUS rpcrt4_conn_open_pipe(RpcConnection *Connection, LPCSTR pname, dwFlags |= SECURITY_CONTEXT_TRACKING; } pipe = CreateFileA(pname, GENERIC_READ|GENERIC_WRITE, 0, NULL, - OPEN_EXISTING, dwFlags, 0); + OPEN_EXISTING, dwFlags | FILE_FLAG_OVERLAPPED, 0); if (pipe != INVALID_HANDLE_VALUE) break; err = GetLastError(); if (err == ERROR_PIPE_BUSY) { TRACE("connection failed, error=%x\n", err); return RPC_S_SERVER_TOO_BUSY; - } else if (err == ERROR_BAD_NETPATH) { - TRACE("connection failed, error=%x\n", err); - return RPC_S_SERVER_UNAVAILABLE; } if (!wait || !WaitNamedPipeA(pname, NMPWAIT_WAIT_FOREVER)) { err = GetLastError(); @@ -235,11 +161,9 @@ static RPC_STATUS rpcrt4_conn_open_pipe(RpcConnection *Connection, LPCSTR pname, } /* success */ - memset(&npc->ovl, 0, sizeof(npc->ovl)); /* pipe is connected; change to message-read mode. */ dwMode = PIPE_READMODE_MESSAGE; SetNamedPipeHandleState(pipe, &dwMode, NULL, NULL); - npc->ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL); npc->pipe = pipe; return RPC_S_OK; @@ -301,8 +225,8 @@ static RPC_STATUS rpcrt4_protseq_ncalrpc_open_endpoint(RpcServerProtseq* protseq I_RpcFree(pname); EnterCriticalSection(&protseq->cs); - Connection->Next = protseq->conn; - protseq->conn = Connection; + list_add_head(&protseq->listeners, &Connection->protseq_entry); + Connection->protseq = protseq; LeaveCriticalSection(&protseq->cs); return r; @@ -322,64 +246,15 @@ static char *ncacn_pipe_name(const char *endpoint) static RPC_STATUS rpcrt4_ncacn_np_open(RpcConnection* Connection) { RpcConnection_np *npc = (RpcConnection_np *) Connection; - static const char prefix[] = "\\\\"; - static const char local[] = "."; - BOOL bUseLocalName = TRUE; - CHAR ComputerName[MAX_COMPUTERNAME_LENGTH + 1]; - DWORD bufLen = sizeof(ComputerName)/sizeof(ComputerName[0]); RPC_STATUS r; LPSTR pname; - LPSTR NetworkAddr; - INT size; /* already connected? */ if (npc->pipe) return RPC_S_OK; - /* protseq=ncacn_np: named pipes */ - size = strlen(prefix); - - if (Connection->NetworkAddr == NULL || strlen(Connection->NetworkAddr) == 0) - { - bUseLocalName = TRUE; - size += strlen(local); - } - else - { - NetworkAddr = Connection->NetworkAddr; - if (NetworkAddr[0] == '\\' && NetworkAddr[1] == '\\') - NetworkAddr += 2; - - if (GetComputerNameA(ComputerName, &bufLen)) - { - if (stricmp(ComputerName, NetworkAddr) == 0) - { - bUseLocalName = TRUE; - size += strlen(local); - } - else - { - bUseLocalName = FALSE; - size += strlen(NetworkAddr); - } - } - else - { - bUseLocalName = FALSE; - size += strlen(NetworkAddr); - } - } - - size += strlen(Connection->Endpoint) + 1; - - pname = I_RpcAllocate(size); - strcpy(pname, prefix); - if (bUseLocalName) - strcat(pname, local); - else - strcat(pname, NetworkAddr); - strcat(pname, Connection->Endpoint); - r = rpcrt4_conn_open_pipe(Connection, pname, TRUE); + pname = ncacn_pipe_name(Connection->Endpoint); + r = rpcrt4_conn_open_pipe(Connection, pname, FALSE); I_RpcFree(pname); return r; @@ -412,8 +287,8 @@ static RPC_STATUS rpcrt4_protseq_ncacn_np_open_endpoint(RpcServerProtseq *protse I_RpcFree(pname); EnterCriticalSection(&protseq->cs); - Connection->Next = protseq->conn; - protseq->conn = Connection; + list_add_head(&protseq->listeners, &Connection->protseq_entry); + Connection->protseq = protseq; LeaveCriticalSection(&protseq->cs); return r; @@ -421,14 +296,12 @@ static RPC_STATUS rpcrt4_protseq_ncacn_np_open_endpoint(RpcServerProtseq *protse static void rpcrt4_conn_np_handoff(RpcConnection_np *old_npc, RpcConnection_np *new_npc) { - /* because of the way named pipes work, we'll transfer the connected pipe - * to the child, then reopen the server binding to continue listening */ + /* because of the way named pipes work, we'll transfer the connected pipe + * to the child, then reopen the server binding to continue listening */ - new_npc->pipe = old_npc->pipe; - new_npc->ovl = old_npc->ovl; - old_npc->pipe = 0; - memset(&old_npc->ovl, 0, sizeof(old_npc->ovl)); - old_npc->listening = FALSE; + new_npc->pipe = old_npc->pipe; + old_npc->pipe = 0; + assert(!old_npc->listen_event); } static RPC_STATUS rpcrt4_ncacn_np_handoff(RpcConnection *old_conn, RpcConnection *new_conn) @@ -507,80 +380,103 @@ static RPC_STATUS rpcrt4_ncalrpc_handoff(RpcConnection *old_conn, RpcConnection return status; } -static int rpcrt4_conn_np_read(RpcConnection *Connection, - void *buffer, unsigned int count) +static int rpcrt4_conn_np_read(RpcConnection *conn, void *buffer, unsigned int count) { - RpcConnection_np *npc = (RpcConnection_np *) Connection; - char *buf = buffer; - BOOL ret = TRUE; - unsigned int bytes_left = count; - OVERLAPPED ovl; + RpcConnection_np *connection = (RpcConnection_np *) conn; + HANDLE event; + NTSTATUS status; - ZeroMemory(&ovl, sizeof(ovl)); - ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL); + event = get_np_event(connection); + if (!event) + return -1; - while (bytes_left) - { - DWORD bytes_read; - ret = ReadFile(npc->pipe, buf, bytes_left, &bytes_read, &ovl); - if (!ret && GetLastError() == ERROR_IO_PENDING) - ret = GetOverlappedResult(npc->pipe, &ovl, &bytes_read, TRUE); - if (!ret && GetLastError() == ERROR_MORE_DATA) - ret = TRUE; - if (!ret || !bytes_read) - break; - bytes_left -= bytes_read; - buf += bytes_read; - } - CloseHandle(ovl.hEvent); - return ret ? count : -1; + if (connection->read_closed) + status = STATUS_CANCELLED; + else + status = NtReadFile(connection->pipe, event, NULL, NULL, &connection->io_status, buffer, count, NULL, NULL); + if (status == STATUS_PENDING) + { + /* check read_closed again before waiting to avoid a race */ + if (connection->read_closed) + { + IO_STATUS_BLOCK io_status; +#ifdef __REACTOS__ /* FIXME: We should also cancel I/O for other threads */ + NtCancelIoFile(connection->pipe, &io_status); +#else + NtCancelIoFileEx(connection->pipe, &connection->io_status, &io_status); +#endif + } + WaitForSingleObject(event, INFINITE); + status = connection->io_status.u.Status; + } + release_np_event(connection, event); + return status && status != STATUS_BUFFER_OVERFLOW ? -1 : connection->io_status.Information; } -static int rpcrt4_conn_np_write(RpcConnection *Connection, - const void *buffer, unsigned int count) +static int rpcrt4_conn_np_write(RpcConnection *conn, const void *buffer, unsigned int count) { - RpcConnection_np *npc = (RpcConnection_np *) Connection; - const char *buf = buffer; - BOOL ret = TRUE; - unsigned int bytes_left = count; - OVERLAPPED ovl; + RpcConnection_np *connection = (RpcConnection_np *) conn; + IO_STATUS_BLOCK io_status; + HANDLE event; + NTSTATUS status; - ZeroMemory(&ovl, sizeof(ovl)); - ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL); + event = get_np_event(connection); + if (!event) + return -1; - while (bytes_left) - { - DWORD bytes_written; - ret = WriteFile(npc->pipe, buf, bytes_left, &bytes_written, &ovl); - if (!ret && GetLastError() == ERROR_IO_PENDING) - ret = GetOverlappedResult(npc->pipe, &ovl, &bytes_written, TRUE); - if (!ret || !bytes_written) - break; - bytes_left -= bytes_written; - buf += bytes_written; - } - CloseHandle(ovl.hEvent); - return ret ? count : -1; + status = NtWriteFile(connection->pipe, event, NULL, NULL, &io_status, buffer, count, NULL, NULL); + if (status == STATUS_PENDING) + { + WaitForSingleObject(event, INFINITE); + status = io_status.u.Status; + } + release_np_event(connection, event); + if (status) + return -1; + + assert(io_status.Information == count); + return count; } -static int rpcrt4_conn_np_close(RpcConnection *Connection) +static int rpcrt4_conn_np_close(RpcConnection *conn) { - RpcConnection_np *npc = (RpcConnection_np *) Connection; - if (npc->pipe) { - FlushFileBuffers(npc->pipe); - CloseHandle(npc->pipe); - npc->pipe = 0; - } - if (npc->ovl.hEvent) { - CloseHandle(npc->ovl.hEvent); - npc->ovl.hEvent = 0; - } - return 0; + RpcConnection_np *connection = (RpcConnection_np *) conn; + if (connection->pipe) + { + FlushFileBuffers(connection->pipe); + CloseHandle(connection->pipe); + connection->pipe = 0; + } + if (connection->listen_event) + { + CloseHandle(connection->listen_event); + connection->listen_event = 0; + } + if (connection->event_cache) + { + CloseHandle(connection->event_cache); + connection->event_cache = 0; + } + return 0; } -static void rpcrt4_conn_np_cancel_call(RpcConnection *Connection) +static void rpcrt4_conn_np_close_read(RpcConnection *conn) { - /* FIXME: implement when named pipe writes use overlapped I/O */ + RpcConnection_np *connection = (RpcConnection_np*)conn; + IO_STATUS_BLOCK io_status; + + connection->read_closed = TRUE; +#ifdef __REACTOS__ /* FIXME: We should also cancel I/O for other threads */ + NtCancelIoFile(connection->pipe, &io_status); +#else + NtCancelIoFileEx(connection->pipe, &connection->io_status, &io_status); +#endif +} + +static void rpcrt4_conn_np_cancel_call(RpcConnection *conn) +{ + RpcConnection_np *connection = (RpcConnection_np *)conn; + CancelIoEx(connection->pipe, NULL); } static int rpcrt4_conn_np_wait_for_incoming_data(RpcConnection *Connection) @@ -752,7 +648,7 @@ typedef struct _RpcServerProtseq_np static RpcServerProtseq *rpcrt4_protseq_np_alloc(void) { - RpcServerProtseq_np *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps)); + RpcServerProtseq_np *ps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ps)); if (ps) ps->mgr_event = CreateEventW(NULL, FALSE, FALSE, NULL); return &ps->common; @@ -774,12 +670,35 @@ static void *rpcrt4_protseq_np_get_wait_array(RpcServerProtseq *protseq, void *p /* open and count connections */ *count = 1; - conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common); - while (conn) { - rpcrt4_conn_listen_pipe(conn); - if (conn->ovl.hEvent) - (*count)++; - conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common); + LIST_FOR_EACH_ENTRY(conn, &protseq->listeners, RpcConnection_np, common.protseq_entry) + { + if (!conn->listen_event) + { + NTSTATUS status; + HANDLE event; + + event = get_np_event(conn); + if (!event) + continue; + + status = NtFsControlFile(conn->pipe, event, NULL, NULL, &conn->io_status, FSCTL_PIPE_LISTEN, NULL, 0, NULL, 0); + switch (status) + { + case STATUS_SUCCESS: + case STATUS_PIPE_CONNECTED: + conn->io_status.u.Status = status; + SetEvent(event); + break; + case STATUS_PENDING: + break; + default: + ERR("pipe listen error %x\n", status); + continue; + } + + conn->listen_event = event; + } + (*count)++; } /* make array of connections */ @@ -796,11 +715,10 @@ static void *rpcrt4_protseq_np_get_wait_array(RpcServerProtseq *protseq, void *p objs[0] = npps->mgr_event; *count = 1; - conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common); - while (conn) { - if ((objs[*count] = conn->ovl.hEvent)) - (*count)++; - conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common); + LIST_FOR_EACH_ENTRY(conn, &protseq->listeners, RpcConnection_np, common.protseq_entry) + { + if (conn->listen_event) + objs[(*count)++] = conn->listen_event; } LeaveCriticalSection(&protseq->cs); return objs; @@ -816,7 +734,7 @@ static int rpcrt4_protseq_np_wait_for_new_connection(RpcServerProtseq *protseq, HANDLE b_handle; HANDLE *objs = wait_array; DWORD res; - RpcConnection *cconn; + RpcConnection *cconn = NULL; RpcConnection_np *conn; if (!objs) @@ -843,23 +761,27 @@ static int rpcrt4_protseq_np_wait_for_new_connection(RpcServerProtseq *protseq, b_handle = objs[res - WAIT_OBJECT_0]; /* find which connection got a RPC */ EnterCriticalSection(&protseq->cs); - conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common); - while (conn) { - if (b_handle == conn->ovl.hEvent) break; - conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common); - } - cconn = NULL; - if (conn) - RPCRT4_SpawnConnection(&cconn, &conn->common); - else - ERR("failed to locate connection for handle %p\n", b_handle); - LeaveCriticalSection(&protseq->cs); - if (cconn) + LIST_FOR_EACH_ENTRY(conn, &protseq->listeners, RpcConnection_np, common.protseq_entry) { - RPCRT4_new_client(cconn); - return 1; + if (b_handle == conn->listen_event) + { + release_np_event(conn, conn->listen_event); + conn->listen_event = NULL; + if (conn->io_status.u.Status == STATUS_SUCCESS || conn->io_status.u.Status == STATUS_PIPE_CONNECTED) + cconn = rpcrt4_spawn_connection(&conn->common); + else + ERR("listen failed %x\n", conn->io_status.u.Status); + break; + } } - else return -1; + LeaveCriticalSection(&protseq->cs); + if (!cconn) + { + ERR("failed to locate connection for handle %p\n", b_handle); + return -1; + } + RPCRT4_new_client(cconn); + return 1; } } @@ -1111,7 +1033,7 @@ static RPC_STATUS rpcrt4_ip_tcp_parse_top_of_tower(const unsigned char *tower_da in_addr.s_addr = ipv4_floor->ipv4addr; if (!inet_ntop(AF_INET, &in_addr, *networkaddr, INET_ADDRSTRLEN)) { - ERR("inet_ntop: %s\n", strerror(errno)); + ERR("inet_ntop: %u\n", WSAGetLastError()); I_RpcFree(*networkaddr); *networkaddr = NULL; if (endpoint) @@ -1130,75 +1052,10 @@ typedef struct _RpcConnection_tcp { RpcConnection common; int sock; -#ifdef HAVE_SOCKETPAIR - int cancel_fds[2]; -#else HANDLE sock_event; HANDLE cancel_event; -#endif } RpcConnection_tcp; -#ifdef HAVE_SOCKETPAIR - -static BOOL rpcrt4_sock_wait_init(RpcConnection_tcp *tcpc) -{ - if (socketpair(PF_UNIX, SOCK_STREAM, 0, tcpc->cancel_fds) < 0) - { - ERR("socketpair() failed: %s\n", strerror(errno)); - return FALSE; - } - return TRUE; -} - -static BOOL rpcrt4_sock_wait_for_recv(RpcConnection_tcp *tcpc) -{ - struct pollfd pfds[2]; - pfds[0].fd = tcpc->sock; - pfds[0].events = POLLIN; - pfds[1].fd = tcpc->cancel_fds[0]; - pfds[1].events = POLLIN; - if (poll(pfds, 2, -1 /* infinite */) == -1 && errno != EINTR) - { - ERR("poll() failed: %s\n", strerror(errno)); - return FALSE; - } - if (pfds[1].revents & POLLIN) /* canceled */ - { - char dummy; - read(pfds[1].fd, &dummy, sizeof(dummy)); - return FALSE; - } - return TRUE; -} - -static BOOL rpcrt4_sock_wait_for_send(RpcConnection_tcp *tcpc) -{ - struct pollfd pfd; - pfd.fd = tcpc->sock; - pfd.events = POLLOUT; - if (poll(&pfd, 1, -1 /* infinite */) == -1 && errno != EINTR) - { - ERR("poll() failed: %s\n", strerror(errno)); - return FALSE; - } - return TRUE; -} - -static void rpcrt4_sock_wait_cancel(RpcConnection_tcp *tcpc) -{ - char dummy = 1; - - write(tcpc->cancel_fds[1], &dummy, 1); -} - -static void rpcrt4_sock_wait_destroy(RpcConnection_tcp *tcpc) -{ - close(tcpc->cancel_fds[0]); - close(tcpc->cancel_fds[1]); -} - -#else /* HAVE_SOCKETPAIR */ - static BOOL rpcrt4_sock_wait_init(RpcConnection_tcp *tcpc) { static BOOL wsa_inited; @@ -1264,23 +1121,10 @@ static BOOL rpcrt4_sock_wait_for_send(RpcConnection_tcp *tcpc) } } -static void rpcrt4_sock_wait_cancel(RpcConnection_tcp *tcpc) -{ - SetEvent(tcpc->cancel_event); -} - -static void rpcrt4_sock_wait_destroy(RpcConnection_tcp *tcpc) -{ - CloseHandle(tcpc->sock_event); - CloseHandle(tcpc->cancel_event); -} - -#endif - static RpcConnection *rpcrt4_conn_tcp_alloc(void) { RpcConnection_tcp *tcpc; - tcpc = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcConnection_tcp)); + tcpc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcConnection_tcp)); if (tcpc == NULL) return NULL; tcpc->sock = -1; @@ -1347,20 +1191,20 @@ static RPC_STATUS rpcrt4_ncacn_ip_tcp_open(RpcConnection* Connection) sock = socket(ai_cur->ai_family, ai_cur->ai_socktype, ai_cur->ai_protocol); if (sock == -1) { - WARN("socket() failed: %s\n", strerror(errno)); + WARN("socket() failed: %u\n", WSAGetLastError()); continue; } if (0>connect(sock, ai_cur->ai_addr, ai_cur->ai_addrlen)) { - WARN("connect() failed: %s\n", strerror(errno)); + WARN("connect() failed: %u\n", WSAGetLastError()); closesocket(sock); continue; } /* RPC depends on having minimal latency so disable the Nagle algorithm */ val = 1; - setsockopt(sock, SOL_TCP, TCP_NODELAY, (char *)&val, sizeof(val)); + setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val)); nonblocking = 1; ioctlsocket(sock, FIONBIO, &nonblocking); @@ -1384,7 +1228,6 @@ static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *pr struct addrinfo *ai; struct addrinfo *ai_cur; struct addrinfo hints; - RpcConnection *first_connection = NULL; TRACE("(%p, %s)\n", protseq, endpoint); @@ -1434,7 +1277,7 @@ static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *pr sock = socket(ai_cur->ai_family, ai_cur->ai_socktype, ai_cur->ai_protocol); if (sock == -1) { - WARN("socket() failed: %s\n", strerror(errno)); + WARN("socket() failed: %u\n", WSAGetLastError()); status = RPC_S_CANT_CREATE_ENDPOINT; continue; } @@ -1442,9 +1285,9 @@ static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *pr ret = bind(sock, ai_cur->ai_addr, ai_cur->ai_addrlen); if (ret < 0) { - WARN("bind failed: %s\n", strerror(errno)); + WARN("bind failed: %u\n", WSAGetLastError()); closesocket(sock); - if (errno == EADDRINUSE) + if (WSAGetLastError() == WSAEADDRINUSE) status = RPC_S_DUPLICATE_ENDPOINT; else status = RPC_S_CANT_CREATE_ENDPOINT; @@ -1454,7 +1297,7 @@ static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *pr sa_len = sizeof(sa); if (getsockname(sock, (struct sockaddr *)&sa, &sa_len)) { - WARN("getsockname() failed: %s\n", strerror(errno)); + WARN("getsockname() failed: %u\n", WSAGetLastError()); closesocket(sock); status = RPC_S_CANT_CREATE_ENDPOINT; continue; @@ -1485,7 +1328,7 @@ static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *pr ret = listen(sock, protseq->MaxCalls); if (ret < 0) { - WARN("listen failed: %s\n", strerror(errno)); + WARN("listen failed: %u\n", WSAGetLastError()); RPCRT4_ReleaseConnection(&tcpc->common); status = RPC_S_OUT_OF_RESOURCES; continue; @@ -1504,35 +1347,20 @@ static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *pr continue; } - tcpc->common.Next = first_connection; - first_connection = &tcpc->common; + EnterCriticalSection(&protseq->cs); + list_add_tail(&protseq->listeners, &tcpc->common.protseq_entry); + tcpc->common.protseq = protseq; + LeaveCriticalSection(&protseq->cs); + + freeaddrinfo(ai); /* since IPv4 and IPv6 share the same port space, we only need one * successful bind to listen for both */ - break; - } - - freeaddrinfo(ai); - - /* if at least one connection was created for an endpoint then - * return success */ - if (first_connection) - { - RpcConnection *conn; - - /* find last element in list */ - for (conn = first_connection; conn->Next; conn = conn->Next) - ; - - EnterCriticalSection(&protseq->cs); - conn->Next = protseq->conn; - protseq->conn = first_connection; - LeaveCriticalSection(&protseq->cs); - TRACE("listening on %s\n", endpoint); return RPC_S_OK; } + freeaddrinfo(ai); ERR("couldn't listen on port %s\n", endpoint); return status; } @@ -1582,11 +1410,11 @@ static int rpcrt4_conn_tcp_read(RpcConnection *Connection, return -1; else if (r > 0) bytes_read += r; - else if (errno == EINTR) + else if (WSAGetLastError() == WSAEINTR) continue; - else if (errno != EAGAIN) + else if (WSAGetLastError() != WSAEWOULDBLOCK) { - WARN("recv() failed: %s\n", strerror(errno)); + WARN("recv() failed: %u\n", WSAGetLastError()); return -1; } else @@ -1609,9 +1437,9 @@ static int rpcrt4_conn_tcp_write(RpcConnection *Connection, int r = send(tcpc->sock, (const char *)buffer + bytes_written, count - bytes_written, 0); if (r >= 0) bytes_written += r; - else if (errno == EINTR) + else if (WSAGetLastError() == WSAEINTR) continue; - else if (errno != EAGAIN) + else if (WSAGetLastError() != WSAEWOULDBLOCK) return -1; else { @@ -1623,24 +1451,33 @@ static int rpcrt4_conn_tcp_write(RpcConnection *Connection, return bytes_written; } -static int rpcrt4_conn_tcp_close(RpcConnection *Connection) +static int rpcrt4_conn_tcp_close(RpcConnection *conn) { - RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection; + RpcConnection_tcp *connection = (RpcConnection_tcp *) conn; - TRACE("%d\n", tcpc->sock); + TRACE("%d\n", connection->sock); - if (tcpc->sock != -1) - closesocket(tcpc->sock); - tcpc->sock = -1; - rpcrt4_sock_wait_destroy(tcpc); - return 0; + if (connection->sock != -1) + closesocket(connection->sock); + connection->sock = -1; + CloseHandle(connection->sock_event); + CloseHandle(connection->cancel_event); + return 0; } -static void rpcrt4_conn_tcp_cancel_call(RpcConnection *Connection) +static void rpcrt4_conn_tcp_close_read(RpcConnection *conn) { - RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection; - TRACE("%p\n", Connection); - rpcrt4_sock_wait_cancel(tcpc); + RpcConnection_tcp *connection = (RpcConnection_tcp *) conn; + shutdown(connection->sock, SD_RECEIVE); +} + +static void rpcrt4_conn_tcp_cancel_call(RpcConnection *conn) +{ + RpcConnection_tcp *connection = (RpcConnection_tcp *) conn; + + TRACE("%p\n", connection); + + SetEvent(connection->cancel_event); } static RPC_STATUS rpcrt4_conn_tcp_is_server_listening(const char *endpoint) @@ -1668,149 +1505,6 @@ static size_t rpcrt4_ncacn_ip_tcp_get_top_of_tower(unsigned char *tower_data, EPM_PROTOCOL_TCP, endpoint); } -#ifdef HAVE_SOCKETPAIR - -typedef struct _RpcServerProtseq_sock -{ - RpcServerProtseq common; - int mgr_event_rcv; - int mgr_event_snd; -} RpcServerProtseq_sock; - -static RpcServerProtseq *rpcrt4_protseq_sock_alloc(void) -{ - RpcServerProtseq_sock *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps)); - if (ps) - { - int fds[2]; - if (!socketpair(PF_UNIX, SOCK_DGRAM, 0, fds)) - { - fcntl(fds[0], F_SETFL, O_NONBLOCK); - fcntl(fds[1], F_SETFL, O_NONBLOCK); - ps->mgr_event_rcv = fds[0]; - ps->mgr_event_snd = fds[1]; - } - else - { - ERR("socketpair failed with error %s\n", strerror(errno)); - HeapFree(GetProcessHeap(), 0, ps); - return NULL; - } - } - return &ps->common; -} - -static void rpcrt4_protseq_sock_signal_state_changed(RpcServerProtseq *protseq) -{ - RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common); - char dummy = 1; - write(sockps->mgr_event_snd, &dummy, sizeof(dummy)); -} - -static void *rpcrt4_protseq_sock_get_wait_array(RpcServerProtseq *protseq, void *prev_array, unsigned int *count) -{ - struct pollfd *poll_info = prev_array; - RpcConnection_tcp *conn; - RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common); - - EnterCriticalSection(&protseq->cs); - - /* open and count connections */ - *count = 1; - conn = (RpcConnection_tcp *)protseq->conn; - while (conn) { - if (conn->sock != -1) - (*count)++; - conn = (RpcConnection_tcp *)conn->common.Next; - } - - /* make array of connections */ - if (poll_info) - poll_info = HeapReAlloc(GetProcessHeap(), 0, poll_info, *count*sizeof(*poll_info)); - else - poll_info = HeapAlloc(GetProcessHeap(), 0, *count*sizeof(*poll_info)); - if (!poll_info) - { - ERR("couldn't allocate poll_info\n"); - LeaveCriticalSection(&protseq->cs); - return NULL; - } - - poll_info[0].fd = sockps->mgr_event_rcv; - poll_info[0].events = POLLIN; - *count = 1; - conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common); - while (conn) { - if (conn->sock != -1) - { - poll_info[*count].fd = conn->sock; - poll_info[*count].events = POLLIN; - (*count)++; - } - conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common); - } - LeaveCriticalSection(&protseq->cs); - return poll_info; -} - -static void rpcrt4_protseq_sock_free_wait_array(RpcServerProtseq *protseq, void *array) -{ - HeapFree(GetProcessHeap(), 0, array); -} - -static int rpcrt4_protseq_sock_wait_for_new_connection(RpcServerProtseq *protseq, unsigned int count, void *wait_array) -{ - struct pollfd *poll_info = wait_array; - int ret; - unsigned int i; - RpcConnection *cconn; - RpcConnection_tcp *conn; - - if (!poll_info) - return -1; - - ret = poll(poll_info, count, -1); - if (ret < 0) - { - ERR("poll failed with error %d\n", ret); - return -1; - } - - for (i = 0; i < count; i++) - if (poll_info[i].revents & POLLIN) - { - /* RPC server event */ - if (i == 0) - { - char dummy; - read(poll_info[0].fd, &dummy, sizeof(dummy)); - return 0; - } - - /* find which connection got a RPC */ - EnterCriticalSection(&protseq->cs); - conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common); - while (conn) { - if (poll_info[i].fd == conn->sock) break; - conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common); - } - cconn = NULL; - if (conn) - RPCRT4_SpawnConnection(&cconn, &conn->common); - else - ERR("failed to locate connection for fd %d\n", poll_info[i].fd); - LeaveCriticalSection(&protseq->cs); - if (cconn) - RPCRT4_new_client(cconn); - else - return -1; - } - - return 1; -} - -#else /* HAVE_SOCKETPAIR */ - typedef struct _RpcServerProtseq_sock { RpcServerProtseq common; @@ -1819,7 +1513,7 @@ typedef struct _RpcServerProtseq_sock static RpcServerProtseq *rpcrt4_protseq_sock_alloc(void) { - RpcServerProtseq_sock *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps)); + RpcServerProtseq_sock *ps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ps)); if (ps) { static BOOL wsa_inited; @@ -1852,12 +1546,10 @@ static void *rpcrt4_protseq_sock_get_wait_array(RpcServerProtseq *protseq, void /* open and count connections */ *count = 1; - conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common); - while (conn) + LIST_FOR_EACH_ENTRY(conn, &protseq->listeners, RpcConnection_tcp, common.protseq_entry) { if (conn->sock != -1) (*count)++; - conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common); } /* make array of connections */ @@ -1874,8 +1566,7 @@ static void *rpcrt4_protseq_sock_get_wait_array(RpcServerProtseq *protseq, void objs[0] = sockps->mgr_event; *count = 1; - conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common); - while (conn) + LIST_FOR_EACH_ENTRY(conn, &protseq->listeners, RpcConnection_tcp, common.protseq_entry) { if (conn->sock != -1) { @@ -1888,7 +1579,6 @@ static void *rpcrt4_protseq_sock_get_wait_array(RpcServerProtseq *protseq, void (*count)++; } } - conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common); } LeaveCriticalSection(&protseq->cs); return objs; @@ -1904,7 +1594,7 @@ static int rpcrt4_protseq_sock_wait_for_new_connection(RpcServerProtseq *protseq HANDLE b_handle; HANDLE *objs = wait_array; DWORD res; - RpcConnection *cconn; + RpcConnection *cconn = NULL; RpcConnection_tcp *conn; if (!objs) @@ -1921,38 +1611,34 @@ static int rpcrt4_protseq_sock_wait_for_new_connection(RpcServerProtseq *protseq if (res == WAIT_OBJECT_0) return 0; - else if (res == WAIT_FAILED) + if (res == WAIT_FAILED) { ERR("wait failed with error %d\n", GetLastError()); return -1; } - else - { - b_handle = objs[res - WAIT_OBJECT_0]; - /* find which connection got a RPC */ - EnterCriticalSection(&protseq->cs); - conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common); - while (conn) - { - if (b_handle == conn->sock_event) break; - conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common); - } - cconn = NULL; - if (conn) - RPCRT4_SpawnConnection(&cconn, &conn->common); - else - ERR("failed to locate connection for handle %p\n", b_handle); - LeaveCriticalSection(&protseq->cs); - if (cconn) - { - RPCRT4_new_client(cconn); - return 1; - } - else return -1; - } -} -#endif /* HAVE_SOCKETPAIR */ + b_handle = objs[res - WAIT_OBJECT_0]; + + /* find which connection got a RPC */ + EnterCriticalSection(&protseq->cs); + LIST_FOR_EACH_ENTRY(conn, &protseq->listeners, RpcConnection_tcp, common.protseq_entry) + { + if (b_handle == conn->sock_event) + { + cconn = rpcrt4_spawn_connection(&conn->common); + break; + } + } + LeaveCriticalSection(&protseq->cs); + if (!cconn) + { + ERR("failed to locate connection for handle %p\n", b_handle); + return -1; + } + + RPCRT4_new_client(cconn); + return 1; +} static RPC_STATUS rpcrt4_ncacn_ip_tcp_parse_top_of_tower(const unsigned char *tower_data, size_t tower_size, @@ -2085,7 +1771,6 @@ static RpcConnection *rpcrt4_ncacn_http_alloc(void) httpc->cancel_event = CreateEventW(NULL, FALSE, FALSE, NULL); httpc->async_data->refs = 1; httpc->async_data->inet_buffers.dwStructSize = sizeof(INTERNET_BUFFERSW); - httpc->async_data->inet_buffers.lpvBuffer = NULL; InitializeCriticalSection(&httpc->async_data->cs); httpc->async_data->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RpcHttpAsyncData.cs"); return &httpc->common; @@ -3411,6 +3096,11 @@ static int rpcrt4_ncacn_http_close(RpcConnection *Connection) return 0; } +static void rpcrt4_ncacn_http_close_read(RpcConnection *conn) +{ + rpcrt4_ncacn_http_close(conn); /* FIXME */ +} + static void rpcrt4_ncacn_http_cancel_call(RpcConnection *Connection) { RpcConnection_http *httpc = (RpcConnection_http *) Connection; @@ -3464,6 +3154,7 @@ static const struct connection_ops conn_protseq_list[] = { rpcrt4_conn_np_read, rpcrt4_conn_np_write, rpcrt4_conn_np_close, + rpcrt4_conn_np_close_read, rpcrt4_conn_np_cancel_call, rpcrt4_ncacn_np_is_server_listening, rpcrt4_conn_np_wait_for_incoming_data, @@ -3485,6 +3176,7 @@ static const struct connection_ops conn_protseq_list[] = { rpcrt4_conn_np_read, rpcrt4_conn_np_write, rpcrt4_conn_np_close, + rpcrt4_conn_np_close_read, rpcrt4_conn_np_cancel_call, rpcrt4_ncalrpc_np_is_server_listening, rpcrt4_conn_np_wait_for_incoming_data, @@ -3506,6 +3198,7 @@ static const struct connection_ops conn_protseq_list[] = { rpcrt4_conn_tcp_read, rpcrt4_conn_tcp_write, rpcrt4_conn_tcp_close, + rpcrt4_conn_tcp_close_read, rpcrt4_conn_tcp_cancel_call, rpcrt4_conn_tcp_is_server_listening, rpcrt4_conn_tcp_wait_for_incoming_data, @@ -3527,6 +3220,7 @@ static const struct connection_ops conn_protseq_list[] = { rpcrt4_ncacn_http_read, rpcrt4_ncacn_http_write, rpcrt4_ncacn_http_close, + rpcrt4_ncacn_http_close_read, rpcrt4_ncacn_http_cancel_call, rpcrt4_ncacn_http_is_server_listening, rpcrt4_ncacn_http_wait_for_incoming_data, @@ -3631,8 +3325,6 @@ RPC_STATUS RPCRT4_CreateConnection(RpcConnection** Connection, BOOL server, NewConnection = ops->alloc(); NewConnection->ref = 1; - NewConnection->Next = NULL; - NewConnection->server_binding = NULL; NewConnection->server = server; NewConnection->ops = ops; NewConnection->NetworkAddr = RPCRT4_strdupA(NetworkAddr); @@ -3640,22 +3332,17 @@ RPC_STATUS RPCRT4_CreateConnection(RpcConnection** Connection, BOOL server, NewConnection->NetworkOptions = RPCRT4_strdupW(NetworkOptions); NewConnection->CookieAuth = RPCRT4_strdupW(CookieAuth); NewConnection->MaxTransmissionSize = RPC_MAX_PACKET_SIZE; - memset(&NewConnection->ActiveInterface, 0, sizeof(NewConnection->ActiveInterface)); NewConnection->NextCallId = 1; SecInvalidateHandle(&NewConnection->ctx); - memset(&NewConnection->exp, 0, sizeof(NewConnection->exp)); - NewConnection->attr = 0; if (AuthInfo) RpcAuthInfo_AddRef(AuthInfo); NewConnection->AuthInfo = AuthInfo; NewConnection->auth_context_id = InterlockedIncrement( &next_id ); - NewConnection->encryption_auth_len = 0; - NewConnection->signature_auth_len = 0; if (QOS) RpcQualityOfService_AddRef(QOS); NewConnection->QOS = QOS; list_init(&NewConnection->conn_pool_entry); - NewConnection->async_state = NULL; + list_init(&NewConnection->protseq_entry); TRACE("connection: %p\n", NewConnection); *Connection = NewConnection; @@ -3663,16 +3350,26 @@ RPC_STATUS RPCRT4_CreateConnection(RpcConnection** Connection, BOOL server, return RPC_S_OK; } -static RPC_STATUS RPCRT4_SpawnConnection(RpcConnection** Connection, RpcConnection* OldConnection) +static RpcConnection *rpcrt4_spawn_connection(RpcConnection *old_connection) { - RPC_STATUS err; + RpcConnection *connection; + RPC_STATUS err; - err = RPCRT4_CreateConnection(Connection, OldConnection->server, rpcrt4_conn_get_name(OldConnection), - OldConnection->NetworkAddr, OldConnection->Endpoint, NULL, - OldConnection->AuthInfo, OldConnection->QOS, OldConnection->CookieAuth); - if (err == RPC_S_OK) - rpcrt4_conn_handoff(OldConnection, *Connection); - return err; + err = RPCRT4_CreateConnection(&connection, old_connection->server, rpcrt4_conn_get_name(old_connection), + old_connection->NetworkAddr, old_connection->Endpoint, NULL, + old_connection->AuthInfo, old_connection->QOS, old_connection->CookieAuth); + if (err != RPC_S_OK) + return NULL; + + rpcrt4_conn_handoff(old_connection, connection); + if (old_connection->protseq) + { + EnterCriticalSection(&old_connection->protseq->cs); + connection->protseq = old_connection->protseq; + list_add_tail(&old_connection->protseq->connections, &connection->protseq_entry); + LeaveCriticalSection(&old_connection->protseq->cs); + } + return connection; } RpcConnection *RPCRT4_GrabConnection( RpcConnection *conn ) @@ -3698,6 +3395,13 @@ RPC_STATUS RPCRT4_ReleaseConnection(RpcConnection* Connection) /* server-only */ if (Connection->server_binding) RPCRT4_ReleaseBinding(Connection->server_binding); + if (Connection->protseq) + { + EnterCriticalSection(&Connection->protseq->cs); + list_remove(&Connection->protseq_entry); + LeaveCriticalSection(&Connection->protseq->cs); + } + HeapFree(GetProcessHeap(), 0, Connection); return RPC_S_OK; } diff --git a/reactos/media/doc/README.WINE b/reactos/media/doc/README.WINE index 9188d9a2f5c..96f3ab000a1 100644 --- a/reactos/media/doc/README.WINE +++ b/reactos/media/doc/README.WINE @@ -160,7 +160,7 @@ reactos/dll/win32/rasapi32 # Synced to WineStaging-1.9.11 reactos/dll/win32/resutils # Synced to WineStaging-1.9.11 reactos/dll/win32/riched20 # Synced to WineStaging-2.9 reactos/dll/win32/riched32 # Synced to WineStaging-1.9.11 -reactos/dll/win32/rpcrt4 # Synced to WineStaging-2.2 +reactos/dll/win32/rpcrt4 # Synced to WineStaging-2.9 reactos/dll/win32/rsabase # Synced to WineStaging-1.9.11 reactos/dll/win32/rsaenh # Synced to WineStaging-2.9 reactos/dll/win32/sccbase # Synced to WineStaging-1.9.11