April 2002 - Wine-Devel - list.winehq.org

Regression tests, UNICODE vs ASCII
by Geoffrey Hausheer April 14, 2002

April 14, 2002

So I've finally started writing tests for functions that have both Unicode and Ascii equivalents, and I'm wondering how to write the tests. I re-read the thread about this that occurred back in January, and there didn't seem to be a clear decision. With the current framework, it doesn't appear to be possible to just write one test, and have it build both unicode and ascii versions, and it seems like at least Alexandre was strongly against this anyway. But in my case, I know nothing at all about writing Unicode tests, or how to explicitly test unicode functionality, so I see that I have three options: 1) Don't write any 'W' tests, and use only 'A' functions in my tests 2) Duplicate my 'A' tests as 'W' tests, and acknowledge that there is likely Unicode specific stuff that is not tested 3) Learn something about Unicode, and figure out how to test the functions correctly. Now obvioulsy (3) is the best choice, but honestly, I am not motivated towards this at the moment. Which leaves (1) and (2), with (2) being the way I'm leaning. But the tests are getting really big, and pretty messy, and duplicating them and managing both versions looks like a nightmare (there are lots of TODOs, and I expect the tests to behave differently on different OS). So what is the recomendation that I do? In the simplest case, I can just copy the Ascii test to a new file and replace all 'A' with 'W', and just keep the tests seperated that way. Anyhow, any comments would be appreciated. Thanks, .Geoff

4 4

Re: Regression tests, UNICODE vs ASCII
by Lina Kemmel April 14, 2002

April 14, 2002

P.S. By "2 code pages" I meant *ANSI* code pages, of course.. Lina Hi, At least 2 code pages contain a couple of BiDi control characters: * Left-to-Right Mark (LRM) and Right-to-Left Mark (RLM) present in both 1255 and 1256 code pages (0xFD and 0xFE); * Zero Width Non-Joiner (ZWNJ) and Zero Width Joiner (ZWJ) -- in cp1256 (0x9D and 0x9E). Lina Shachar Shemesh <wine-devel(a)sun.consumer.org.il> Sent by: wine-devel-admin(a)winehq.com 14/04/02 09:50 ص Please respond to Shachar Shemesh To: Francois Gouget <fgouget(a)free.fr> cc: Andriy Palamarchuk <apa3a(a)yahoo.com>, Geoffrey Hausheer <i8e7fkwmsl1(a)phracturedblue.com>, wine-devel(a)winehq.com Subject: Re: Regression tests, UNICODE vs ASCII One thing you may try are the explicit BiDi specifiers (Right to left, left to right etc.). These are Unicode characters designed to explicitly specify the direction of otherwise amigious characters. Ansii does not have, to the best of my knowledge, an equivalent encoded characters. Shachar Francois Gouget wrote: >On Mon, 8 Apr 2002, Andriy Palamarchuk wrote: > >>A couple comments: >>1) it is useful to check intermixed API calls, like >>A->W->A to be sure they do conversions correctly. >>2) while testing W functions use some Unicode symbols >>which do not have corresponding ASCII symbols. >> > > Could you give a couple examples of these Unicode symbols? I know >that I would be hard-pressed to make up a Unicode string with anything >significant. But if I had an example to base my code on, integrating it >into my own tests should be trivial. > >-- >Francois Gouget fgouget(a)free.fr http://fgouget.free.fr/ > 1 + e ^ ( i * pi ) = 0 >

1 0

Re: Regression tests, UNICODE vs ASCII
by Lina Kemmel April 14, 2002

April 14, 2002

Hi, At least 2 code pages contain a couple of BiDi control characters: * Left-to-Right Mark (LRM) and Right-to-Left Mark (RLM) present in both 1255 and 1256 code pages (0xFD and 0xFE); * Zero Width Non-Joiner (ZWNJ) and Zero Width Joiner (ZWJ) -- in cp1256 (0x9D and 0x9E). Lina Shachar Shemesh <wine-devel(a)sun.consumer.org.il> Sent by: wine-devel-admin(a)winehq.com 14/04/02 09:50 ص Please respond to Shachar Shemesh To: Francois Gouget <fgouget(a)free.fr> cc: Andriy Palamarchuk <apa3a(a)yahoo.com>, Geoffrey Hausheer <i8e7fkwmsl1(a)phracturedblue.com>, wine-devel(a)winehq.com Subject: Re: Regression tests, UNICODE vs ASCII One thing you may try are the explicit BiDi specifiers (Right to left, left to right etc.). These are Unicode characters designed to explicitly specify the direction of otherwise amigious characters. Ansii does not have, to the best of my knowledge, an equivalent encoded characters. Shachar Francois Gouget wrote: >On Mon, 8 Apr 2002, Andriy Palamarchuk wrote: > >>A couple comments: >>1) it is useful to check intermixed API calls, like >>A->W->A to be sure they do conversions correctly. >>2) while testing W functions use some Unicode symbols >>which do not have corresponding ASCII symbols. >> > > Could you give a couple examples of these Unicode symbols? I know >that I would be hard-pressed to make up a Unicode string with anything >significant. But if I had an example to base my code on, integrating it >into my own tests should be trivial. > >-- >Francois Gouget fgouget(a)free.fr http://fgouget.free.fr/ > 1 + e ^ ( i * pi ) = 0 >

1 0

X11 fork available
by Ove Kaaven April 13, 2002

April 13, 2002

Ever since the main Wine tree changed its license to the LGPL, a fork of the tree under the old license had seemed necessary, and been planned. This fork is now ready. If you're a Wine contributor that don't care all that much about forking, you do not need to leave the official LGPL-ed Wine tree to let the X11-licensed fork live. All you have to do is to agree to license your patches under the X11 license, so we are able to pick it up from wine-patches and apply it to the X11 tree whenever possible. This will make your contributions more widely used, so we encourage as many as possible to do so. And if it's out of the question for you, then we encourage you to tell us that, so that we know that we can never apply your patches. The fork's name was decided after a lot of brainstorming by Eric and me, when we found a name which we both liked... ReWind. It can stand for "Re-engineering Windows", or something like "Rewind to the old Windows days". The fork is currently hosted on SourceForge. The homepage is thus http://rewind.sourceforge.net/ for now. It's not a very fancy page, but all the necessary CVS and mailing list information is there. Go there if you're interested in contributing actively to ReWind. Patches known to come from X11-friendly contributors are already applied to the CVS, but many more patches are waiting for the authors to declare a stance. The CVS repository that ReWind is based on is the WineHQ repository, cleansed of all post-LGPL commits (except the Before-LGPL tag), so all the CVS history of the pre-LGPL Wine is present in the ReWind CVS repository. This ensures that no history is lost in the event that the X11 fork prevails over the LGPL fork. Your help to achieve this is welcome. Followups to this post should preferably go to wine-license. Thanks for your attention.

1 0

Looking for help to implement IOCTL_SCSI_PASS_THROUGH_DIRECT
by Laurent Pinchart April 12, 2002

April 12, 2002

Hi, I need to implement IOCTL_SCSI_PASS_THROUGH_DIRECT for cdroms (and a few other IOCTLs, like IOCTL_SCSI_GET_ADDRESS). As I don't have enough SCSI & cdrom handling experience, I wonder if someone could help me getting started. Should I use the linux CDROM_SEND_PACKET ioctl ? If so, how should I handle the 16-byte command from the windows IOCTL_SCSI_PASS_THROUGH_DIRECT, as the command is 12-bytes long for CDROM_SEND_PACKET ? Any help will be appreciated. Laurent Pinchart

1 0

update to regression testing framework
by Paul Millar April 12, 2002

April 12, 2002

Hi, The attached patch changes the way the regression testing works slightly. The default behaviour should be the same, but there's some optional "enhancements": o If you set WINETEST_REPORT_SUCCESS environment variable to 1, successful tests are reported as well as unsuccessful ones. o If you set WINETEST_CONTINUE_ON_FAIL environment variable to 1, "make test" will run all tests from all modules, rather than failing on the first failing module. 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) The patch changes both the C and Perl frameworks. I'm pretty sure the Perl is right but someone who actually knows Perl ought to check it :) The second patch illustrates these by changing dlls/kernel/tests/atom.pl and dlls/kernel/tests/directory.c (apologies to Alexandre & Dmitry if I got the test semantics wrong). HTH ---- Paul Millar ChangeLog: Adding test names and some optional behaviour.

4 6

Patch: sock-shutdown.diff (9 in series)
by Martin Wilck April 12, 2002

April 12, 2002

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 April 12, 2002

April 12, 2002

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 April 12, 2002

April 12, 2002

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 April 12, 2002

April 12, 2002

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