ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ntdll: Implement IOCTL_AFD_RECV. 

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=50366
Signed-off-by: Zebediah Figura <z.figura12@gmail.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Zebediah Figura 2021-05-21 22:08:48 -05:00 committed by Alexandre Julliard
parent 5d3fde087a
commit b8f4061df0
12 changed files with 481 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dlls/ntdll/Makefile.in
View File

@ -57,6 +57,7 @@ C_SRCS = \
unix/signal_arm64.c \
unix/signal_i386.c \
unix/signal_x86_64.c \
unix/socket.c \
unix/sync.c \
unix/system.c \
unix/tape.c \

7
dlls/ntdll/unix/file.c
View File

@ -4645,7 +4645,7 @@ struct async_irp
static struct async_fileio *fileio_freelist;
static void release_fileio( struct async_fileio *io )
void release_fileio( struct async_fileio *io )
{
for (;;)
{
@ -4655,7 +4655,7 @@ static void release_fileio( struct async_fileio *io )
}
}
static struct async_fileio *alloc_fileio( DWORD size, async_callback_t callback, HANDLE handle )
struct async_fileio *alloc_fileio( DWORD size, async_callback_t callback, HANDLE handle )
{
/* first free remaining previous fileinfos */
struct async_fileio *io = InterlockedExchangePointer( (void **)&fileio_freelist, NULL );
@ -5729,6 +5729,9 @@ NTSTATUS WINAPI NtDeviceIoControlFile( HANDLE handle, HANDLE event, PIO_APC_ROUT
switch (device)
{
case FILE_DEVICE_BEEP:
status = sock_ioctl( handle, event, apc, apc_context, io, code, in_buffer, in_size, out_buffer, out_size );
break;
case FILE_DEVICE_DISK:
case FILE_DEVICE_CD_ROM:
case FILE_DEVICE_DVD:

313
dlls/ntdll/unix/socket.c Normal file
View File

@ -0,0 +1,313 @@
/*
* Windows sockets
*
* Copyright 2021 Zebediah Figura for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if 0
#pragma makedep unix
#endif
#include "config.h"
#include <errno.h>
#include <unistd.h>
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "winioctl.h"
#define USE_WS_PREFIX
#include "winsock2.h"
#include "wine/afd.h"
#include "unix_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(winsock);
static async_data_t server_async( HANDLE handle, struct async_fileio *user, HANDLE event,
PIO_APC_ROUTINE apc, void *apc_context, IO_STATUS_BLOCK *io )
{
async_data_t async;
async.handle = wine_server_obj_handle( handle );
async.user = wine_server_client_ptr( user );
async.iosb = wine_server_client_ptr( io );
async.event = wine_server_obj_handle( event );
async.apc = wine_server_client_ptr( apc );
async.apc_context = wine_server_client_ptr( apc_context );
return async;
}
static NTSTATUS wait_async( HANDLE handle, BOOL alertable )
{
return NtWaitForSingleObject( handle, alertable, NULL );
}
struct async_recv_ioctl
{
struct async_fileio io;
int unix_flags;
unsigned int count;
struct iovec iov[1];
};
static NTSTATUS sock_errno_to_status( int err )
{
switch (err)
{
case EBADF: return STATUS_INVALID_HANDLE;
case EBUSY: return STATUS_DEVICE_BUSY;
case EPERM:
case EACCES: return STATUS_ACCESS_DENIED;
case EFAULT: return STATUS_ACCESS_VIOLATION;
case EINVAL: return STATUS_INVALID_PARAMETER;
case ENFILE:
case EMFILE: return STATUS_TOO_MANY_OPENED_FILES;
case EINPROGRESS:
case EWOULDBLOCK: return STATUS_DEVICE_NOT_READY;
case EALREADY: return STATUS_NETWORK_BUSY;
case ENOTSOCK: return STATUS_OBJECT_TYPE_MISMATCH;
case EDESTADDRREQ: return STATUS_INVALID_PARAMETER;
case EMSGSIZE: return STATUS_BUFFER_OVERFLOW;
case EPROTONOSUPPORT:
case ESOCKTNOSUPPORT:
case EPFNOSUPPORT:
case EAFNOSUPPORT:
case EPROTOTYPE: return STATUS_NOT_SUPPORTED;
case ENOPROTOOPT: return STATUS_INVALID_PARAMETER;
case EOPNOTSUPP: return STATUS_NOT_SUPPORTED;
case EADDRINUSE: return STATUS_SHARING_VIOLATION;
case EADDRNOTAVAIL: return STATUS_INVALID_PARAMETER;
case ECONNREFUSED: return STATUS_CONNECTION_REFUSED;
case ESHUTDOWN: return STATUS_PIPE_DISCONNECTED;
case ENOTCONN: return STATUS_INVALID_CONNECTION;
case ETIMEDOUT: return STATUS_IO_TIMEOUT;
case ENETUNREACH: return STATUS_NETWORK_UNREACHABLE;
case EHOSTUNREACH: return STATUS_HOST_UNREACHABLE;
case ENETDOWN: return STATUS_NETWORK_BUSY;
case EPIPE:
case ECONNRESET: return STATUS_CONNECTION_RESET;
case ECONNABORTED: return STATUS_CONNECTION_ABORTED;
case EISCONN: return STATUS_CONNECTION_ACTIVE;
case 0: return STATUS_SUCCESS;
default:
FIXME( "unknown errno %d\n", err );
return STATUS_UNSUCCESSFUL;
}
}
extern ssize_t CDECL __wine_locked_recvmsg( int fd, struct msghdr *hdr, int flags );
static NTSTATUS try_recv( int fd, struct async_recv_ioctl *async, ULONG_PTR *size )
{
#ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
char control_buffer[512];
#endif
struct msghdr hdr;
ssize_t ret;
memset( &hdr, 0, sizeof(hdr) );
hdr.msg_iov = async->iov;
hdr.msg_iovlen = async->count;
#ifndef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS
hdr.msg_control = control_buffer;
hdr.msg_controllen = sizeof(control_buffer);
#endif
while ((ret = __wine_locked_recvmsg( fd, &hdr, async->unix_flags )) < 0 && errno == EINTR);
if (ret < 0)
{
/* Unix-like systems return EINVAL when attempting to read OOB data from
* an empty socket buffer; Windows returns WSAEWOULDBLOCK. */
if ((async->unix_flags & MSG_OOB) && errno == EINVAL)
errno = EWOULDBLOCK;
if (errno != EWOULDBLOCK) WARN( "recvmsg: %s\n", strerror( errno ) );
return sock_errno_to_status( errno );
}
*size = ret;
return (hdr.msg_flags & MSG_TRUNC) ? STATUS_BUFFER_OVERFLOW : STATUS_SUCCESS;
}
static NTSTATUS async_recv_proc( void *user, IO_STATUS_BLOCK *io, NTSTATUS status )
{
struct async_recv_ioctl *async = user;
ULONG_PTR information = 0;
int fd, needs_close;
TRACE( "%#x\n", status );
if (status == STATUS_ALERTED)
{
if ((status = server_get_unix_fd( async->io.handle, 0, &fd, &needs_close, NULL, NULL )))
return status;
status = try_recv( fd, async, &information );
TRACE( "got status %#x, %#lx bytes read\n", status, information );
if (status == STATUS_DEVICE_NOT_READY)
status = STATUS_PENDING;
if (needs_close) close( fd );
}
if (status != STATUS_PENDING)
{
io->Status = status;
io->Information = information;
release_fileio( &async->io );
}
return status;
}
static NTSTATUS sock_recv( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user, IO_STATUS_BLOCK *io,
int fd, const WSABUF *buffers, unsigned int count, int unix_flags, int force_async )
{
struct async_recv_ioctl *async;
ULONG_PTR information;
HANDLE wait_handle;
DWORD async_size;
NTSTATUS status;
unsigned int i;
ULONG options;
async_size = offsetof( struct async_recv_ioctl, iov[count] );
if (!(async = (struct async_recv_ioctl *)alloc_fileio( async_size, async_recv_proc, handle )))
return STATUS_NO_MEMORY;
async->count = count;
for (i = 0; i < count; ++i)
{
async->iov[i].iov_base = buffers[i].buf;
async->iov[i].iov_len = buffers[i].len;
}
async->unix_flags = unix_flags;
status = try_recv( fd, async, &information );
if (status != STATUS_SUCCESS && status != STATUS_BUFFER_OVERFLOW && status != STATUS_DEVICE_NOT_READY)
{
release_fileio( &async->io );
return status;
}
if (status == STATUS_DEVICE_NOT_READY && force_async)
status = STATUS_PENDING;
if (!NT_ERROR(status))
{
io->Status = status;
io->Information = information;
}
SERVER_START_REQ( recv_socket )
{
req->status = status;
req->total = information;
req->async = server_async( handle, &async->io, event, apc, apc_user, io );
status = wine_server_call( req );
wait_handle = wine_server_ptr_handle( reply->wait );
options = reply->options;
}
SERVER_END_REQ;
if (status != STATUS_PENDING) release_fileio( &async->io );
if (wait_handle) status = wait_async( wait_handle, options & FILE_SYNCHRONOUS_IO_ALERT );
return status;
}
NTSTATUS sock_ioctl( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user, IO_STATUS_BLOCK *io,
ULONG code, void *in_buffer, ULONG in_size, void *out_buffer, ULONG out_size )
{
int fd, needs_close;
NTSTATUS status;
TRACE( "handle %p, code %#x, in_buffer %p, in_size %u, out_buffer %p, out_size %u\n",
handle, code, in_buffer, in_size, out_buffer, out_size );
if ((status = server_get_unix_fd( handle, 0, &fd, &needs_close, NULL, NULL )))
return status;
switch (code)
{
case IOCTL_AFD_LISTEN:
{
const struct afd_listen_params *params = in_buffer;
TRACE( "backlog %u\n", params->backlog );
if (out_size) FIXME( "unexpected output size %u\n", out_size );
if (params->unknown1) FIXME( "listen: got unknown1 %#x\n", params->unknown1 );
if (params->unknown2) FIXME( "listen: got unknown2 %#x\n", params->unknown2 );
status = STATUS_BAD_DEVICE_TYPE;
break;
}
case IOCTL_AFD_RECV:
{
const struct afd_recv_params *params = in_buffer;
int unix_flags = 0;
if (out_size) FIXME( "unexpected output size %u\n", out_size );
if (in_size < sizeof(struct afd_recv_params))
{
status = STATUS_INVALID_PARAMETER;
break;
}
if ((params->msg_flags & (AFD_MSG_NOT_OOB | AFD_MSG_OOB)) == 0 ||
(params->msg_flags & (AFD_MSG_NOT_OOB | AFD_MSG_OOB)) == (AFD_MSG_NOT_OOB | AFD_MSG_OOB))
{
status = STATUS_INVALID_PARAMETER;
break;
}
if (params->msg_flags & ~(AFD_MSG_NOT_OOB | AFD_MSG_OOB | AFD_MSG_PEEK | AFD_MSG_WAITALL))
FIXME( "unknown msg_flags %#x\n", params->msg_flags );
if (params->recv_flags & ~AFD_RECV_FORCE_ASYNC)
FIXME( "unknown recv_flags %#x\n", params->recv_flags );
if (params->msg_flags & AFD_MSG_OOB)
unix_flags |= MSG_OOB;
if (params->msg_flags & AFD_MSG_PEEK)
unix_flags |= MSG_PEEK;
if (params->msg_flags & AFD_MSG_WAITALL)
FIXME( "MSG_WAITALL is not supported\n" );
status = sock_recv( handle, event, apc, apc_user, io, fd, params->buffers, params->count,
unix_flags, !!(params->recv_flags & AFD_RECV_FORCE_ASYNC) );
break;
}
default:
{
FIXME( "Unknown ioctl %#x (device %#x, access %#x, function %#x, method %#x)\n",
code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3 );
status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
}
if (needs_close) close( fd );
return status;
}

4
dlls/ntdll/unix/unix_private.h
View File

@ -257,10 +257,14 @@ extern NTSTATUS serial_DeviceIoControl( HANDLE device, HANDLE event, PIO_APC_ROU
IO_STATUS_BLOCK *io, ULONG code, void *in_buffer,
ULONG in_size, void *out_buffer, ULONG out_size ) DECLSPEC_HIDDEN;
extern NTSTATUS serial_FlushBuffersFile( int fd ) DECLSPEC_HIDDEN;
extern NTSTATUS sock_ioctl( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user, IO_STATUS_BLOCK *io,
ULONG code, void *in_buffer, ULONG in_size, void *out_buffer, ULONG out_size ) DECLSPEC_HIDDEN;
extern NTSTATUS tape_DeviceIoControl( HANDLE device, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
IO_STATUS_BLOCK *io, ULONG code, void *in_buffer,
ULONG in_size, void *out_buffer, ULONG out_size ) DECLSPEC_HIDDEN;
extern struct async_fileio *alloc_fileio( DWORD size, async_callback_t callback, HANDLE handle ) DECLSPEC_HIDDEN;
extern void release_fileio( struct async_fileio *io ) DECLSPEC_HIDDEN;
extern NTSTATUS errno_to_status( int err ) DECLSPEC_HIDDEN;
extern BOOL get_redirect( OBJECT_ATTRIBUTES *attr, UNICODE_STRING *redir ) DECLSPEC_HIDDEN;
extern NTSTATUS nt_to_unix_file_name( const OBJECT_ATTRIBUTES *attr, char **name_ret, UINT disposition ) DECLSPEC_HIDDEN;

17
include/wine/afd.h
View File

@ -21,10 +21,12 @@
#ifndef __WINE_WINE_AFD_H
#define __WINE_WINE_AFD_H
#include <winternl.h>
#include <winioctl.h>
#include "wine/server_protocol.h"
#define IOCTL_AFD_LISTEN CTL_CODE(FILE_DEVICE_BEEP, 0x802, METHOD_NEITHER, FILE_ANY_ACCESS)
#define IOCTL_AFD_RECV CTL_CODE(FILE_DEVICE_BEEP, 0x805, METHOD_NEITHER, FILE_ANY_ACCESS)
struct afd_listen_params
{
@ -33,6 +35,21 @@ struct afd_listen_params
int unknown2;
};
#define AFD_RECV_FORCE_ASYNC 0x2
#define AFD_MSG_NOT_OOB 0x0020
#define AFD_MSG_OOB 0x0040
#define AFD_MSG_PEEK 0x0080
#define AFD_MSG_WAITALL 0x4000
struct afd_recv_params
{
const WSABUF *buffers;
unsigned int count;
int recv_flags;
int msg_flags;
};
#define IOCTL_AFD_WINE_CREATE CTL_CODE(FILE_DEVICE_NETWORK, 200, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_AFD_WINE_ACCEPT CTL_CODE(FILE_DEVICE_NETWORK, 201, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_AFD_WINE_ACCEPT_INTO CTL_CODE(FILE_DEVICE_NETWORK, 202, METHOD_BUFFERED, FILE_ANY_ACCESS)

22
include/wine/server_protocol.h
View File

@ -1818,6 +1818,23 @@ struct set_socket_deferred_reply
struct recv_socket_request
{
struct request_header __header;
char __pad_12[4];
async_data_t async;
unsigned int status;
unsigned int total;
};
struct recv_socket_reply
{
struct reply_header __header;
obj_handle_t wait;
unsigned int options;
};
struct get_next_console_request_request
{
struct request_header __header;
@ -5467,6 +5484,7 @@ enum request
REQ_get_socket_info,
REQ_enable_socket_event,
REQ_set_socket_deferred,
REQ_recv_socket,
REQ_get_next_console_request,
REQ_read_directory_changes,
REQ_read_change,
@ -5748,6 +5766,7 @@ union generic_request
struct get_socket_info_request get_socket_info_request;
struct enable_socket_event_request enable_socket_event_request;
struct set_socket_deferred_request set_socket_deferred_request;
struct recv_socket_request recv_socket_request;
struct get_next_console_request_request get_next_console_request_request;
struct read_directory_changes_request read_directory_changes_request;
struct read_change_request read_change_request;
@ -6027,6 +6046,7 @@ union generic_reply
struct get_socket_info_reply get_socket_info_reply;
struct enable_socket_event_reply enable_socket_event_reply;
struct set_socket_deferred_reply set_socket_deferred_reply;
struct recv_socket_reply recv_socket_reply;
struct get_next_console_request_reply get_next_console_request_reply;
struct read_directory_changes_reply read_directory_changes_reply;
struct read_change_reply read_change_reply;
@ -6247,7 +6267,7 @@ union generic_reply
/* ### protocol_version begin ### */
#define SERVER_PROTOCOL_VERSION 702
#define SERVER_PROTOCOL_VERSION 703
/* ### protocol_version end ### */

6
server/fd.c
View File

@ -2076,6 +2076,12 @@ unsigned int get_fd_options( struct fd *fd )
return fd->options;
}
/* retrieve the completion flags for the fd */
unsigned int get_fd_comp_flags( struct fd *fd )
{
return fd->comp_flags;
}
/* check if fd is in overlapped mode */
int is_fd_overlapped( struct fd *fd )
{

1
server/file.h
View File

@ -89,6 +89,7 @@ extern struct fd *get_fd_object_for_mapping( struct fd *fd, unsigned int access,
extern void *get_fd_user( struct fd *fd );
extern void set_fd_user( struct fd *fd, const struct fd_ops *ops, struct object *user );
extern unsigned int get_fd_options( struct fd *fd );
extern unsigned int get_fd_comp_flags( struct fd *fd );
extern int is_fd_overlapped( struct fd *fd );
extern int get_unix_fd( struct fd *fd );
extern int is_same_file_fd( struct fd *fd1, struct fd *fd2 );

11
server/protocol.def
View File

@ -1479,6 +1479,17 @@ enum server_fd_type
@END
/* Perform a recv on a socket */
@REQ(recv_socket)
async_data_t async; /* async I/O parameters */
unsigned int status; /* status of initial call */
unsigned int total; /* number of bytes already read */
@REPLY
obj_handle_t wait; /* handle to wait on for blocking recv */
unsigned int options; /* device open options */
@END
/* Retrieve the next pending console ioctl request */
@REQ(get_next_console_request)
obj_handle_t handle; /* console server handle */

9
server/request.h
View File

@ -177,6 +177,7 @@ DECL_HANDLER(get_socket_event);
DECL_HANDLER(get_socket_info);
DECL_HANDLER(enable_socket_event);
DECL_HANDLER(set_socket_deferred);
DECL_HANDLER(recv_socket);
DECL_HANDLER(get_next_console_request);
DECL_HANDLER(read_directory_changes);
DECL_HANDLER(read_change);
@ -457,6 +458,7 @@ static const req_handler req_handlers[REQ_NB_REQUESTS] =
(req_handler)req_get_socket_info,
(req_handler)req_enable_socket_event,
(req_handler)req_set_socket_deferred,
(req_handler)req_recv_socket,
(req_handler)req_get_next_console_request,
(req_handler)req_read_directory_changes,
(req_handler)req_read_change,
@ -1064,6 +1066,13 @@ C_ASSERT( sizeof(struct enable_socket_event_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request, deferred) == 16 );
C_ASSERT( sizeof(struct set_socket_deferred_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct recv_socket_request, async) == 16 );
C_ASSERT( FIELD_OFFSET(struct recv_socket_request, status) == 56 );
C_ASSERT( FIELD_OFFSET(struct recv_socket_request, total) == 60 );
C_ASSERT( sizeof(struct recv_socket_request) == 64 );
C_ASSERT( FIELD_OFFSET(struct recv_socket_reply, wait) == 8 );
C_ASSERT( FIELD_OFFSET(struct recv_socket_reply, options) == 12 );
C_ASSERT( sizeof(struct recv_socket_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, signal) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, read) == 20 );

83
server/sock.c
View File

@ -653,14 +653,15 @@ static int sock_dispatch_asyncs( struct sock *sock, int event, int error )
async_terminate( sock->connect_req->async, get_error() );
}
if (event & (POLLIN | POLLPRI) && async_waiting( &sock->read_q ))
{
if (debug_level) fprintf( stderr, "activating read queue for socket %p\n", sock );
async_wake_up( &sock->read_q, STATUS_ALERTED );
event &= ~(POLLIN | POLLPRI);
}
if (is_fd_overlapped( sock->fd ))
{
if (event & (POLLIN|POLLPRI) && async_waiting( &sock->read_q ))
{
if (debug_level) fprintf( stderr, "activating read queue for socket %p\n", sock );
async_wake_up( &sock->read_q, STATUS_ALERTED );
event &= ~(POLLIN|POLLPRI);
}
if (event & POLLOUT && async_waiting( &sock->write_q ))
{
if (debug_level) fprintf( stderr, "activating write queue for socket %p\n", sock );
@ -2129,3 +2130,73 @@ DECL_HANDLER(get_socket_info)
release_object( &sock->obj );
}
DECL_HANDLER(recv_socket)
{
struct sock *sock = (struct sock *)get_handle_obj( current->process, req->async.handle, 0, &sock_ops );
unsigned int status = req->status;
timeout_t timeout = 0;
struct async *async;
struct fd *fd;
if (!sock) return;
fd = sock->fd;
/* recv() returned EWOULDBLOCK, i.e. no data available yet */
if (status == STATUS_DEVICE_NOT_READY && !(sock->state & FD_WINE_NONBLOCKING))
{
#ifdef SO_RCVTIMEO
struct timeval tv;
socklen_t len = sizeof(tv);
/* Set a timeout on the async if necessary.
*
* We want to do this *only* if the client gave us STATUS_DEVICE_NOT_READY.
* If the client gave us STATUS_PENDING, it expects the async to always
* block (it was triggered by WSARecv*() with a valid OVERLAPPED
* structure) and for the timeout not to be respected. */
if (is_fd_overlapped( fd ) && !getsockopt( get_unix_fd( fd ), SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, &len ))
timeout = tv.tv_sec * -10000000 + tv.tv_usec * -10;
#endif
status = STATUS_PENDING;
}
/* are we shut down? */
if (status == STATUS_PENDING && !(sock->state & FD_READ)) status = STATUS_PIPE_DISCONNECTED;
sock->pending_events &= ~FD_READ;
sock->reported_events &= ~FD_READ;
if ((async = create_request_async( fd, get_fd_comp_flags( fd ), &req->async )))
{
int success = 0;
if (status == STATUS_SUCCESS)
{
struct iosb *iosb = async_get_iosb( async );
iosb->result = req->total;
release_object( iosb );
success = 1;
}
else if (status == STATUS_PENDING)
{
success = 1;
}
set_error( status );
if (timeout)
async_set_timeout( async, timeout, STATUS_IO_TIMEOUT );
if (status == STATUS_PENDING)
queue_async( &sock->read_q, async );
/* always reselect; we changed reported_events above */
sock_reselect( sock );
reply->wait = async_handoff( async, success, NULL, 0 );
reply->options = get_fd_options( fd );
release_object( async );
}
release_object( sock );
}

16
server/trace.c
View File

@ -2094,6 +2094,19 @@ static void dump_set_socket_deferred_request( const struct set_socket_deferred_r
fprintf( stderr, ", deferred=%04x", req->deferred );
}
static void dump_recv_socket_request( const struct recv_socket_request *req )
{
dump_async_data( " async=", &req->async );
fprintf( stderr, ", status=%08x", req->status );
fprintf( stderr, ", total=%08x", req->total );
}
static void dump_recv_socket_reply( const struct recv_socket_reply *req )
{
fprintf( stderr, " wait=%04x", req->wait );
fprintf( stderr, ", options=%08x", req->options );
}
static void dump_get_next_console_request_request( const struct get_next_console_request_request *req )
{
fprintf( stderr, " handle=%04x", req->handle );
@ -4540,6 +4553,7 @@ static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
(dump_func)dump_get_socket_info_request,
(dump_func)dump_enable_socket_event_request,
(dump_func)dump_set_socket_deferred_request,
(dump_func)dump_recv_socket_request,
(dump_func)dump_get_next_console_request_request,
(dump_func)dump_read_directory_changes_request,
(dump_func)dump_read_change_request,
@ -4817,6 +4831,7 @@ static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
(dump_func)dump_get_socket_info_reply,
NULL,
NULL,
(dump_func)dump_recv_socket_reply,
(dump_func)dump_get_next_console_request_reply,
NULL,
(dump_func)dump_read_change_reply,
@ -5094,6 +5109,7 @@ static const char * const req_names[REQ_NB_REQUESTS] = {
"get_socket_info",
"enable_socket_event",
"set_socket_deferred",
"recv_socket",
"get_next_console_request",
"read_directory_changes",
"read_change",