wine-devel

wine-devel@winehq.org

10 participants
84459 discussions

Patch: sock-shutdown.diff (9 in series)
by Martin Wilck 12 Apr '02

12 Apr '02

Sorry I got the numbers wrong - there is no number 6 :-/ Patch: sock-shutdown.diff On overlapped sockets, shutdown() must be done asynchronously too to avoid premature closing of connections (necessary but unfortunately not sufficient). This patch queues the shutdown request in the async queue. Moreover it sets flags for the fd state to prevent calls to send() or recv() after the respective connection of the socket was shut down. Patch against: CVS 2002-04-12, with my sock-fd-type, sock-accept-deferred, async-winsock patches applied. Modified files: dlls/winsock: socket.c include/wine: server_protocol.h include: winsock.h server: protocol.def, sock.c diff -ruNX ignore TMP/wine/dlls/winsock/socket.c MW/wine/dlls/winsock/socket.c --- TMP/wine/dlls/winsock/socket.c Fri Apr 12 15:29:04 2002 +++ MW/wine/dlls/winsock/socket.c Fri Apr 12 15:29:13 2002 @@ -2258,6 +2258,12 @@ if ( fd == -1 ) goto error; + if ( flags & FD_FLAG_SEND_SHUTDOWN ) + { + err = WSAESHUTDOWN; + goto err_close; + } + iovec = WS_ALLOC ( dwBufferCount * sizeof (struct iovec) ); if ( !iovec ) @@ -2470,55 +2476,168 @@ return (INT16)WS_setsockopt( s, (UINT16)level, optname, optval, optlen ); } +/*********************************************************************** + * WS2_async_shutdown (INTERNAL) + * + * On overlapped sockets, shutdown() must be done asynchronously. + */ +static void WS2_async_shutdown ( async_private *as ) +{ + ws2_async* wsa = (ws2_async*) as; + int err = 1; + + TRACE ( "async %p %d\n", wsa, wsa->async.type ); + switch ( wsa->async.type ) + { + case ASYNC_TYPE_READ: + err = shutdown ( wsa->async.fd, 0 ); + break; + case ASYNC_TYPE_WRITE: + err = shutdown ( wsa->async.fd, 1 ); + break; + default: + WARN ("invalid type: %d\n", wsa->async.type ); + } + + if ( err ) + wsa->overlapped->Internal = STATUS_UNSUCCESSFUL; + else + wsa->overlapped->Internal = STATUS_SUCCESS; +} + +/*********************************************************************** + * WS2_register_async_shutdown (INTERNAL) + */ +static int WS2_register_async_shutdown ( SOCKET s, int fd, int type ) +{ + struct ws2_async *wsa; + int ret, err = WSAEFAULT; + DWORD dwflags = 0; + int len = 0; + LPWSAOVERLAPPED ovl = HeapAlloc (GetProcessHeap(), 0, sizeof ( WSAOVERLAPPED )); + + TRACE ("s %d fd %d type %d\n", s, fd, type); + if (!ovl) + goto out; + + ovl->hEvent = WSACreateEvent (); + if ( ovl->hEvent == WSA_INVALID_EVENT ) + goto out_free; + + wsa = WS2_make_async ( s, fd, type, NULL, 0, + &dwflags, NULL, &len, ovl, NULL ); + if ( !wsa ) + goto out_close; + + /* Hack: this will cause ws2_async_cleanup() to free the overlapped structure */ + wsa->user_overlapped = NULL; + wsa->async.func = WS2_async_shutdown; + if ( (ret = register_new_async ( &wsa->async )) ) + { + err = RtlNtStatusToDosError ( ret ); + ws2_async_cleanup ( &wsa->async ); + goto out; + } + return 0; + +out_close: + WSACloseEvent ( ovl->hEvent ); +out_free: + HeapFree ( GetProcessHeap(), 0, ovl ); +out: + return err; +} /*********************************************************************** * shutdown (WS2_32.22) */ int WINAPI WS_shutdown(SOCKET s, int how) { - int fd = _get_sock_fd(s); + int fd, fd0 = -1, fd1 = -1, flags, err = WSAENOTSOCK; + enum fd_type type; + unsigned int set_flags = 0, clear_flags = 0; - TRACE("socket %04x, how %i\n", s, how ); - if (fd != -1) - { - switch( how ) - { - case 0: /* drop receives */ - _enable_event(s, 0, 0, FD_READ); -#ifdef SHUT_RD - how = SHUT_RD; -#endif - break; + fd = _get_sock_fd_type ( s, &type, &flags ); + TRACE("socket %04x, how %i %d %d \n", s, how, type, flags ); - case 1: /* drop sends */ - _enable_event(s, 0, 0, FD_WRITE); -#ifdef SHUT_WR - how = SHUT_WR; -#endif - break; + if (fd == -1) + goto error; - case 2: /* drop all */ -#ifdef SHUT_RDWR - how = SHUT_RDWR; -#endif - default: - WSAAsyncSelect( s, 0, 0, 0 ); - break; - } + if ( flags & FD_FLAG_OVERLAPPED ) { + + switch ( how ) + { + case SD_RECEIVE: + fd0 = fd; + set_flags |= FD_FLAG_RECV_SHUTDOWN; + clear_flags |= FD_READ; + break; + case SD_SEND: + fd1 = fd; + set_flags |= FD_FLAG_SEND_SHUTDOWN; + clear_flags |= FD_WRITE; + break; + case SD_BOTH: + fd0 = fd; + fd1 = _get_sock_fd ( s ); + set_flags |= FD_FLAG_RECV_SHUTDOWN|FD_FLAG_SEND_SHUTDOWN; + clear_flags |= FD_READ|FD_WRITE; + default: + clear_flags |= FD_WINE_CONNECTED|FD_WINE_LISTENING; + WSAAsyncSelect( s, 0, 0, 0 ); + } + _enable_event( s, 0, set_flags, clear_flags ); - if (shutdown(fd, how) == 0) - { - if( how > 1 ) - { - _enable_event(s, 0, 0, FD_WINE_CONNECTED|FD_WINE_LISTENING); - } - close(fd); - return 0; - } - SetLastError(wsaErrno()); - close(fd); - } - else SetLastError(WSAENOTSOCK); + if ( fd0 != -1 ) + { + err = WS2_register_async_shutdown ( s, fd0, ASYNC_TYPE_READ ); + if ( err ) + { + close ( fd0 ); + goto error; + } + } + if ( fd1 != -1 ) + { + err = WS2_register_async_shutdown ( s, fd1, ASYNC_TYPE_WRITE ); + if ( err ) + { + close ( fd1 ); + goto error; + } + } + return 0; + } + else /* non-overlapped mode */ + { + switch( how ) + { + case 0: /* drop receives */ + _enable_event(s, 0, 0, FD_READ); + break; + case 1: /* drop sends */ + _enable_event(s, 0, 0, FD_WRITE); + break; + case 2: /* drop all */ + default: + WSAAsyncSelect( s, 0, 0, 0 ); + break; + } + + if ( shutdown( fd, how ) ) + { + err = wsaErrno (); + close ( fd ); + goto error; + } + if( how > 1 ) + _enable_event(s, 0, 0, FD_WINE_CONNECTED|FD_WINE_LISTENING); + close(fd); + return 0; + } + +error: + WSASetLastError ( err ); return SOCKET_ERROR; } @@ -3707,9 +3826,12 @@ TRACE ( "fd=%d, type=%d, flags=%x\n", fd, type, flags ); if (fd == -1) - { - err = WSAENOTSOCK; goto error; + + if ( flags & FD_FLAG_RECV_SHUTDOWN ) + { + err = WSAESHUTDOWN; + goto err_close; } iovec = HeapAlloc ( GetProcessHeap(), 0, dwBufferCount * sizeof (struct iovec) ); @@ -3879,6 +4001,7 @@ SetLastError ( WSATRY_AGAIN ); } SERVER_END_REQ; + /* WS_closesocket ( cs ); */ return SOCKET_ERROR; case CF_REJECT: WS_closesocket(cs); diff -ruNX ignore TMP/wine/include/wine/server_protocol.h MW/wine/include/wine/server_protocol.h --- TMP/wine/include/wine/server_protocol.h Fri Apr 12 14:38:16 2002 +++ MW/wine/include/wine/server_protocol.h Fri Apr 12 15:29:13 2002 @@ -796,6 +796,9 @@ #define FD_FLAG_OVERLAPPED 0x01 #define FD_FLAG_TIMEOUT 0x02 +#define FD_FLAG_RECV_SHUTDOWN 0x08000000 +#define FD_FLAG_SEND_SHUTDOWN 0x04000000 +#define FD_FLAG_SHUTDOWN_MASK (FD_FLAG_RECV_SHUTDOWN|FD_FLAG_SEND_SHUTDOWN) struct set_file_pointer_request @@ -3196,6 +3199,6 @@ struct get_window_properties_reply get_window_properties_reply; }; -#define SERVER_PROTOCOL_VERSION 79 +#define SERVER_PROTOCOL_VERSION 80 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */ diff -ruNX ignore TMP/wine/include/winsock.h MW/wine/include/winsock.h --- TMP/wine/include/winsock.h Tue Apr 2 16:51:40 2002 +++ MW/wine/include/winsock.h Fri Apr 12 15:29:13 2002 @@ -728,6 +728,7 @@ #define FD_CLOSE 0x00000020 /* internal per-socket flags */ +/* CAUTION: FD_FLAG_RECV_SHUTDOWN / FD_FLAG_SEND_SHUTDOWN (server/protocol.def) must fit into this mask */ #ifdef __WINE__ #define FD_WINE_LISTENING 0x10000000 #define FD_WINE_NONBLOCKING 0x20000000 diff -ruNX ignore TMP/wine/server/protocol.def MW/wine/server/protocol.def --- TMP/wine/server/protocol.def Fri Apr 12 14:38:16 2002 +++ MW/wine/server/protocol.def Fri Apr 12 15:29:13 2002 @@ -612,7 +612,10 @@ }; #define FD_FLAG_OVERLAPPED 0x01 #define FD_FLAG_TIMEOUT 0x02 - +/* These are only for sockets, but must work with ReadFile() etc., too */ +#define FD_FLAG_RECV_SHUTDOWN 0x08000000 +#define FD_FLAG_SEND_SHUTDOWN 0x04000000 +#define FD_FLAG_SHUTDOWN_MASK (FD_FLAG_RECV_SHUTDOWN|FD_FLAG_SEND_SHUTDOWN) /* Set a file current position */ @REQ(set_file_pointer) diff -ruNX ignore TMP/wine/server/sock.c MW/wine/server/sock.c --- TMP/wine/server/sock.c Fri Apr 12 15:29:04 2002 +++ MW/wine/server/sock.c Fri Apr 12 15:29:13 2002 @@ -230,7 +230,6 @@ } } else { - if ( sock->flags & WSA_FLAG_OVERLAPPED ) { if( IS_READY(sock->read_q) && (POLLIN & event) ) @@ -243,25 +242,26 @@ if (debug_level) fprintf ( stderr, "activating write queue for socket %p\n", sock ); async_notify(sock->write_q.head, STATUS_ALERTED); } - } - /* normal data flow */ - if (event & POLLIN) - { - char dummy; + } else { /* Linux 2.4 doesn't report POLLHUP if only one side of the socket * has been closed, so we need to check for it explicitly here */ - if (!recv( sock->obj.fd, &dummy, 1, MSG_PEEK )) event = POLLHUP; - else - { - /* incoming data */ - sock->pmask |= FD_READ; - sock->hmask |= FD_READ; - sock->errors[FD_READ_BIT] = 0; - if (debug_level) - fprintf(stderr, "socket %d is readable\n", sock->obj.fd ); - } + /* !!!! MW: do that only for non-overlapped sockets ??? */ + char dummy; + if (!recv( sock->obj.fd, &dummy, 1, MSG_PEEK )) + event = POLLHUP; + } + /* normal data flow */ + if (event & POLLIN) + { + + /* incoming data */ + sock->pmask |= FD_READ; + sock->hmask |= FD_READ; + sock->errors[FD_READ_BIT] = 0; + if (debug_level) + fprintf(stderr, "socket %d is readable\n", sock->obj.fd ); } if (event & POLLOUT) { @@ -371,8 +371,8 @@ reply->index_low = 0; reply->serial = 0; } - *flags = 0; - if (sock->flags & WSA_FLAG_OVERLAPPED) *flags |= FD_FLAG_OVERLAPPED; + *flags = ( sock->state & FD_FLAG_SHUTDOWN_MASK ); + if ( sock->flags & WSA_FLAG_OVERLAPPED ) *flags |= FD_FLAG_OVERLAPPED; return FD_TYPE_DEFAULT; }

2 1

Patch: wait-debug.diff (10 in series)
by Martin Wilck 12 Apr '02

12 Apr '02

Patch: wait-debug.diff Introduce a debug channel for WaitForMultipleObjectsEx() in scheduler/synchro.c - I found this very useful to debug my asynchronous socket code. Moreover, include "async.h" _after_ declaring debug channels so that TRACEs can be used in the static functions in async.h. Patch against: CVS 2002-04-12, with my async-immediate, async-file patches applied. Modified files: dlls/kernel: comm.c dlls/ntdll: ntdll.spec files: file.c include: async.h scheduler: synchro.c diff -ruNX ignore TMP/wine/dlls/kernel/comm.c MW/wine/dlls/kernel/comm.c --- TMP/wine/dlls/kernel/comm.c Fri Apr 12 12:31:58 2002 +++ MW/wine/dlls/kernel/comm.c Fri Apr 12 12:32:19 2002 @@ -80,7 +80,6 @@ #include "winerror.h" #include "wine/server.h" -#include "async.h" #include "file.h" #include "heap.h" @@ -91,6 +90,7 @@ #endif WINE_DEFAULT_DEBUG_CHANNEL(comm); +#include "async.h" /*********************************************************************** * Asynchronous I/O for asynchronous wait requests * diff -ruNX ignore TMP/wine/dlls/ntdll/ntdll.spec MW/wine/dlls/ntdll/ntdll.spec --- TMP/wine/dlls/ntdll/ntdll.spec Tue Apr 2 16:51:27 2002 +++ MW/wine/dlls/ntdll/ntdll.spec Fri Apr 12 12:33:12 2002 @@ -5,7 +5,7 @@ global heap int int21 int31 io loaddll local module ntdll process profile reg relay resource segment seh selector server snoop string system tape task thread tid timer toolhelp ver virtual - vxd win32) + vxd wait win32) #note that the Zw... functions are alternate names for the #Nt... functions. (see www.sysinternals.com for details) diff -ruNX ignore TMP/wine/files/file.c MW/wine/files/file.c --- TMP/wine/files/file.c Fri Apr 12 12:31:58 2002 +++ MW/wine/files/file.c Fri Apr 12 12:32:19 2002 @@ -55,7 +55,6 @@ #include "drive.h" #include "file.h" -#include "async.h" #include "heap.h" #include "msdos.h" #include "wincon.h" @@ -64,6 +63,7 @@ #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(file); +#include "async.h" #if defined(MAP_ANONYMOUS) && !defined(MAP_ANON) #define MAP_ANON MAP_ANONYMOUS diff -ruNX ignore TMP/wine/include/async.h MW/wine/include/async.h --- TMP/wine/include/async.h Fri Apr 12 12:31:58 2002 +++ MW/wine/include/async.h Fri Apr 12 12:32:19 2002 @@ -102,6 +102,7 @@ ovp->ops->set_status ( ovp, ret ); } + TRACE ("ovp %p, status %lx %lx, ret %x\n", ovp, status, ovp->ops->get_status (ovp), ret); if ( ovp->ops->get_status (ovp) != STATUS_PENDING ) finish_async (ovp); diff -ruNX ignore TMP/wine/scheduler/synchro.c MW/wine/scheduler/synchro.c --- TMP/wine/scheduler/synchro.c Mon Apr 8 10:56:59 2002 +++ MW/wine/scheduler/synchro.c Fri Apr 12 12:33:12 2002 @@ -23,6 +23,7 @@ #include <signal.h> #include <sys/time.h> #include <sys/poll.h> +#include <stdio.h> #include <unistd.h> #include <string.h> @@ -30,6 +31,9 @@ #include "thread.h" #include "winerror.h" #include "wine/server.h" +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(wait); #include "async.h" @@ -225,9 +229,22 @@ BOOL wait_all, DWORD timeout, BOOL alertable ) { - int ret, cookie; + int ret, cookie,i; struct timeval tv; + if ( TRACE_ON ( __default ) ) + { + const int len = 256; + char bf[len], *pp; + + for (i = 0, pp = bf; i < count && pp < bf+len; i++) + pp += snprintf (pp, bf + len - pp, " %d", handles[i]); + bf[len-1] = 0; + + TRACE ( "n=%ld wait=%c timeout=%ld alertable=%c handles%s\n", count, + ( wait_all ? 'y' : 'n' ), timeout, ( alertable ? 'y' : 'n' ), bf ); + } + if (count > MAXIMUM_WAIT_OBJECTS) { SetLastError( ERROR_INVALID_PARAMETER ); @@ -259,6 +276,7 @@ call_apcs( alertable ); if (alertable) break; } + TRACE ("status: %d\n", ret); if (HIWORD(ret)) /* is it an error code? */ { SetLastError( RtlNtStatusToDosError(ret) );

1 0

Patch: async-winsock.diff (8 in series)
by Martin Wilck 12 Apr '02

12 Apr '02

Patch: async-winsock.diff Basic implementation of asynchronous WSARecvFrom()/WSASendTo()/WSAGetOverlappedResult(), client side. Patch against: CVS 2002-04-12, with my sock-fd-type and sock-accept-deferred patches applied. Also requires the server side patch (async-sock-server). Modified files: dlls/winsock: socket.c, ws2_32.spec include: winsock2.h diff -ruNX ignore TMP/wine/dlls/winsock/socket.c MW/wine/dlls/winsock/socket.c --- TMP/wine/dlls/winsock/socket.c Fri Apr 12 14:55:42 2002 +++ MW/wine/dlls/winsock/socket.c Fri Apr 12 15:13:28 2002 @@ -105,6 +105,7 @@ #include "wine/winbase16.h" #include "wingdi.h" #include "winuser.h" +#include "winerror.h" #include "winsock2.h" #include "ws2tcpip.h" #include "wsipx.h" @@ -126,6 +127,170 @@ inet_ntoa(((struct sockaddr_in *)a)->sin_addr), \ ntohs(((struct sockaddr_in *)a)->sin_port)) +/**************************************************************** + * Async IO declarations and operations + ****************************************************************/ +#include "async.h" + +static DWORD ws2_async_get_status (const struct async_private *ovp); +static DWORD ws2_async_get_count (const struct async_private *ovp); +static void ws2_async_set_status (struct async_private *ovp, const DWORD status); +static void CALLBACK ws2_async_call_completion (ULONG_PTR data); +static void ws2_async_cleanup ( struct async_private *ovp ); + +static struct async_ops ws2_async_ops = +{ + ws2_async_get_status, + ws2_async_set_status, + ws2_async_get_count, + ws2_async_call_completion, + ws2_async_cleanup +}; + +static struct async_ops ws2_nocomp_async_ops = +{ + ws2_async_get_status, + ws2_async_set_status, + ws2_async_get_count, + NULL, /* call_completion */ + ws2_async_cleanup +}; + +typedef struct ws2_async +{ + async_private async; + LPWSAOVERLAPPED overlapped; + LPWSAOVERLAPPED user_overlapped; + LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_func; + struct iovec *iovec; + int n_iovecs; + struct WS_sockaddr *addr; + union { + int val; /* for send operations */ + int *ptr; /* for recv operations */ + } addrlen; + DWORD flags; +} ws2_async; + +static DWORD ws2_async_get_status (const struct async_private *ovp) +{ + return ((ws2_async*) ovp)->overlapped->Internal; +} + +static VOID ws2_async_set_status (struct async_private *ovp, const DWORD status) +{ + ((ws2_async*) ovp)->overlapped->Internal = status; +} + +static DWORD ws2_async_get_count (const struct async_private *ovp) +{ + return ((ws2_async*) ovp)->overlapped->InternalHigh; +} + +static void ws2_async_cleanup ( struct async_private *ap ) +{ + struct ws2_async *as = (struct ws2_async*) ap; + + TRACE ( "as: %p uovl %p ovl %p\n", as, as->user_overlapped, as->overlapped ); + if ( !as->user_overlapped ) + { + if ( as->overlapped->hEvent != INVALID_HANDLE_VALUE ) + WSACloseEvent ( as->overlapped->hEvent ); + HeapFree ( GetProcessHeap(), 0, as->overlapped ); + } + + if ( as->iovec ) + HeapFree ( GetProcessHeap(), 0, as->iovec ); + + HeapFree ( GetProcessHeap(), 0, as ); +} + +static void CALLBACK ws2_async_call_completion (ULONG_PTR data) +{ + ws2_async* as = (ws2_async*) data; + + TRACE ("data: %p\n", as); + + as->completion_func ( RtlNtStatusToDosError (as->overlapped->Internal), + as->overlapped->InternalHigh, + as->user_overlapped, + as->flags ); + ws2_async_cleanup ( &as->async ); +} + +static void WS2_async_recv (async_private *as); +static void WS2_async_send (async_private *as); + +/*********************************************************************** + * WS2_make_async (WS2_32.69) + */ +inline static struct ws2_async* +WS2_make_async (SOCKET s, int fd, int type, struct iovec *iovec, DWORD dwBufferCount, + LPDWORD lpFlags, struct WS_sockaddr *addr, + LPINT addrlen, LPWSAOVERLAPPED lpOverlapped, + LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine) +{ + struct ws2_async *wsa = HeapAlloc ( GetProcessHeap(), 0, sizeof ( ws2_async ) ); + + TRACE ( "wsa %p\n", wsa ); + + if (!wsa) + return NULL; + + wsa->async.ops = ( lpCompletionRoutine ? &ws2_async_ops : &ws2_nocomp_async_ops ); + wsa->async.handle = (HANDLE) s; + wsa->async.fd = fd; + wsa->async.type = type; + switch (type) + { + case ASYNC_TYPE_READ: + wsa->flags = *lpFlags; + wsa->async.func = WS2_async_recv; + wsa->addrlen.ptr = addrlen; + break; + case ASYNC_TYPE_WRITE: + wsa->flags = 0; + wsa->async.func = WS2_async_send; + wsa->addrlen.val = *addrlen; + break; + default: + ERR ("Invalid async type: %d\n", type); + } + wsa->user_overlapped = lpOverlapped; + wsa->completion_func = lpCompletionRoutine; + wsa->iovec = iovec; + wsa->n_iovecs = dwBufferCount; + wsa->addr = addr; + + if ( lpOverlapped ) + { + wsa->overlapped = lpOverlapped; + wsa->async.event = ( lpCompletionRoutine ? INVALID_HANDLE_VALUE : lpOverlapped->hEvent ); + } + else + { + wsa->overlapped = HeapAlloc ( GetProcessHeap(), 0, + sizeof (WSAOVERLAPPED) ); + if ( !wsa->overlapped ) + goto error; + wsa->async.event = wsa->overlapped->hEvent = INVALID_HANDLE_VALUE; + } + + wsa->overlapped->InternalHigh = 0; + TRACE ( "wsa %p, ops %p, h %d, ev %d, fd %d, func %p, ov %p, uov %p, cfunc %p\n", + wsa, wsa->async.ops, wsa->async.handle, wsa->async.event, wsa->async.fd, wsa->async.func, + wsa->overlapped, wsa->user_overlapped, wsa->completion_func ); + + return wsa; + +error: + TRACE ("Error\n"); + HeapFree ( GetProcessHeap(), 0, wsa ); + return NULL; +} + +/****************************************************************/ + /* ----------------------------------- internal data */ /* ws_... struct conversion flags */ @@ -1988,6 +2153,88 @@ } /*********************************************************************** + * WS2_send (INTERNAL) + */ +static int WS2_send ( int fd, struct iovec* iov, int count, + const struct WS_sockaddr *to, INT tolen, DWORD dwFlags ) +{ + struct msghdr hdr; + int n = -1; + TRACE ( "fd %d, iovec %p, count %d addr %p, len %d, flags %lx\n", + fd, iov, count, to, tolen, dwFlags); + + hdr.msg_name = NULL; + + if ( to ) + { +#if DEBUG_SOCKADDR + dump_sockaddr (to); +#endif + hdr.msg_name = (struct sockaddr*) ws_sockaddr_ws2u ( to, tolen, &hdr.msg_namelen ); + if ( !hdr.msg_name ) + { + WSASetLastError ( WSAEFAULT ); + goto out; + } + } + else + hdr.msg_namelen = 0; + + hdr.msg_iov = iov; + hdr.msg_iovlen = count; + hdr.msg_control = NULL; + hdr.msg_controllen = 0; + hdr.msg_flags = 0; + + n = sendmsg (fd, &hdr, dwFlags); + +out: + ws_sockaddr_free ( hdr.msg_name, to ); + return n; +} + +/*********************************************************************** + * WS2_async_send (INTERNAL) + */ +static void WS2_async_send ( async_private *as ) +{ + ws2_async* wsa = (ws2_async*) as; + int result, err; + + TRACE ( "async %p\n", wsa ); + + if ( wsa->overlapped->Internal != STATUS_PENDING ) + { + TRACE ( "status: %ld\n", wsa->overlapped->Internal ); + return; + } + + result = WS2_send ( wsa->async.fd, wsa->iovec, wsa->n_iovecs, + wsa->addr, wsa->addrlen.val, wsa->flags ); + + if (result >= 0) + { + wsa->overlapped->Internal = STATUS_SUCCESS; + wsa->overlapped->InternalHigh = result; + TRACE ( "sent %d bytes\n", result ); + _enable_event ( (SOCKET) wsa->async.handle, FD_WRITE, 0, 0 ); + return; + } + + err = errno; + if ( err == EAGAIN || err == EINTR ) + { + wsa->overlapped->Internal = STATUS_PENDING; + TRACE ( "still pending\n" ); + } + else + { + wsa->overlapped->Internal = STATUS_UNSUCCESSFUL; + TRACE ( "Error: %d\n", errno ); + } +} + +/*********************************************************************** * WSASendTo (WS2_32.74) */ INT WINAPI WSASendTo( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, @@ -1996,9 +2243,9 @@ LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine ) { - int i, n, fd, err = WSAENOTSOCK, flags; + int i, n, fd, err = WSAENOTSOCK, flags, ret; struct iovec* iovec; - struct msghdr msghdr; + struct ws2_async *wsa; enum fd_type type; TRACE ("socket %04x, wsabuf %p, nbufs %ld, flags %ld, to %p, tolen %d, ovl %p, func %p\n", @@ -2006,6 +2253,7 @@ to, tolen, lpOverlapped, lpCompletionRoutine); fd = _get_sock_fd_type( s, &type, &flags ); + TRACE ( "fd=%d, type=%d, flags=%x\n", fd, type, flags ); if ( fd == -1 ) goto error; @@ -2014,7 +2262,7 @@ if ( !iovec ) { - err = WSAENOBUFS; + err = WSAEFAULT; goto err_close; } @@ -2024,30 +2272,46 @@ iovec[i].iov_len = lpBuffers[i].len; } - msghdr.msg_name = NULL; - - if (to) + if ( (lpOverlapped || lpCompletionRoutine) && flags & FD_FLAG_OVERLAPPED ) { -#if DEBUG_SOCKADDR - dump_sockaddr (to); -#endif - msghdr.msg_name = (void*) ws_sockaddr_ws2u (to, tolen, &msghdr.msg_namelen); - if ( !msghdr.msg_name ) + wsa = WS2_make_async ( s, fd, ASYNC_TYPE_WRITE, iovec, dwBufferCount, + &dwFlags, (struct WS_sockaddr*) to, &tolen, + lpOverlapped, lpCompletionRoutine ); + if ( !wsa ) { err = WSAEFAULT; goto err_free; } - } - else - msghdr.msg_namelen = 0; + + if ( ( ret = register_new_async ( &wsa->async )) ) + { + err = RtlNtStatusToDosError ( ret ); - msghdr.msg_iov = iovec; - msghdr.msg_iovlen = dwBufferCount; - msghdr.msg_control = NULL; - msghdr.msg_controllen = 0; - msghdr.msg_flags = 0; + if ( !lpOverlapped ) + HeapFree ( GetProcessHeap(), 0, wsa->overlapped ); + HeapFree ( GetProcessHeap(), 0, wsa ); + goto err_free; + } - /* FIXME: Treat overlapped IO here */ + _enable_event ( s, FD_WRITE, 0, 0 ); + + /* Try immediate completion */ + if ( lpOverlapped ) + { + if ( WSAGetOverlappedResult ( (HANDLE) s, lpOverlapped, + lpNumberOfBytesSent, FALSE, &dwFlags) ) + return 0; + + if ( (err = WSAGetLastError ()) != WSA_IO_INCOMPLETE ) + { + WARN ("err=%d\n", err); + goto err_free; + } + } + + WSASetLastError (WSA_IO_PENDING); + return SOCKET_ERROR; + } if (_is_blocking(s)) { @@ -2055,9 +2319,8 @@ do_block(fd, 2); } - /* FIXME: can we support MSG_PARTIAL ? How does it relate to sendmsg()'s msg_flags ? */ - - if ((n = sendmsg (fd, &msghdr, dwFlags)) == -1) + n = WS2_send ( fd, iovec, dwBufferCount, to, tolen, dwFlags ); + if ( n == -1 ) { err = wsaErrno(); if ( err == WSAEWOULDBLOCK ) @@ -2065,24 +2328,22 @@ goto err_free; } + TRACE(" -> %i bytes\n", n); *lpNumberOfBytesSent = n; - ws_sockaddr_free ( msghdr.msg_name, to ); - WS_FREE ( iovec ); + HeapFree ( GetProcessHeap(), 0, iovec ); close ( fd ); - return 0; err_free: - ws_sockaddr_free ( msghdr.msg_name, to ); - WS_FREE ( iovec ); + HeapFree ( GetProcessHeap(), 0, iovec ); err_close: close ( fd ); error: WARN (" -> ERROR %d\n", err); - SetLastError (err); + WSASetLastError (err); return SOCKET_ERROR; } @@ -2686,6 +2947,53 @@ return SOCKET_ERROR; } +/********************************************************************** + * WSAGetOverlappedResult (WS2_32.40) + */ +BOOL WINAPI WSAGetOverlappedResult ( SOCKET s, LPWSAOVERLAPPED lpOverlapped, + LPDWORD lpcbTransfer, BOOL fWait, + LPDWORD lpdwFlags ) +{ + DWORD r; + + TRACE ( "socket %d ovl %p trans %p, wait %d flags %p\n", + s, lpOverlapped, lpcbTransfer, fWait, lpdwFlags ); + + if ( !(lpOverlapped && lpOverlapped->hEvent) ) + { + ERR ( "Invalid pointer\n" ); + WSASetLastError (WSA_INVALID_PARAMETER); + return FALSE; + } + + do { + r = WaitForSingleObjectEx (lpOverlapped->hEvent, fWait ? INFINITE : 0, TRUE); + } while (r == STATUS_USER_APC); + + if ( lpcbTransfer ) + *lpcbTransfer = lpOverlapped->InternalHigh; + + if ( lpdwFlags ) + *lpdwFlags = lpOverlapped->Offset; + + TRACE ("r=%lx, int=%lx inth%ld\n", r, lpOverlapped->Internal, lpOverlapped->InternalHigh); + + if ( r == WAIT_OBJECT_0 ) + return TRUE; + + if ( lpOverlapped->Internal == STATUS_PENDING ) + WSASetLastError ( WSA_IO_INCOMPLETE ); + else + { + DWORD err = RtlNtStatusToDosError ( lpOverlapped->Internal ); + WSASetLastError ( err ); + TRACE ( "Error: %lx\n", err ); + } + + return FALSE; +} + + /*********************************************************************** * WSAAsyncSelect (WS2_32.101) */ @@ -3278,6 +3586,105 @@ } /*********************************************************************** + * WS2_recv (INTERNAL) + */ +static int WS2_recv ( int fd, struct iovec* iov, int count, + struct WS_sockaddr *lpFrom, LPINT lpFromlen, + LPDWORD lpFlags ) +{ + struct msghdr hdr; + int n; + TRACE ( "fd %d, iovec %p, count %d addr %p, len %p, flags %lx\n", + fd, iov, count, lpFrom, lpFromlen, *lpFlags); + + hdr.msg_name = NULL; + + if ( lpFrom ) + { +#if DEBUG_SOCKADDR + dump_sockaddr (lpFrom); +#endif + + hdr.msg_namelen = *lpFromlen; + hdr.msg_name = ws_sockaddr_alloc ( lpFrom, lpFromlen, &hdr.msg_namelen ); + if ( !hdr.msg_name ) + { + WSASetLastError ( WSAEFAULT ); + n = -1; + goto out; + } + } + else + hdr.msg_namelen = 0; + + hdr.msg_iov = iov; + hdr.msg_iovlen = count; + hdr.msg_control = NULL; + hdr.msg_controllen = 0; + hdr.msg_flags = 0; + + if ( (n = recvmsg (fd, &hdr, *lpFlags)) == -1 ) + goto out; + + if ( lpFrom && + ws_sockaddr_u2ws ( hdr.msg_name, hdr.msg_namelen, + lpFrom, lpFromlen ) != 0 ) + { + /* The from buffer was too small, but we read the data + * anyway. Is that really bad? + */ + WSASetLastError ( WSAEFAULT ); + WARN ( "Address buffer too small\n" ); + } + +out: + + ws_sockaddr_free ( hdr.msg_name, lpFrom ); + return n; +} + +/*********************************************************************** + * WS2_async_recv (INTERNAL) + */ +static void WS2_async_recv ( async_private *as ) +{ + ws2_async* wsa = (ws2_async*) as; + int result, err; + + TRACE ( "async %p\n", wsa ); + + if ( wsa->overlapped->Internal != STATUS_PENDING ) + { + TRACE ( "status: %ld\n", wsa->overlapped->Internal ); + return; + } + + result = WS2_recv ( wsa->async.fd, wsa->iovec, wsa->n_iovecs, + wsa->addr, wsa->addrlen.ptr, &wsa->flags ); + + if (result >= 0) + { + wsa->overlapped->Internal = STATUS_SUCCESS; + wsa->overlapped->InternalHigh = result; + TRACE ( "received %d bytes\n", result ); + _enable_event ( (SOCKET) wsa->async.handle, FD_READ, 0, 0 ); + return; + } + + err = errno; + if ( err == EAGAIN || err == EINTR ) + { + wsa->overlapped->Internal = STATUS_PENDING; + TRACE ( "still pending\n" ); + } + else + { + wsa->overlapped->Internal = STATUS_UNSUCCESSFUL; + TRACE ( "Error: %d\n", errno ); + } +} + +/*********************************************************************** * WSARecvFrom (WS2_32.69) */ INT WINAPI WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, @@ -3286,11 +3693,9 @@ LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine ) { - /* Uses recvmsg() in order to provide scatter-gather I/O */ - + int i, n, fd, err = WSAENOTSOCK, flags, ret; struct iovec* iovec; - struct msghdr msghdr; - int fd, i, length, err = WSAENOTSOCK, flags; + struct ws2_async *wsa; enum fd_type type; TRACE("socket %04x, wsabuf %p, nbufs %ld, flags %ld, from %p, fromlen %ld, ovl %p, func %p\n", @@ -3299,6 +3704,7 @@ lpOverlapped, lpCompletionRoutine); fd = _get_sock_fd_type( s, &type, &flags ); + TRACE ( "fd=%d, type=%d, flags=%x\n", fd, type, flags ); if (fd == -1) { @@ -3306,11 +3712,10 @@ goto error; } - /* FIXME: should this be HeapAlloc() or WS_ALLOC ? */ - iovec = WS_ALLOC ( dwBufferCount * sizeof (struct iovec) ); + iovec = HeapAlloc ( GetProcessHeap(), 0, dwBufferCount * sizeof (struct iovec) ); if ( !iovec ) { - err = WSAENOBUFS; + err = WSAEFAULT; goto err_close; } @@ -3320,67 +3725,69 @@ iovec[i].iov_len = lpBuffers[i].len; } - msghdr.msg_name = NULL; - - if ( lpFrom ) + if ( (lpOverlapped || lpCompletionRoutine) && flags & FD_FLAG_OVERLAPPED ) { -#if DEBUG_SOCKADDR - dump_sockaddr (lpFrom); -#endif + wsa = WS2_make_async ( s, fd, ASYNC_TYPE_READ, iovec, dwBufferCount, + lpFlags, lpFrom, lpFromlen, + lpOverlapped, lpCompletionRoutine ); - msghdr.msg_namelen = *lpFromlen; - msghdr.msg_name = ws_sockaddr_alloc (lpFrom, lpFromlen, &msghdr.msg_namelen); - } - else - msghdr.msg_namelen = 0; + if ( !wsa ) + { + err = WSAEFAULT; + goto err_free; + } + + if ( ( ret = register_new_async ( &wsa->async )) ) + { + err = RtlNtStatusToDosError ( ret ); - msghdr.msg_iov = iovec; - msghdr.msg_iovlen = dwBufferCount; - msghdr.msg_control = NULL; - msghdr.msg_controllen = 0; - msghdr.msg_flags = 0; + if ( !lpOverlapped ) + HeapFree ( GetProcessHeap(), 0, wsa->overlapped ); + HeapFree ( GetProcessHeap(), 0, wsa ); + goto err_free; + } - /* FIXME: Treat overlapped IO here */ + _enable_event ( s, FD_READ, 0, 0 ); - if (_is_blocking(s)) + /* Try immediate completion */ + if ( lpOverlapped ) + { + if ( WSAGetOverlappedResult ( (HANDLE) s, lpOverlapped, + lpNumberOfBytesRecvd, FALSE, lpFlags) ) + return 0; + + if ( (err = WSAGetLastError ()) != WSA_IO_INCOMPLETE ) + goto err_free; + } + + WSASetLastError ( WSA_IO_PENDING ); + return SOCKET_ERROR; + } + + if ( _is_blocking(s) ) { /* block here */ /* FIXME: OOB and exceptfds? */ do_block(fd, 1); } - - /* FIXME: can we support MSG_PARTIAL ? - How does it relate to recvmsg()'s msg_flags ? */ - - if ((length = recvmsg (fd, &msghdr, *lpFlags)) == -1) + + n = WS2_recv ( fd, iovec, dwBufferCount, lpFrom, lpFromlen, lpFlags ); + if ( n == -1 ) { err = wsaErrno(); goto err_free; } - TRACE(" -> %i bytes\n", length); + TRACE(" -> %i bytes\n", n); + *lpNumberOfBytesRecvd = n; - if ( lpFrom && ws_sockaddr_u2ws (msghdr.msg_name, msghdr.msg_namelen, lpFrom, lpFromlen) != 0 ) - { - /* The from buffer was too small, but we read the data - * anyway. Is that really bad? - */ - SetLastError ( WSAEFAULT ); - WARN ( " -> Address buffer too small\n" ); - } - - *lpNumberOfBytesRecvd = length; - - WS_FREE (iovec); - ws_sockaddr_free ( msghdr.msg_name, lpFrom ); + HeapFree (GetProcessHeap(), 0, iovec); close(fd); _enable_event(s, FD_READ, 0, 0); - return 0; err_free: - WS_FREE (iovec); - ws_sockaddr_free ( msghdr.msg_name, lpFrom ); + HeapFree (GetProcessHeap(), 0, iovec); err_close: close (fd); diff -ruNX ignore TMP/wine/dlls/winsock/ws2_32.spec MW/wine/dlls/winsock/ws2_32.spec --- TMP/wine/dlls/winsock/ws2_32.spec Fri Apr 12 14:55:42 2002 +++ MW/wine/dlls/winsock/ws2_32.spec Fri Apr 12 15:05:29 2002 @@ -52,7 +52,7 @@ 37 stdcall WSAEnumProtocolsA(ptr ptr ptr) WSAEnumProtocolsA 38 stdcall WSAEnumProtocolsW(ptr ptr ptr) WSAEnumProtocolsW 39 stdcall WSAEventSelect(long long long) WSAEventSelect -40 stub WSAGetOverlappedResult +40 stdcall WSAGetOverlappedResult(long ptr ptr long ptr) WSAGetOverlappedResult 41 stub WSAGetQOSByName 42 stub WSAGetServiceClassInfoA 43 stub WSAGetServiceClassInfoW diff -ruNX ignore TMP/wine/include/winsock2.h MW/wine/include/winsock2.h --- TMP/wine/include/winsock2.h Tue Apr 2 16:51:40 2002 +++ MW/wine/include/winsock2.h Fri Apr 12 15:05:29 2002 @@ -221,8 +221,7 @@ #define WSAEVENT HANDLE #define LPWSAEVENT LPHANDLE -#define WSAOVERLAPPED OVERLAPPED -typedef struct _OVERLAPPED* LPWSAOVERLAPPED; +typedef OVERLAPPED WSAOVERLAPPED, *LPWSAOVERLAPPED; #define WSA_IO_PENDING (ERROR_IO_PENDING) #define WSA_IO_INCOMPLETE (ERROR_IO_INCOMPLETE)

1 0

PATCH: async-sock-server.diff (7 in series)
by Martin Wilck 12 Apr '02

12 Apr '02

PATCH: async-sock-server.diff Basic implementation of async IO queues in the server code for sockets. Patch against: CVS-2002-04-12, with my sock-fd-type patch applied. Modified files: server: sock.c diff -ruNX ignore TMP/wine/server/sock.c MW/wine/server/sock.c --- TMP/wine/server/sock.c Fri Apr 12 14:38:16 2002 +++ MW/wine/server/sock.c Fri Apr 12 15:26:36 2002 @@ -86,6 +86,7 @@ static void sock_destroy( struct object *obj ); static int sock_get_error( int err ); static void sock_set_error(void); +static struct async_queue * sock_queue_async(struct object *obj, struct async* async, int type, int count); static const struct object_ops sock_ops = { @@ -100,7 +101,7 @@ sock_get_fd, /* get_fd */ no_flush, /* flush */ sock_get_info, /* get_file_info */ - NULL, /* queue_async */ + sock_queue_async, /* queue_async */ sock_destroy /* destroy */ }; @@ -229,6 +230,21 @@ } } else { + + if ( sock->flags & WSA_FLAG_OVERLAPPED ) + { + if( IS_READY(sock->read_q) && (POLLIN & event) ) + { + if (debug_level) fprintf ( stderr, "activating read queue for socket %p\n", sock ); + async_notify(sock->read_q.head, STATUS_ALERTED); + } + if( IS_READY(sock->write_q) && (POLLOUT & event) ) + { + if (debug_level) fprintf ( stderr, "activating write queue for socket %p\n", sock ); + async_notify(sock->write_q.head, STATUS_ALERTED); + } + } + /* normal data flow */ if (event & POLLIN) { @@ -312,6 +328,8 @@ int ev = 0; assert( obj->ops == &sock_ops ); + if ( debug_level ) + fprintf (stderr, "mask: %x %x %x -> %x\n", sock->mask, sock->state, sock->hmask, mask); if (sock->state & FD_CONNECT) /* connecting, wait for writable */ @@ -320,8 +338,11 @@ /* listening, wait for readable */ return (sock->hmask & FD_ACCEPT) ? 0 : POLLIN; - if (mask & FD_READ) ev |= POLLIN | POLLPRI; - if (mask & FD_WRITE) ev |= POLLOUT; + if (mask & FD_READ || (sock->flags & WSA_FLAG_OVERLAPPED && IS_READY (sock->read_q))) + ev |= POLLIN | POLLPRI; + if (mask & FD_WRITE || (sock->flags & WSA_FLAG_OVERLAPPED && IS_READY (sock->write_q))) + ev |= POLLOUT; + return ev; } @@ -353,6 +374,38 @@ *flags = 0; if (sock->flags & WSA_FLAG_OVERLAPPED) *flags |= FD_FLAG_OVERLAPPED; return FD_TYPE_DEFAULT; +} + +static struct async_queue *sock_queue_async(struct object *obj, struct async *async, int type, int count) +{ + struct sock *sock = (struct sock *)obj; + struct async_queue *q; + + assert( obj->ops == &sock_ops ); + + if ( !(sock->flags & WSA_FLAG_OVERLAPPED) ) + { + set_error ( STATUS_INVALID_HANDLE ); + return NULL; + } + + switch(type) + { + case ASYNC_TYPE_READ: + q = &sock->read_q; + break; + case ASYNC_TYPE_WRITE: + q = &sock->write_q; + break; + default: + set_error( STATUS_INVALID_PARAMETER ); + return NULL; + } + + if(async && !async->q) + async_insert(q, async); + + return q; } static void sock_destroy( struct object *obj )

1 0

Patch: async-file.diff (4 in series)
by Martin Wilck 12 Apr '02

12 Apr '02

Patch: async-file.diff Some improvements to the async IO API. - Need a "cleanup" method. - calling the "call_completion" method unconditionally in finish_async (introduced by me) was wrong, because the thread may never be in an alertable wait state -> call it only if user completion function is present. - We need two constant "ops" objects, one with and one without call_completion method (the event field may NOT be used to determine whether the completion must be called or not). - STATUS_CANCELLED is correct for cancelled requests ( corresponds to ERROR_OPERATION_ABORTED ). Modified files: dlls/kernel: comm.c files: file.c include: async.h server: async.c diff -ruNX ignore TMP/wine/dlls/kernel/comm.c MW/wine/dlls/kernel/comm.c --- TMP/wine/dlls/kernel/comm.c Fri Apr 12 11:47:48 2002 +++ MW/wine/dlls/kernel/comm.c Fri Apr 12 12:27:07 2002 @@ -99,14 +99,15 @@ static DWORD commio_get_async_status (const async_private *ovp); static DWORD commio_get_async_count (const async_private *ovp); static void commio_set_async_status (async_private *ovp, const DWORD status); -static void CALLBACK commio_call_completion_func (ULONG_PTR data); +static void commio_async_cleanup (async_private *ovp); static async_ops commio_async_ops = { commio_get_async_status, /* get_status */ commio_set_async_status, /* set_status */ commio_get_async_count, /* get_count */ - commio_call_completion_func /* call_completion */ + NULL, /* call_completion */ + commio_async_cleanup /* cleanup */ }; typedef struct async_commio @@ -131,9 +132,9 @@ return 0; } -static void CALLBACK commio_call_completion_func (ULONG_PTR data) +static void commio_async_cleanup (async_private *ovp) { - HeapFree(GetProcessHeap(), 0, (void*) data); + HeapFree(GetProcessHeap(), 0, ovp ); } /***********************************************************************/ diff -ruNX ignore TMP/wine/files/file.c MW/wine/files/file.c --- TMP/wine/files/file.c Fri Apr 12 11:59:51 2002 +++ MW/wine/files/file.c Fri Apr 12 12:28:22 2002 @@ -88,13 +88,24 @@ static DWORD fileio_get_async_count (const async_private *ovp); static void fileio_set_async_status (async_private *ovp, const DWORD status); static void CALLBACK fileio_call_completion_func (ULONG_PTR data); +static void fileio_async_cleanup (async_private *ovp); static async_ops fileio_async_ops = { fileio_get_async_status, /* get_status */ fileio_set_async_status, /* set_status */ fileio_get_async_count, /* get_count */ - fileio_call_completion_func /* call_completion */ + fileio_call_completion_func, /* call_completion */ + fileio_async_cleanup /* cleanup */ +}; + +static async_ops fileio_nocomp_async_ops = +{ + fileio_get_async_status, /* get_status */ + fileio_set_async_status, /* set_status */ + fileio_get_async_count, /* get_count */ + NULL, /* call_completion */ + fileio_async_cleanup /* cleanup */ }; typedef struct async_fileio @@ -128,12 +139,16 @@ async_fileio *ovp = (async_fileio*) data; TRACE ("data: %p\n", ovp); - if (ovp->completion_func) - ovp->completion_func(ovp->lpOverlapped->Internal, - ovp->lpOverlapped->InternalHigh, - ovp->lpOverlapped); + ovp->completion_func( ovp->lpOverlapped->Internal, + ovp->lpOverlapped->InternalHigh, + ovp->lpOverlapped ); + + fileio_async_cleanup ( &ovp->async ); +} - HeapFree(GetProcessHeap(), 0, ovp); +static void fileio_async_cleanup ( struct async_private *ovp ) +{ + HeapFree ( GetProcessHeap(), 0, ovp ); } /*********************************************************************** @@ -1479,6 +1494,8 @@ { async_fileio *ovp; int fd; + int flags; + enum fd_type type; TRACE("file %d to buf %p num %ld %p func %p\n", hFile, buffer, bytesToRead, overlapped, lpCompletionRoutine); @@ -1490,10 +1507,11 @@ return FALSE; } - fd = FILE_GetUnixHandle( hFile, GENERIC_READ ); - if(fd<0) + fd = FILE_GetUnixHandleType ( hFile, GENERIC_READ, &type, &flags); + if ( fd < 0 ) { - TRACE("Couldn't get FD\n"); + WARN ( "Couldn't get FD\n" ); + SetLastError ( ERROR_INVALID_PARAMETER ); return FALSE; } @@ -1502,11 +1520,10 @@ { TRACE("HeapAlloc Failed\n"); SetLastError(ERROR_NOT_ENOUGH_MEMORY); - close(fd); - return FALSE; + goto error; } - ovp->async.ops = &fileio_async_ops; + ovp->async.ops = ( lpCompletionRoutine ? &fileio_async_ops : &fileio_nocomp_async_ops ); ovp->async.handle = hFile; ovp->async.fd = fd; ovp->async.type = ASYNC_TYPE_READ; @@ -1518,6 +1535,11 @@ ovp->buffer = buffer; return !register_new_async (&ovp->async); + +error: + close (fd); + return FALSE; + } /*********************************************************************** @@ -1691,6 +1713,8 @@ { async_fileio *ovp; int fd; + int flags; + enum fd_type type; TRACE("file %d to buf %p num %ld %p func %p stub\n", hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine); @@ -1701,7 +1725,7 @@ return FALSE; } - fd = FILE_GetUnixHandle( hFile, GENERIC_WRITE ); + fd = FILE_GetUnixHandleType ( hFile, GENERIC_WRITE, &type, &flags ); if ( fd < 0 ) { TRACE( "Couldn't get FD\n" ); @@ -1713,8 +1737,7 @@ { TRACE("HeapAlloc Failed\n"); SetLastError(ERROR_NOT_ENOUGH_MEMORY); - close (fd); - return FALSE; + goto error; } ovp->async.ops = &fileio_async_ops; @@ -1729,6 +1752,10 @@ ovp->completion_func = lpCompletionRoutine; return !register_new_async (&ovp->async); + +error: + close (fd); + return FALSE; } /*********************************************************************** diff -ruNX ignore TMP/wine/include/async.h MW/wine/include/async.h --- TMP/wine/include/async.h Fri Apr 12 11:47:48 2002 +++ MW/wine/include/async.h Fri Apr 12 12:25:30 2002 @@ -35,6 +35,7 @@ typedef DWORD (*async_get_status)(const struct async_private *ovp); typedef DWORD (*async_get_count)(const struct async_private *ovp); typedef void (*async_set_status)(struct async_private *ovp, const DWORD status); +typedef void (*async_cleanup)(struct async_private *ovp); typedef struct async_ops { @@ -42,6 +43,7 @@ async_set_status set_status; async_get_count get_count; async_call_completion_func call_completion; + async_cleanup cleanup; } async_ops; typedef struct async_private @@ -74,7 +76,10 @@ if( ovp->event != INVALID_HANDLE_VALUE ) NtSetEvent( ovp->event, NULL ); - QueueUserAPC( ovp->ops->call_completion, GetCurrentThread(), (ULONG_PTR)ovp ); + if ( ovp->ops->call_completion ) + QueueUserAPC( ovp->ops->call_completion, GetCurrentThread(), (ULONG_PTR)ovp ); + else + ovp->ops->cleanup ( ovp ); } inline static BOOL __register_async( async_private *ovp, const DWORD status ) @@ -92,7 +97,11 @@ } SERVER_END_REQ; - if ( ret ) ovp->ops->set_status ( ovp, GetLastError() ); + if ( ret ) { + SetLastError( RtlNtStatusToDosError(ret) ); + ovp->ops->set_status ( ovp, ret ); + } + if ( ovp->ops->get_status (ovp) != STATUS_PENDING ) finish_async (ovp); diff -ruNX ignore TMP/wine/server/async.c MW/wine/server/async.c --- TMP/wine/server/async.c Fri Apr 12 11:47:48 2002 +++ MW/wine/server/async.c Fri Apr 12 12:23:56 2002 @@ -71,7 +71,7 @@ { while(q->head) { - async_notify(q->head, STATUS_HANDLES_CLOSED); + async_notify(q->head, STATUS_CANCELLED); destroy_async(q->head); } }

1 0

PATCH: winemaker.diff (3 in series)
by Martin Wilck 12 Apr '02

12 Apr '02

PATCH: winemaker.diff (identical to: http://www.winehq.com/hypermail/wine-devel/2002/04/0187.html) Fix winemaker-generated references to dlls that have changed their names in configure.ac. Patch against: Wine CVS 2002-04-12 Modified Files: tools: winemaker diff -ruNX ignore TMP/wine/tools/winemaker MW/wine/tools/winemaker --- TMP/wine/tools/winemaker Tue Apr 9 13:19:57 2002 +++ MW/wine/tools/winemaker Tue Apr 9 13:29:27 2002 @@ -2732,14 +2732,14 @@ WINE_DLL_ROOT="/lib:/lib/dlls:/usr/lib:/usr/lib/dlls:/usr/local/lib:/usr/local/lib/dlls" fi fi -AC_PATH_FILE(WINE_DLL_ROOT,[libntdll.so],[ - AC_MSG_ERROR([Could not find the Wine dlls (libntdll.so)]) +AC_PATH_FILE(WINE_DLL_ROOT,[libntdll.dll.so],[ + AC_MSG_ERROR([Could not find the Wine dlls (libntdll.dll.so)]) ],[$WINE_DLL_ROOT]) -AC_PATH_LIBRARY(WINE_DLL_ROOT,[-lntdll],[$WINE_LIBRARY_PATH -lwine -lwine_unicode],[ - AC_MSG_ERROR([Could not link with the Wine dlls (libntdll.so)]) +AC_PATH_LIBRARY(WINE_DLL_ROOT,[-lntdll.dll],[$WINE_LIBRARY_PATH -lwine -lwine_unicode],[ + AC_MSG_ERROR([Could not link with the Wine dlls (libntdll.dll.so)]) ],[$WINE_DLL_ROOT]) -WINE_DLL_PATH="-L$WINE_DLL_ROOT" +WINE_DLL_PATH="-L$WINE_DLL_ROOT/wine" if test -n "$LD_PATH" then

1 0

PATCH: sock-fd-type.diff (2 in series)
by Martin Wilck 12 Apr '02

12 Apr '02

PATCH: sock-fd-type.diff Patch against: Wine CVS 2002-04-12 Test status: Compiles (no errors/warnings). Modified Files: dlls/winsock : socket.c Log message: Martin Wilck <Martin.Wilck(a)Fujitsu-Siemens.com> _get_sock_fd_type : New function, retrieve fd type and flags like FILE_GetUnixHandleType(). WSASendTo() /WSARecvFrom(): Use _get_sock_fd_type(). diff -ruNX ignore TMP/wine/dlls/winsock/socket.c MW/wine/dlls/winsock/socket.c --- TMP/wine/dlls/winsock/socket.c Tue Apr 9 13:27:56 2002 +++ MW/wine/dlls/winsock/socket.c Tue Apr 9 13:28:08 2002 @@ -246,6 +246,13 @@ return fd; } +inline static int _get_sock_fd_type( SOCKET s, enum fd_type *type, int *flags ) +{ + int fd; + if (set_error( wine_server_handle_to_fd( s, GENERIC_READ, &fd, type, flags ) )) return -1; + return fd; +} + static void _enable_event(SOCKET s, unsigned int event, unsigned int sstate, unsigned int cstate) { @@ -1976,15 +1983,16 @@ LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine ) { - int i, n, fd, err = WSAENOTSOCK; + int i, n, fd, err = WSAENOTSOCK, flags; struct iovec* iovec; struct msghdr msghdr; - + enum fd_type type; + TRACE ("socket %04x, wsabuf %p, nbufs %ld, flags %ld, to %p, tolen %d, ovl %p, func %p\n", s, lpBuffers, dwBufferCount, dwFlags, to, tolen, lpOverlapped, lpCompletionRoutine); - fd = _get_sock_fd(s); + fd = _get_sock_fd_type( s, &type, &flags ); if ( fd == -1 ) goto error; @@ -3269,14 +3277,15 @@ struct iovec* iovec; struct msghdr msghdr; - int fd, i, length, err = WSAENOTSOCK; + int fd, i, length, err = WSAENOTSOCK, flags; + enum fd_type type; TRACE("socket %04x, wsabuf %p, nbufs %ld, flags %ld, from %p, fromlen %ld, ovl %p, func %p\n", s, lpBuffers, dwBufferCount, *lpFlags, lpFrom, (lpFromlen ? *lpFromlen : -1L), lpOverlapped, lpCompletionRoutine); - fd = _get_sock_fd(s); + fd = _get_sock_fd_type( s, &type, &flags ); if (fd == -1) {

1 0

PATCH: async-immediate.diff (1 in series)
by Martin Wilck 12 Apr '02

12 Apr '02

PATCH: async-immediate.diff (Resubmission of http://www.winehq.com/hypermail/wine-patches/2002/04/0021.html) This patch uses a more elegant and (IMO) more wine-ish method to check for possible immediate completion of asynchronous IO requests in ReadFile() and WriteFile(). The implementation in current CVS is wrong for 2 reasons: 1. The overlapped event is not set, nor the completion routine called, if immediate completion succeeds. This breaks apps that do not check for immediate success. 2. If there are async requests currently in the queue, immediate completion will bypass the request ordering. This will lead to data corruption on FIFO-type files. The patch fixes this. Patch against: Wine CVS 2002-04-12 Test status: Compiles (no errors/warnings). Tested for regular file IO (ok). The 2002-01-15 patch has been tested for 16-bit serial IO by Lawson Whitney (ok). Modified Files: files : file.c Log message: Martin Wilck <Martin.Wilck(a)Fujitsu-Siemens.com> GetOverlappedResult(): Return ERROR_IO_INCOMPLETE if IO still pending (MSDN docs) ReadFile() / WriteFile(): Use GetOverlappedResult() to check for immediate completion. diff -ruNX ignore TMP/wine/files/file.c MW/wine/files/file.c --- TMP/wine/files/file.c Tue Apr 9 13:20:25 2002 +++ MW/wine/files/file.c Tue Apr 9 13:25:25 2002 @@ -1395,7 +1395,8 @@ if(lpTransferred) *lpTransferred = lpOverlapped->InternalHigh; - SetLastError(lpOverlapped->Internal); + SetLastError ( lpOverlapped->Internal == STATUS_PENDING ? + ERROR_IO_INCOMPLETE : lpOverlapped->Internal ); return (r==WAIT_OBJECT_0); } @@ -1576,41 +1577,21 @@ SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } - - /* see if we can read some data already (this shouldn't block) */ - result = pread( unix_handle, buffer, bytesToRead, OVERLAPPED_OFFSET(overlapped) ); - if ((result < 0) && (errno == ESPIPE)) - result = read( unix_handle, buffer, bytesToRead ); - close(unix_handle); - - if(result<0) - { - if( (errno!=EAGAIN) && (errno!=EINTR) && - ((errno != EFAULT) || IsBadWritePtr( buffer, bytesToRead )) ) - { - FILE_SetDosError(); - return FALSE; - } - else - result = 0; - } - /* if we read enough to keep the app happy, then return now */ - if(result>=bytesToRead) - { - *bytesRead = result; - return TRUE; - } - - /* at last resort, do an overlapped read */ - overlapped->InternalHigh = result; + close(unix_handle); + overlapped->InternalHigh = 0; if(!FILE_ReadFileEx(hFile, buffer, bytesToRead, overlapped, NULL, overlapped->hEvent)) return FALSE; - /* fail on return, with ERROR_IO_PENDING */ - SetLastError(ERROR_IO_PENDING); - return FALSE; + if ( !GetOverlappedResult (hFile, overlapped, bytesRead, FALSE) ) + { + if ( GetLastError() == ERROR_IO_INCOMPLETE ) + SetLastError ( ERROR_IO_PENDING ); + return FALSE; + } + + return TRUE; } if (flags & FD_FLAG_TIMEOUT) { @@ -1790,43 +1771,20 @@ return FALSE; } - /* see if we can write some data already (this shouldn't block) */ - - result = pwrite( unix_handle, buffer, bytesToWrite, OVERLAPPED_OFFSET (overlapped) ); - if ((result < 0) && (errno == ESPIPE)) - result = write( unix_handle, buffer, bytesToWrite ); - close(unix_handle); + overlapped->InternalHigh = 0; - if(result<0) - { - if( (errno!=EAGAIN) && (errno!=EINTR) && - ((errno != EFAULT) || IsBadReadPtr( buffer, bytesToWrite )) ) - { - FILE_SetDosError(); - return FALSE; - } - else - result = 0; - } + if(!FILE_WriteFileEx(hFile, buffer, bytesToWrite, overlapped, NULL, overlapped->hEvent)) + return FALSE; - /* if we wrote enough to keep the app happy, then return now */ - if(result>=bytesToWrite) + if ( !GetOverlappedResult (hFile, overlapped, bytesWritten, FALSE) ) { - *bytesWritten = result; - return TRUE; - } - - /* at last resort, do an overlapped read */ - overlapped->Internal = STATUS_PENDING; - overlapped->InternalHigh = result; - - if(!FILE_WriteFileEx(hFile, buffer, bytesToWrite, overlapped, NULL, overlapped->hEvent)) + if ( GetLastError() == ERROR_IO_INCOMPLETE ) + SetLastError ( ERROR_IO_PENDING ); return FALSE; + } - /* fail on return, with ERROR_IO_PENDING */ - SetLastError(ERROR_IO_PENDING); - return FALSE; + return TRUE; } switch(type)

1 0

Re: Make dumping more robust
by juergen.schmied＠debitel.net 12 Apr '02

12 Apr '02

I just rewrote the dumping of pidl's because the dumping itself produces lots of relay/snoop messages. So I made it not call any other functions. Will send it soon. juergen

2 1

Expect Trouble
by Shachar Shemesh 12 Apr '02

12 Apr '02

Hi list, I am sorry if this is a baisc question. I have not been able to find anything about it in the docs. I am trying to run a small program I wrote and compiled with VC6 on Windows. I am getting the following error: Invoking /usr/bin/wine.bin HebTest.exe ... Warning: loading builtin kernel32.dll, but native version already present. Expect trouble. Warning: loading builtin user32.dll, but native version already present. Expect trouble. wine: Unhandled exception, starting debugger... err:seh:start_debugger Couldn't start debugger ("debugger/winedbg 134661992 32") (2) Read the Wine Developers Guide on how to set up winedbg or another debugger Wine failed with return code 5 I get the same error whether I am using my own CVS compiled version, or the nightly CVS for debian SID. I get this error regardless of whether I am using fake windows or real windows. I even tried removing the user32.dll file (0 bytes) completely from C:\Windows\System of the fake windows. Attached is the output when running wine with --debugmsg +all, and the binary I am using to run this program (it is a debug build). It's a tiny program of my writing, so unless I unwittedly stole it from somewhere, you hereby have my permission to use the binary as you see fit. Sources are available upon request. Thanks Shachar

1 0

Re: Handling of messages above WM_USER in pack_message
by Alexandre Julliard 12 Apr '02

12 Apr '02

Uwe Bonnes <bon(a)elektron.ikp.physik.tu-darmstadt.de> writes: > I don't know if this global approach is valid, but at least it helped me to > get winhlp32 working called with WinHelpA from an application. In what other > way can we cope with user defined messages and their related structures in > inter-process SendMessage? We can't. User messages cannot pass data around, WinHelpA will need to do that differently. The best way to find out how is probably to watch winhlp32 with a message spy under Windows. -- Alexandre Julliard julliard(a)winehq.com

2 1

NT Status vs. Dos Error code in async operations
by Martin Wilck 12 Apr '02

12 Apr '02

Hi, If my understanding of the MS docs is correct, the status of overlapped requests is stored as an NT status in lpOverlapped->Internal (As Mike implemented it). The error code returned by GetOverlappedResult() or passed to the completion routine, though, is a DOS error code. Thus in priciple we'd need to convert the status with RtlNtStatusToDosError(), right ? Moreover, if our async read()/write() operations fail, we simply set the status to STATUS_UNSUCCESSFUL which translates to ERROR_GEN_FAILURE - not very meaningful to our users. What we'd need would consequently be a errno->NT status converter to set the overlapped status correctly from the error reported by read or write. I can't seem to find one in the wine code (??). There only seem to be local errno -> DOS error converters, and no DOS error->Nt status converter. What should we do? Martin -- Martin Wilck Phone: +49 5251 8 15113 Fujitsu Siemens Computers Fax: +49 5251 8 20409 Heinz-Nixdorf-Ring 1 mailto:Martin.Wilck@Fujitsu-Siemens.com D-33106 Paderborn http://www.fujitsu-siemens.com/primergy

2 1

Async IO on sockets: good news and bad news
by Martin Wilck 11 Apr '02

11 Apr '02

Hi, The good news is: I have the basic mechanism for async IO on sockets running. Requests can be scheduled and waited for, just like for regular files. The bad news is: This is not enough for sockets. Problems occur especially when sockets are closed, because the signalling of socket events uses a completely independent mechanism. This leads to all sorts of strange behaviour, mostly to data loss because "FD_CLOSE" is signalled prematurely. Sadly, this means for me: - The whole event signalling mechanism needs to be reworked so that it is consistent with overlapped IO. - Probably the async IO mechanism, too. It seems that it would be good to have a single IO queue where all events are handled, rather than several ones. Unlike now, also things like "peer closed socket" would be scheduled in that queue. Well I need to think more. Currently, I am not even sure how exactly it _should_ work. Martin -- Martin Wilck Phone: +49 5251 8 15113 Fujitsu Siemens Computers Fax: +49 5251 8 20409 Heinz-Nixdorf-Ring 1 mailto:Martin.Wilck@Fujitsu-Siemens.com D-33106 Paderborn http://www.fujitsu-siemens.com/primergy

1 0

16-bit apps starting and stopping notification
by Andriy Palamarchuk 10 Apr '02

10 Apr '02

I found an issue for a hang of 16-bit application (www.formdocs.com) installer. The app registers with NotifyRegister16 callback function and looks like it hangs while waiting for completion of child process. The last part of relay trace is attached. NotifyRegister16 function of ToolHelp dll is used to register handler for following events: NFY_UNKNOWN NFY_LOADSEG NFY_FREESEG NFY_STARTDLL NFY_STARTTASK NFY_EXITTASK NFY_DELMODULE NFY_RIP NFY_TASKIN NFY_TASKOUT NFY_INCHAR NFY_OUTSTRING NFY_LOGERROR NFY_LOGPARAMERROR Note, this works for 16-bit applications only. These events also used by debuggers to debug 16-bit applications. Can somebody give me a hint how is better to approach implementation of NFY_EXITTASK, NFY_STARTTASK events generation? How important do you think is to implement this functionality, since it is for 16-bit apps only? Andriy Palamarchuk __________________________________________________ Do You Yahoo!? Yahoo! Tax Center - online filing with TurboTax http://taxes.yahoo.com/

1 0

Wine & ActiveX?
by Mark Lehrer 10 Apr '02

10 Apr '02

Hello! We are trying to make one of our applications work under Wine on Red Hat 7.2. We have a lot of talent here in both Linux and Windows, but no Wine experts (yet!). Unfortunately it only gets as far as showing the splash screen before it freezes. Is there a document that can help us with debugging procedures? Obviously running Visual Studio is not an option... but what is the best way to start looking at what may be going wrong? It uses ActiveX so perhaps that is the trouble. We took out all of the DCOM stuff already. Thanks! Mark

3 2

RE: update to regression testing framework
by Geoffrey Hausheer 10 Apr '02

10 Apr '02

> -----Original Message----- > From: Paul Millar paulm(a)astro.gla.ac.uk > Subject: update to regression testing framework > o The commands "named_ok", "set_name" and "unset_name" now > exist (in C > and Perl). You can use these to specify a name for tests either > individually (via named_ok) or for a region (via set_name and > unset_name) > What is the benefit of this? The current framework supports 'ok(test,printf-style string)' which seems to be fine for debugging in general, and 'trace' to just print out general purpose information about what the test is doing. Thanks, .Geoff

1 0

winebuild broken?
by Michael Cardenas 09 Apr '02

09 Apr '02

It seems that with the new dll separation changes, winebuild is broken. I've been trying to build an app with winebuild, and it tries to open kernel32.dll.so instead of libkernel32.dll.so when trying to resolve the "import kernel32.dll" line of the spec file. This works for compiling wine, but not for compiling external apps that use the installed lib directory. I'm not sure if I should fix winebuild to look for lib(name).dll.so or if I should change the dll makefiles to create the correct symlinks so that wine can compile or if we should make winebuild check for both lib(name).dll.so and (name).dll.so. For now, I'm doing the last case, which works fine, so I can submit that patch if you want it. There is also the problem of dlls in the wine directory which are not found either, which I'm still working on. -- michael cardenas lead windows compatibility engineer www.lindows.com "Be the change you want to see in the world." -Mahatma Gandhi

1 1

Failing MODULE_DllProcessAttach causes other module left uninitialized
by Uwe Bonnes 09 Apr '02

09 Apr '02

Hallo, in loader/module.c:MODULE_DllProcessAttach the recursion to attach ends as soon as _one_ initialization fails. This leaves other modules uninitialized. I had this problem with xnview and native shell (without native shfolder). The missing SHGetFolderPathA caused COMDLG32_DllEntryPoint to return FALSE and in cause WSVFW32_LibMain wasn't called. Later this caused MULTIMEDIA_GetIData to not find it's IData and cause a crash. The missing HGetFolderPathA wasn't the culprit. I think the original error was obscured to much here. Either we judge a failing InitDLL as error and abort there, or in MODULE_DllProcessAttach we should recurse without looking at the result. What about appended patch? -- Uwe Bonnes bon(a)elektron.ikp.physik.tu-darmstadt.de Institut fuer Kernphysik Schlossgartenstrasse 9 64289 Darmstadt --------- Tel. 06151 162516 -------- Fax. 06151 164321 ---------- Index: wine/loader/module.c =================================================================== RCS file: /home/wine/wine/loader/module.c,v retrieving revision 1.150 diff -u -r1.150 module.c --- wine/loader/module.c 2 Apr 2002 19:47:30 -0000 1.150 +++ wine/loader/module.c 9 Apr 2002 14:06:26 -0000 @@ -212,17 +212,14 @@ wm->flags |= WINE_MODREF_MARKER; /* Recursively attach all DLLs this one depends on */ - for ( i = 0; retv && i < wm->nDeps; i++ ) + for ( i = 0; i < wm->nDeps; i++ ) if ( wm->deps[i] ) - retv = MODULE_DllProcessAttach( wm->deps[i], lpReserved ); + MODULE_DllProcessAttach( wm->deps[i], lpReserved ); /* Call DLL entry point */ + retv = MODULE_InitDLL( wm, DLL_PROCESS_ATTACH, lpReserved ); if ( retv ) - { - retv = MODULE_InitDLL( wm, DLL_PROCESS_ATTACH, lpReserved ); - if ( retv ) - wm->flags |= WINE_MODREF_PROCESS_ATTACHED; - } + wm->flags |= WINE_MODREF_PROCESS_ATTACHED; /* Re-insert MODREF at head of list */ if ( retv && wm->prev )

2 1

Starting application from a directory with some kernel32.dll
by Uwe Bonnes 09 Apr '02

09 Apr '02

Hallo, when an application is run in a directory, where there is also a kernel32.dll, and this is _not_ the system directory, MODULE_GetLoadOrder doesn't strip the path and therefore crashes when native kernel32.dll is loaded. While the header of MODULE_GetLoadOrder talks about "any path is stripped", the function only strips the path for "16 bit modules or if the module resides in the system directory " Is this intended behaviour? Bye -- Uwe Bonnes bon(a)elektron.ikp.physik.tu-darmstadt.de Institut fuer Kernphysik Schlossgartenstrasse 9 64289 Darmstadt --------- Tel. 06151 162516 -------- Fax. 06151 164321 ----------

3 4

Return To Castle Wolfenstein
by Michal Seliga 09 Apr '02

09 Apr '02

Greetings I use wine from 10.3.2002 I tried to run Return To castle Wolfenstain in it. Works almost great! I found few problems I would like to tell you, maybe they are solved already 1) installation: font is wider then expected (I think) so it looks like not all texts are fully visible or they collide with buttons (screenshot on request) 2) installation: in part where i should write an installation code, there are places for 4 characters in all textfields, but when I type in 2 characters it will jump to the next one. It looks like if editfield is xx chars long, then after writing xx/2 characters it thinks it is already all filled 3) game: works in window, but thinks it runs fullscreen. but except of this it runs great (only a bit slow sometimes) 4) game: when I chnged settings a bit it crashed after some minutes, but only once and I don't know hat exactly I changed. I think I switched trueform on, so maybe this is problem (yes I have ATI). but with defaults It worked great I have Mandrake 8.1, but changed to gcc-3.0.1 as default compiler, kernel upgraded to 2.4.19-pre1 and XFree upgraded to 4.2.0 processor Duron700, gfx card ATI Radeon 7500 64MB DDR, motherboard Abit KT7 If you will have some more questions feel free to ask, I don't have the game but it should be no problem to borow from friend (I hope), he already finished it good work people, I was really surprised...

2 1

CVS won't compile with wine/dlls/winsock socket.c ws2_32.spec patch applied
by Tony Lambregts 09 Apr '02

09 Apr '02

wine compiles fine with my system until this patch is applied http://www.winehq.com/hypermail/wine-cvs/2002/04/0087.html after it is applied it stops with the following errors > > socket.c: In function `WSASendTo': > socket.c:1990: sizeof applied to an incomplete type > socket.c:2000: arithmetic on pointer to an incomplete type > socket.c:2000: dereferencing pointer to incomplete type > socket.c:2001: arithmetic on pointer to an incomplete type > socket.c:2001: dereferencing pointer to incomplete type > socket.c: In function `WSARecvFrom': > socket.c:3286: sizeof applied to an incomplete type > socket.c:3295: arithmetic on pointer to an incomplete type > socket.c:3295: dereferencing pointer to incomplete type > socket.c:3296: arithmetic on pointer to an incomplete type > socket.c:3296: dereferencing pointer to incomplete type > make: *** [socket.o] Error 1 I changed directory to dlls/winsock and did make clean make depend make I have attached a log of the session if that will help it seems it doesn't like this code and I (moron user ) can't see anything wrong with it . > int i, n, fd, err = WSAENOTSOCK; > struct iovec* iovec; > struct msghdr msghdr; > > TRACE ("socket %04x, wsabuf %p, nbufs %ld, flags %ld, to %p, tolen > %d, ovl %p, func %p\n", > s, lpBuffers, dwBufferCount, dwFlags, > to, tolen, lpOverlapped, lpCompletionRoutine); > > fd = _get_sock_fd(s); > > if ( fd == -1 ) > goto error; > > iovec = WS_ALLOC ( dwBufferCount * sizeof (struct iovec) ); I welcome your advice, fixes or flames Tony Lambregts Script started on Mon Apr 8 11:29:24 2002 [tony@tony winsock]$ make clean rm -f *.o *.a *.so *.ln \#*\# *~ *% .\#* *.bak *.orig *.rej *.flc *.spec.c *.spec.def *.glue.c y.tab.c y.tab.h lex.yy.c core tests/testlist.c [tony@tony winsock]$ make depend ../../tools/makedep -I. -I. -I../../include -I../../include -C. async.c socket.c -C. [tony@tony winsock]$ make LD_LIBRARY_PATH="../../unicode:$LD_LIBRARY_PATH" ../../tools/winebuild/winebuild -fPIC -L../../dlls -o winsock.spec.c -spec winsock.spec gcc -c -I. -I. -I../../include -I../../include -g -O2 -Wall -fPIC -D__WINE__ -DUSE_WS_PREFIX -D_REENTRANT -I/usr/X11R6/include -o winsock.spec.o winsock.spec.c gcc -c -I. -I. -I../../include -I../../include -g -O2 -Wall -fPIC -D__WINE__ -DUSE_WS_PREFIX -D_REENTRANT -I/usr/X11R6/include -o async.o async.c gcc -c -I. -I. -I../../include -I../../include -g -O2 -Wall -fPIC -D__WINE__ -DUSE_WS_PREFIX -D_REENTRANT -I/usr/X11R6/include -o socket.o socket.c socket.c: In function `WSASendTo': socket.c:1990: sizeof applied to an incomplete type socket.c:2000: arithmetic on pointer to an incomplete type socket.c:2000: dereferencing pointer to incomplete type socket.c:2001: arithmetic on pointer to an incomplete type socket.c:2001: dereferencing pointer to incomplete type socket.c: In function `WSARecvFrom': socket.c:3286: sizeof applied to an incomplete type socket.c:3295: arithmetic on pointer to an incomplete type socket.c:3295: dereferencing pointer to incomplete type socket.c:3296: arithmetic on pointer to an incomplete type socket.c:3296: dereferencing pointer to incomplete type make: *** [socket.o] Error 1 [tony@tony winsock]$ exit exit Script done on Mon Apr 8 11:30:32 2002

2 2

Bitblt::Maskblt code ready for CVS
by Lonnie Cumberland 09 Apr '02

09 Apr '02

Hello All, I have worked out the modifications and implementation for the maskblt() functin in the graphics/bitble.c sources and have been able to run it in my version of wine 20020310 release. How can I get the source for the new bitble.c, or the new Maskblt() routine added to the CVS tree? cheers, Lonnie -- Lonnie Cumberland OutStep Technologies Incorporated EMAIL: Lonnie(a)OutStep.com : Lonnie_Cumberland(a)yahoo.com The Basis Express Virtual Office & Data Backup and Recovery Services URL: http://www.basis-express.com "The Virtual Office without boundaries!!!"

2 1

Invalidation problems
by Dimitrie O. Paun 09 Apr '02

09 Apr '02

People, I think I can reproduce one of those ugly redraw problems. The problem manifests itself in the Microsoft Control Spy. This program looks like in figure http://www.dssd.ca/wine/mscs1.png. If I click on the Styles menu, I get a dialog like this: http://www.dssd.ca/wine/mscs2.png The two list boxes on the right display messages sent to the control on the left. As you can see, when the Styles dialog pops up, it hides part of the listboxes which keep scrolling in the background. Now, what happens is that sometimes, they scroll off with a bit of dialog caption in them as shown here: http://www.dssd.ca/wine/mscs3.png !!! Hope this is helpful to someone more knowledgeable in this area. -- Dimi.

1 1

Re: wine/controls edit.c
by Dimitrie O. Paun 09 Apr '02

09 Apr '02

On April 8, 2002 07:46 pm, Alexandre Julliard wrote: > ChangeSet ID: 1018309592593147649736242 > CVSROOT: /opt/cvs-commit > Module name: wine > Changes by: julliard(a)wine.codeweavers.com 02/04/08 18:46:32 > > Modified files: > controls : edit.c > > Log message: > Dmitry Timoshkov <dmitry(a)codeweavers.com> > Added CS_PARENTDC style. We can see that from the patch :-) Why did you do it though? -- Dimi.

2 1

[PATCH] async IO API, reworked
by Martin Wilck 09 Apr '02

09 Apr '02

Hi, Here is a reworked version of the async API patch which I hope is now ready for being applied. Details see below. Regards, Martin PATCH: async-struct.diff Purpose: Modified API for asynchronous IO requests. - separate cleanly between async scheduling and file IO related issues, - make the API compatible with other types of async requests (e.g. for sockets), - remove exports of async IO related functions for DLL separation. ** This patch OBSOLETES these two patches I submitted: ** http://www.winehq.com/hypermail/wine-patches/2002/04/0020.html http://www.winehq.com/hypermail/wine-patches/2002/04/0034.html Note: the cancel_async server request that was in the previous patch (0020.html) was removed (unnecessary). Patch against: Wine CVS 2002/04/05 Test status: Compiles (no errors/warnings). Tested regular file async IO with ReadFile and ReadFileEx (ok). Added files: include : async.h (structs and inline functions for async requests) Modified files: server : protocol.def (add APC type APC_ASYNC_IO, remove func element of register_async request) async.h (remove func element in async struct) async.c (remove references to func element in async struct) thread.c (allow NULL function pointer for APC_ASYNC_IO requests) dlls/kernel : comm.c (use modified API) files : file.c (use modified API) include : file.h (move async stuff to async.h) scheduler : synchro.c (remove functions now inlined through async.h, call_apcs() calls check_async_list() for APC_ASYNC_IO APCs) diff -ruNX ignore CVS/wine/dlls/kernel/comm.c TMP/wine/dlls/kernel/comm.c --- CVS/wine/dlls/kernel/comm.c Wed Apr 3 19:32:56 2002 +++ TMP/wine/dlls/kernel/comm.c Fri Apr 5 11:19:40 2002 @@ -91,6 +91,53 @@ WINE_DEFAULT_DEBUG_CHANNEL(comm); +/*********************************************************************** + * Asynchronous I/O for asynchronous wait requests * + */ +#include "async.h" + +static DWORD commio_get_async_status (const async_private *ovp); +static DWORD commio_get_async_count (const async_private *ovp); +static void commio_set_async_status (async_private *ovp, const DWORD status); +static void CALLBACK commio_call_completion_func (ULONG_PTR data); + +static async_ops commio_async_ops = +{ + commio_get_async_status, /* get_status */ + commio_set_async_status, /* set_status */ + commio_get_async_count, /* get_count */ + commio_call_completion_func /* call_completion */ +}; + +typedef struct async_commio +{ + struct async_private async; + LPOVERLAPPED lpOverlapped; + char *buffer; +} async_commio; + +static DWORD commio_get_async_status (const struct async_private *ovp) +{ + return ((async_commio*) ovp)->lpOverlapped->Internal; +} + +static void commio_set_async_status (async_private *ovp, const DWORD status) +{ + ((async_commio*) ovp)->lpOverlapped->Internal = status; +} + +static DWORD commio_get_async_count (const struct async_private *ovp) +{ + return 0; +} + +static void CALLBACK commio_call_completion_func (ULONG_PTR data) +{ + HeapFree(GetProcessHeap(), 0, (void*) data); +} + +/***********************************************************************/ + #if !defined(TIOCINQ) && defined(FIONREAD) #define TIOCINQ FIONREAD #endif @@ -1558,12 +1605,13 @@ */ static void COMM_WaitCommEventService(async_private *ovp) { - LPOVERLAPPED lpOverlapped = ovp->lpOverlapped; + async_commio *commio = (async_commio*) ovp; + LPOVERLAPPED lpOverlapped = commio->lpOverlapped; TRACE("overlapped %p\n",lpOverlapped); /* FIXME: detect other events */ - *ovp->buffer = EV_RXCHAR; + *commio->buffer = EV_RXCHAR; lpOverlapped->Internal = STATUS_SUCCESS; } @@ -1579,8 +1627,8 @@ LPDWORD lpdwEvents, /* [out] event(s) that were detected */ LPOVERLAPPED lpOverlapped) /* [in/out] for Asynchronous waiting */ { - int fd,ret; - async_private *ovp; + int fd; + async_commio *ovp; if(!lpOverlapped) { @@ -1591,53 +1639,32 @@ if(NtResetEvent(lpOverlapped->hEvent,NULL)) return FALSE; - lpOverlapped->Internal = STATUS_PENDING; - lpOverlapped->InternalHigh = 0; - lpOverlapped->Offset = 0; - lpOverlapped->OffsetHigh = 0; - fd = FILE_GetUnixHandle( hFile, GENERIC_WRITE ); if(fd<0) return FALSE; - ovp = (async_private *) HeapAlloc(GetProcessHeap(), 0, sizeof (async_private)); + ovp = (async_commio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_commio)); if(!ovp) { close(fd); return FALSE; } - ovp->event = lpOverlapped->hEvent; + + ovp->async.ops = &commio_async_ops; + ovp->async.handle = hFile; + ovp->async.fd = fd; + ovp->async.type = ASYNC_TYPE_WAIT; + ovp->async.func = COMM_WaitCommEventService; + ovp->async.event = lpOverlapped->hEvent; ovp->lpOverlapped = lpOverlapped; - ovp->func = COMM_WaitCommEventService; ovp->buffer = (char *)lpdwEvents; - ovp->fd = fd; - ovp->count = 0; /- ovp->completion_func = 0; - ovp->type = ASYNC_TYPE_WAIT; - ovp->handle = hFile; - - ovp->next = NtCurrentTeb()->pending_list; - ovp->prev = NULL; - if(ovp->next) - ovp->next->prev=ovp; - NtCurrentTeb()->pending_list = ovp; - - /* start an ASYNCHRONOUS WaitCommEvent */ - SERVER_START_REQ( register_async ) - { - req->handle = hFile; - req->overlapped = lpOverlapped; - req->type = ASYNC_TYPE_WAIT; - req->count = 0; - req->func = check_async_list; - req->status = STATUS_PENDING; - ret=wine_server_call_err(req); - } - SERVER_END_REQ; + lpOverlapped->InternalHigh = 0; + lpOverlapped->Offset = 0; + lpOverlapped->OffsetHigh = 0; - if (!ret) - SetLastError(ERROR_IO_PENDING); + if ( !register_new_async (&ovp->async) ) + SetLastError( ERROR_IO_PENDING ); return FALSE; } diff -ruNX ignore CVS/wine/files/file.c TMP/wine/files/file.c --- CVS/wine/files/file.c Wed Apr 3 19:32:56 2002 +++ TMP/wine/files/file.c Fri Apr 5 12:15:58 2002 @@ -64,6 +64,65 @@ WINE_DEFAULT_DEBUG_CHANNEL(file); +/*********************************************************************** + * Asynchronous file I/O * + */ +#include "async.h" + +static DWORD fileio_get_async_status (const async_private *ovp); +static DWORD fileio_get_async_count (const async_private *ovp); +static void fileio_set_async_status (async_private *ovp, const DWORD status); +static void CALLBACK fileio_call_completion_func (ULONG_PTR data); + +static async_ops fileio_async_ops = +{ + fileio_get_async_status, /* get_status */ + fileio_set_async_status, /* set_status */ + fileio_get_async_count, /* get_count */ + fileio_call_completion_func /* call_completion */ +}; + +typedef struct async_fileio +{ + struct async_private async; + LPOVERLAPPED lpOverlapped; + LPOVERLAPPED_COMPLETION_ROUTINE completion_func; + char *buffer; + int count; +} async_fileio; + +static DWORD fileio_get_async_status (const struct async_private *ovp) +{ + return ((async_fileio*) ovp)->lpOverlapped->Internal; +} + +static void fileio_set_async_status (async_private *ovp, const DWORD status) +{ + ((async_fileio*) ovp)->lpOverlapped->Internal = status; +} + +static DWORD fileio_get_async_count (const struct async_private *ovp) +{ + async_fileio *fileio = (async_fileio*) ovp; + DWORD ret = fileio->count - fileio->lpOverlapped->InternalHigh; + return (ret < 0 ? 0 : ret); +} + +static void CALLBACK fileio_call_completion_func (ULONG_PTR data) +{ + async_fileio *ovp = (async_fileio*) data; + TRACE ("data: %p\n", ovp); + + if (ovp->completion_func) + ovp->completion_func(ovp->lpOverlapped->Internal, + ovp->lpOverlapped->InternalHigh, + ovp->lpOverlapped); + + HeapFree(GetProcessHeap(), 0, ovp); +} + +/***********************************************************************/ + #if defined(MAP_ANONYMOUS) && !defined(MAP_ANON) #define MAP_ANON MAP_ANONYMOUS #endif @@ -1344,30 +1403,6 @@ return (r==WAIT_OBJECT_0); } - -/*********************************************************************** - * FILE_StartAsync (INTERNAL) - * - * type==ASYNC_TYPE_NONE means cancel the indicated overlapped operation - * lpOverlapped==NULL means all overlappeds match - */ -BOOL FILE_StartAsync(HANDLE hFile, LPOVERLAPPED lpOverlapped, DWORD type, DWORD count, DWORD status) -{ - BOOL ret; w- SERVER_START_REQ(register_async) - { - req->handle = hFile; - req->overlapped = lpOverlapped; - req->type = type; - req->count = count; - req->func = check_async_list; - req->status = status; - ret = wine_server_call( req ); - } - SERVER_END_REQ; - return !ret; -} - /*********************************************************************** * CancelIo (KERNEL32.@) */ @@ -1377,16 +1412,11 @@ TRACE("handle = %x\n",handle); - ovp = NtCurrentTeb()->pending_list; - while(ovp) + for (ovp = NtCurrentTeb()->pending_list; ovp; ovp = t) { t = ovp->next; - if(FILE_StartAsync(handle, ovp->lpOverlapped, ovp->type, 0, STATUS_CANCELLED)) - { - TRACE("overlapped = %p\n",ovp->lpOverlapped); - finish_async(ovp, STATUS_CANCELLED); - } - ovp = t; + if ( ovp->handle == handle ) + cancel_async ( ovp ); } WaitForMultipleObjectsEx(0,NULL,FALSE,1,TRUE); return TRUE; @@ -1400,18 +1430,19 @@ */ static void FILE_AsyncReadService(async_private *ovp) { - LPOVERLAPPED lpOverlapped = ovp->lpOverlapped; + async_fileio *fileio = (async_fileio*) ovp; + LPOVERLAPPED lpOverlapped = fileio->lpOverlapped; int result, r; int already = lpOverlapped->InternalHigh; - TRACE("%p %p\n", lpOverlapped, ovp->buffer ); + TRACE("%p %p\n", lpOverlapped, fileio->buffer ); /* check to see if the data is ready (non-blocking) */ - result = pread (ovp->fd, &ovp->buffer[already], ovp->count - already, + result = pread (ovp->fd, &fileio->buffer[already], fileio->count - already, OVERLAPPED_OFFSET (lpOverlapped) + already); if ((result < 0) && (errno == ESPIPE)) - result = read (ovp->fd, &ovp->buffer[already], ovp->count - already); + result = read (ovp->fd, &fileio->buffer[already], fileio->count - already); if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR))) { @@ -1429,9 +1460,9 @@ } lpOverlapped->InternalHigh += result; - TRACE("read %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,ovp->count); + TRACE("read %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,fileio->count); - if(lpOverlapped->InternalHigh < ovp->count) + if(lpOverlapped->InternalHigh < fileio->count) r = STATUS_PENDING; else r = STATUS_SUCCESS; @@ -1448,7 +1479,7 @@ LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, HANDLE hEvent) { - async_private *ovp; + async_fileio *ovp; int fd; TRACE("file %d to buf %p num %ld %p func %p\n", @@ -1468,7 +1499,7 @@ return FALSE; } - ovp = (async_private *) HeapAlloc(GetProcessHeap(), 0, sizeof (async_private)); + ovp = (async_fileio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_fileio)); if(!ovp) { TRACE("HeapAlloc Failed\n"); @@ -1476,31 +1507,19 @@ close(fd); return FALSE; } - ovp->event = hEvent; + + ovp->async.ops = &fileio_async_ops; + ovp->async.handle = hFile; + ovp->async.fd = fd; + ovp->async.type = ASYNC_TYPE_READ; + ovp->async.func = FILE_AsyncReadService; + ovp->async.event = hEvent; ovp->lpOverlapped = overlapped; ovp->count = bytesToRead; ovp->completion_func = lpCompletionRoutine; - ovp->func = FILE_AsyncReadService; ovp->buffer = buffer; - ovp->fd = fd; - ovp->type = ASYNC_TYPE_READ; - ovp->handle = hFile; - - /* hook this overlap into the pending async operation list */ - ovp->next = NtCurrentTeb()->pending_list; - ovp->prev = NULL; - if(ovp->next) - ovp->next->prev = ovp; - NtCurrentTeb()->pending_list = ovp; - if ( !FILE_StartAsync(hFile, overlapped, ASYNC_TYPE_READ, bytesToRead, STATUS_PENDING) ) - { - /* FIXME: remove async_private and release memory */ - ERR("FILE_StartAsync failed\n"); - return FALSE; - } - - return TRUE; + return !register_new_async (&ovp->async); } /*********************************************************************** @@ -1510,7 +1529,6 @@ LPOVERLAPPED overlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine) { - overlapped->Internal = STATUS_PENDING; overlapped->InternalHigh = 0; return FILE_ReadFileEx(hFile,buffer,bytesToRead,overlapped,lpCompletionRoutine, INVALID_HANDLE_VALUE); } @@ -1588,7 +1606,6 @@ } /* at last resort, do an overlapped read */ - overlapped->Internal = STATUS_PENDING; overlapped->InternalHigh = result; if(!FILE_ReadFileEx(hFile, buffer, bytesToRead, overlapped, NULL, overlapped->hEvent)) @@ -1646,18 +1663,19 @@ */ static void FILE_AsyncWriteService(struct async_private *ovp) { - LPOVERLAPPED lpOverlapped = ovp->lpOverlapped; + async_fileio *fileio = (async_fileio *) ovp; + LPOVERLAPPED lpOverlapped = fileio->lpOverlapped; int result, r; int already = lpOverlapped->InternalHigh; - TRACE("(%p %p)\n",lpOverlapped,ovp->buffer); + TRACE("(%p %p)\n",lpOverlapped,fileio->buffer); /* write some data (non-blocking) */ - result = pwrite(ovp->fd, &ovp->buffer[already], ovp->count - already, + result = pwrite(ovp->fd, &fileio->buffer[already], fileio->count - already, OVERLAPPED_OFFSET (lpOverlapped) + already); if ((result < 0) && (errno == ESPIPE)) - result = write(ovp->fd, &ovp->buffer[already], ovp->count - already); + result = write(ovp->fd, &fileio->buffer[already], fileio->count - already); if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR))) { @@ -1674,9 +1692,9 @@ lpOverlapped->InternalHigh += result; - TRACE("wrote %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,ovp->count); + TRACE("wrote %d more bytes %ld/%d so far\n",result,lpOverlapped->InternalHigh,fileio->count); - if(lpOverlapped->InternalHigh < ovp->count) + if(lpOverlapped->InternalHigh < fileio->count) r = STATUS_PENDING; else r = STATUS_SUCCESS; @@ -1693,7 +1711,8 @@ LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, HANDLE hEvent) { - async_private *ovp; + async_fileio *ovp; + int fd; TRACE("file %d to buf %p num %ld %p func %p stub\n", hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine); @@ -1704,46 +1723,34 @@ return FALSE; } - overlapped->Internal = STATUS_PENDING; - overlapped->InternalHigh = 0; - - if (!FILE_StartAsync(hFile, overlapped, ASYNC_TYPE_WRITE, bytesToWrite, STATUS_PENDING )) + fd = FILE_GetUnixHandle( hFile, GENERIC_WRITE ); + if ( fd < 0 ) { - TRACE("FILE_StartAsync failed\n"); + TRACE( "Couldn't get FD\n" ); return FALSE; } - ovp = (async_private*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_private)); + ovp = (async_fileio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_fileio)); if(!ovp) { TRACE("HeapAlloc Failed\n"); SetLastError(ERROR_NOT_ENOUGH_MEMORY); + close (fd); return FALSE; } + + ovp->async.ops = &fileio_async_ops; + ovp->async.handle = hFile; + ovp->async.fd = FILE_GetUnixHandle( hFile, GENERIC_WRITE ); + ovp->async.type = ASYNC_TYPE_WRITE; + ovp->async.func = FILE_AsyncWriteService; ovp->lpOverlapped = overlapped; - ovp->event = hEvent; - ovp->func = FILE_AsyncWriteService; + ovp->async.event = hEvent; ovp->buffer = (LPVOID) buffer; ovp->count = bytesToWrite; ovp->completion_func = lpCompletionRoutine; - ovp->fd = FILE_GetUnixHandle( hFile, GENERIC_WRITE ); - ovp->type = ASYNC_TYPE_WRITE; - ovp->handle = hFile; - if(ovp->fd <0) - { - HeapFree(GetProcessHeap(), 0, ovp); - return FALSE; - } - - /* hook this overlap into the pending async operation list */ - ovp->next = NtCurrentTeb()->pending_list; - ovp->prev = NULL; - if(ovp->next) - ovp->next->prev = ovp; - NtCurrentTeb()->pending_list = ovp; - - return TRUE; + return !register_new_async (&ovp->async); } /*********************************************************************** @@ -1753,7 +1760,6 @@ LPOVERLAPPED overlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine) { - overlapped->Internal = STATUS_PENDING; overlapped->InternalHigh = 0; return FILE_WriteFileEx(hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine, INVALID_HANDLE_VALUE); diff -ruNX ignore CVS/wine/include/async.h TMP/wine/include/async.h --- CVS/wine/include/async.h Thu Jan 1 01:00:00 1970 +++ TMP/wine/include/async.h Fri Apr 5 12:24:13 2002 @@ -0,0 +1,124 @@ +/* + * Structures and static functions for handling asynchronous I/O. + * + * Copyright (C) 2002 Mike McCormack, Martin Wilck + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* + * This file declares static functions. + * It should only be included by those source files that implement async I/O requests. + */ + +#ifndef __WINE_ASYNC_H +#define __WINE_ASYNC_H + +struct async_private; + +typedef void (*async_handler)(struct async_private *ovp); +typedef void CALLBACK (*async_call_completion_func)(ULONG_PTR data); +typedef DWORD (*async_get_status)(const struct async_private *ovp); +typedef DWORD (*async_get_count)(const struct async_private *ovp); +typedef void (*async_set_status)(struct async_private *ovp, const DWORD status); + +typedef struct async_ops +{ + async_get_status get_status; + async_set_status set_status; + async_get_count get_count; + async_call_completion_func call_completion; +} async_ops; + +typedef struct async_private +{ + struct async_ops *ops; + HANDLE handle; + HANDLE event; + int fd; + async_handler func; + int type; + struct async_private *next; + struct async_private *prev; +} async_private; + +/* All functions declared static for Dll separation purposes */ + +inline static void finish_async( async_private *ovp ) +{ + if(ovp->prev) + ovp->prev->next = ovp->next; + else + NtCurrentTeb()->pending_list = ovp->next; + + if(ovp->next) + ovp->next->prev = ovp->prev; + + ovp->next = ovp->prev = NULL; + + close( ovp->fd ); + if( ovp->event != INVALID_HANDLE_VALUE ) + NtSetEvent( ovp->event, NULL ); + + QueueUserAPC( ovp->ops->call_completion, GetCurrentThread(), (ULONG_PTR)ovp ); +} + +inline static BOOL __register_async( async_private *ovp, const DWORD status ) +{ + BOOL ret; + + SERVER_START_REQ( register_async ) + { + req->handle = ovp->handle; + req->overlapped = ovp; + req->type = ovp->type; + req->count = ovp->ops->get_count( ovp ); + req->status = status; + ret = wine_server_call( req ); + } + SERVER_END_REQ; + + if ( ret ) ovp->ops->set_status ( ovp, GetLastError() ); + if ( ovp->ops->get_status (ovp) != STATUS_PENDING ) + finish_async (ovp); + + return ret; +} + +#define register_old_async(ovp) \ + __register_async (ovp, ovp->ops->get_status( ovp )); + +inline static BOOL register_new_async( async_private *ovp ) +{ + ovp->ops->set_status ( ovp, STATUS_PENDING ); + + ovp->next = NtCurrentTeb()->pending_list; + ovp->prev = NULL; + if ( ovp->next ) ovp->next->prev = ovp; + NtCurrentTeb()->pending_list = ovp; + + return __register_async( ovp, STATUS_PENDING ); +} + +inline static BOOL cancel_async ( async_private *ovp ) +{ + /* avoid multiple cancellations */ + if ( ovp->ops->get_status( ovp ) != STATUS_PENDING ) + return 0; + ovp->ops->set_status ( ovp, STATUS_CANCELLED ); + return __register_async ( ovp, STATUS_CANCELLED ); +} + +#endif /* __WINE_ASYNC_H */ diff -ruNX ignore CVS/wine/include/file.h TMP/wine/include/file.h --- CVS/wine/include/file.h Wed Apr 3 19:32:56 2002 +++ TMP/wine/include/file.h Fri Apr 5 11:19:40 2002 @@ -46,27 +46,6 @@ int flags; } DOS_DEVICE; -/* overlapped private structure */ -struct async_private; -typedef void (*async_handler)(struct async_private *ovp); -typedef struct async_private -{ - LPOVERLAPPED lpOverlapped; - HANDLE handle; - HANDLE event; - int fd; - char *buffer; - async_handler func; - int count; - int type; - LPOVERLAPPED_COMPLETION_ROUTINE completion_func; - struct async_private *next; - struct async_private *prev; -} async_private; - -extern void WINAPI check_async_list(LPOVERLAPPED ov, DWORD status); -extern void finish_async(struct async_private *ovp, DWORD status); - /* locale-independent case conversion */ inline static char FILE_tolower( char c ) { @@ -99,7 +78,6 @@ DWORD attributes, HANDLE template, BOOL fail_read_only, UINT drive_type ); extern HANDLE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa ); -extern BOOL FILE_StartAsync(HANDLE handle, LPOVERLAPPED lpOverlapped, DWORD type, DWORD count, DWORD status); extern LONG WINAPI WIN16_hread(HFILE16,SEGPTR,LONG); diff -ruNX ignore CVS/wine/include/wine/server_protocol.h TMP/wine/include/wine/server_protocol.h --- CVS/wine/include/wine/server_protocol.h Tue Apr 2 15:39:35 2002 +++ TMP/wine/include/wine/server_protocol.h Fri Apr 5 12:21:25 2002 @@ -502,7 +502,7 @@ int type; /* VARARG(args,ptrs); */ }; -enum apc_type { APC_NONE, APC_USER, APC_TIMER, APC_ASYNC }; +enum apc_type { APC_NONE, APC_USER, APC_TIMER, APC_ASYNC, APC_ASYNC_IO }; @@ -2278,7 +2278,6 @@ { struct request_header __header; handle_t handle; - void* func; int type; void* overlapped; int count; @@ -3184,6 +3183,6 @@ struct get_window_properties_reply get_window_properties_reply; }; -#define SERVER_PROTOCOL_VERSION 77 +#define SERVER_PROTOCOL_VERSION 78 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */ diff -ruNX ignore CVS/wine/scheduler/synchro.c TMP/wine/scheduler/synchro.c --- CVS/wine/scheduler/synchro.c Wed Apr 3 19:32:56 2002 +++ TMP/wine/scheduler/synchro.c Fri Apr 5 12:35:35 2002 @@ -30,6 +30,7 @@ #include "thread.h" #include "winerror.h" #include "wine/server.h" +#include "async.h" /*********************************************************************** @@ -50,74 +51,32 @@ } } -static void CALLBACK call_completion_routine(ULONG_PTR data) -{ - async_private* ovp = (async_private*)data; - - ovp->completion_func(ovp->lpOverlapped->Internal, - ovp->lpOverlapped->InternalHigh, - ovp->lpOverlapped); - ovp->completion_func=NULL; - HeapFree(GetProcessHeap(), 0, ovp); -} - -void finish_async(async_private *ovp, DWORD status) -{ - ovp->lpOverlapped->Internal=status; - - /* call ReadFileEx/WriteFileEx's overlapped completion function */ - if(ovp->completion_func) - { - QueueUserAPC(call_completion_routine,GetCurrentThread(),(ULONG_PTR)ovp); - } - - /* remove it from the active list */ - if(ovp->prev) - ovp->prev->next = ovp->next; - else - NtCurrentTeb()->pending_list = ovp->next; - - if(ovp->next) - ovp->next->prev = ovp->prev; - - ovp->next=NULL; - ovp->prev=NULL; - - close(ovp->fd); - if(ovp->event!=INVALID_HANDLE_VALUE) - NtSetEvent(ovp->event,NULL); - if(!ovp->completion_func) HeapFree(GetProcessHeap(), 0, ovp); -} - /*********************************************************************** * check_async_list * * Process a status event from the server. */ -void WINAPI check_async_list(LPOVERLAPPED overlapped, DWORD status) +static void WINAPI check_async_list(async_private *asp, DWORD status) { async_private *ovp; + DWORD ovp_status; - /* fprintf(stderr,"overlapped %p status %x\n",overlapped,status); */ + for( ovp = NtCurrentTeb()->pending_list; ovp && ovp != asp; ovp = ovp->next ); - for(ovp = NtCurrentTeb()->pending_list; ovp; ovp = ovp->next) - if(ovp->lpOverlapped == overlapped) - break; - - if(!ovp) + if(!ovp) return; - if(status != STATUS_ALERTED) - ovp->lpOverlapped->Internal = status; + if( status != STATUS_ALERTED ) + { + ovp_status = status; + ovp->ops->set_status (ovp, status); + } + else ovp_status = ovp->ops->get_status (ovp); - if(ovp->lpOverlapped->Internal==STATUS_PENDING) - { - ovp->func(ovp); - FILE_StartAsync(ovp->handle, ovp->lpOverlapped, ovp->type, 0, ovp->lpOverlapped->Internal); - } + if( ovp_status == STATUS_PENDING ) ovp->func( ovp ); - if(ovp->lpOverlapped->Internal!=STATUS_PENDING) - finish_async(ovp,ovp->lpOverlapped->Internal); + /* This will destroy all but PENDING requests */ + register_old_async( ovp ); } @@ -200,6 +159,9 @@ /* convert sec/usec to NT time */ DOSFS_UnixTimeToFileTime( (time_t)args[0], &ft, (DWORD)args[1] * 10 ); proc( args[2], ft.dwLowDateTime, ft.dwHighDateTime ); + break; + case APC_ASYNC_IO: + check_async_list ( args[0], (DWORD) args[1]); break; default: server_protocol_error( "get_apc_request: bad type %d\n", type ); diff -ruNX ignore CVS/wine/server/async.c TMP/wine/server/async.c --- CVS/wine/server/async.c Wed Apr 3 19:32:56 2002 +++ TMP/wine/server/async.c Fri Apr 5 12:22:32 2002 @@ -64,7 +64,7 @@ { /* fprintf(stderr,"notifying %p!\n",async->overlapped); */ async->status = status; - thread_queue_apc(async->thread, NULL, async->func, APC_ASYNC, 1, 2, async->overlapped, status); + thread_queue_apc(async->thread, NULL, NULL, APC_ASYNC_IO, 1, 2, async->overlapped, status); } void destroy_async_queue( struct async_queue *q ) @@ -116,7 +116,7 @@ destroy_async(async); } -struct async *create_async(struct object *obj, struct thread *thread, void *func, +struct async *create_async(struct object *obj, struct thread *thread, void *overlapped) { struct async *async = (struct async *) malloc(sizeof(struct async)); @@ -128,7 +128,6 @@ async->obj = obj; async->thread = thread; - async->func = func; async->overlapped = overlapped; async->next = NULL; async->prev = NULL; @@ -165,7 +164,7 @@ if(req->status==STATUS_PENDING) { if(!async) - async = create_async(obj, current, req->func, req->overlapped); + async = create_async(obj, current, req->overlapped); if(async) { diff -ruNX ignore CVS/wine/server/async.h TMP/wine/server/async.h --- CVS/wine/server/async.h Tue Apr 2 15:39:41 2002 +++ TMP/wine/server/async.h Fri Apr 5 11:19:45 2002 @@ -30,7 +30,6 @@ { struct object *obj; struct thread *thread; - void *func; void *overlapped; unsigned int status; struct timeval when; @@ -51,7 +50,7 @@ struct async *find_async(struct async_queue *q, struct thread *thread, void *overlapped); void async_insert(struct async_queue *q, struct async *async); struct async *create_async(struct object *obj, struct thread *thread, - void *func, void *overlapped); + void *overlapped); void async_add_timeout(struct async *async, int timeout); static inline void init_async_queue(struct async_queue *q) { diff -ruNX ignore CVS/wine/server/protocol.def TMP/wine/server/protocol.def --- CVS/wine/server/protocol.def Wed Apr 3 19:32:56 2002 +++ TMP/wine/server/protocol.def Fri Apr 5 12:17:37 2002 @@ -412,7 +412,7 @@ int type; /* function type */ VARARG(args,ptrs); /* function arguments */ @END -enum apc_type { APC_NONE, APC_USER, APC_TIMER, APC_ASYNC }; +enum apc_type { APC_NONE, APC_USER, APC_TIMER, APC_ASYNC, APC_ASYNC_IO }; /* Close a handle for the current process */ @@ -1615,10 +1615,9 @@ #define SERIALINFO_SET_ERROR 0x04 -/* Create/Destroy an async I/O */ +/* Create / reschedule an async I/O */ @REQ(register_async) handle_t handle; /* handle to comm port, socket or file */ - void* func; int type; void* overlapped; int count; diff -ruNX ignore CVS/wine/server/thread.c TMP/wine/server/thread.c --- CVS/wine/server/thread.c Tue Apr 2 15:39:42 2002 +++ TMP/wine/server/thread.c Fri Apr 5 11:19:45 2002 @@ -959,8 +959,9 @@ } /* Optimization: ignore APCs that have a NULL func; they are only used * to wake up a thread, but since we got here the thread woke up already. + * Exception: for APC_ASYNC_IO, func == NULL is legal. */ - if (apc->func) break; + if (apc->func || apc->type == APC_ASYNC_IO) break; free( apc ); } size = apc->nb_args * sizeof(apc->args[0]); diff -ruNX ignore CVS/wine/server/trace.c TMP/wine/server/trace.c --- CVS/wine/server/trace.c Wed Apr 3 19:32:56 2002 +++ TMP/wine/server/trace.c Fri Apr 5 12:21:25 2002 @@ -1846,7 +1846,6 @@ static void dump_register_async_request( const struct register_async_request *req ) { fprintf( stderr, " handle=%d,", req->handle ); - fprintf( stderr, " func=%p,", req->func ); fprintf( stderr, " type=%d,", req->type ); fprintf( stderr, " overlapped=%p,", req->overlapped ); fprintf( stderr, " count=%d,", req->count );

3 4

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel