wine-devel

wine-devel@winehq.org

2 participants
84469 discussions

Re: Regression tests, UNICODE vs ASCII
by Lina Kemmel 15 Apr '02

15 Apr '02

You can write something like the following: const WCHAR zeroWidthNonJoiner = 0x200C; const WCHAR zeroWidthJoiner = 0x200D; const WCHAR leftToRightMark = 0x200E; const WCHAR rightToLeftMark = 0x200F; const WCHAR leftToRightEmbedding = 0x202A; const WCHAR rightToLeftEmbedding = 0x202B; const WCHAR popDirectionalFormatting = 0x202C; const WCHAR leftToRightOverride = 0x202D; const WCHAR rightToLeftOverride = 0x202E; ( or enum { zeroWidthNonJoiner = 0x200C, zeroWidthJoiner, leftToRightMark, rightToLeftMark, leftToRightEmbedding = 0x202A, rightToLeftEmbedding, popDirectionalFormatting, leftToRightOverride, rightToLeftOverride }; ) const WCHAR test_string[] = {zeroWidthNonJoiner, zeroWidthJoiner, leftToRightMark, ... , rightToLeftOverride}; Lina Francois Gouget <fgouget(a)free.fr> Sent by: wine-devel-admin(a)winehq.com 14/04/02 10:02 م Please respond to Francois Gouget To: Shachar Shemesh <wine-devel(a)sun.consumer.org.il> 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 On Sun, 14 Apr 2002, Shachar Shemesh wrote: > 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. But what would these Unicode characters look like? I.e. what would I write in my code: const WCHAR test_string[]={'???','???','???'}; -- Francois Gouget fgouget(a)free.fr http://fgouget.free.fr/ Broadcast message : fin du monde dans cinq minutes, repentez vous !

1 0

re: 16-bit apps starting and stopping notification
by Joshua Thielen 15 Apr '02

15 Apr '02

> Can somebody give me a hint how is better to approach > implementation of > NFY_EXITTASK, NFY_STARTTASK events generation? Does anyone know what ToolHelpHook does (KERNEL.341)? Could this be used by windows to hook a toolhelp notification function into kernel.dll? > How important do you think is to implement this > functionality, since it is for 16-bit apps only? I still use a 16-bit app for school that uses these functions and that doesn't work in wine. I'm not sure if the app does't work because it needs these notifications or if there is another reason. I attempted to implement this a couple of months ago, but it was an ugly hack since I was calling a toolhelp helper function from kernel.dll (or maybe it was ntdll) in order to send the notification. Regards, Josh Thielen

2 2

Directory reorganization
by Joshua Thielen 14 Apr '02

14 Apr '02

Hello everybody, I have an idea for reorganizing some of the directories in wine. I hope I'm not stating an obvious idea here, but I would like to group everything into the following first level directories: dlls documentation include programs server tools I'm not sure, but maybe the following directories should also be included: libtest miscemu ole The point is to keep all related source files together with their dll directory. This way, if a new hacker is hunting for a bug, it is clear where they should begin to look. Also, it is easier to focus on the code for one dll this way. Here is where I would move things: controls --> dlls/user/controls files --> dlls/ntdll/files graphics --> dlls/gdi/graphics if1632 --> dlls/ntdll/if1632 library --> dlls (and possibly rename to wine?) loader --> dlls/ntdll/loader memory --> dlls/ntdll/memory msdos --> dlls/ntdll/msdos relay32 --> dlls/ntdll/relay32 scheduler --> dlls/ntdll/scheduler win32 --> dlls/ntdll/win32 windows --> dlls/user/windows These are the directories I'm not sure about: miscemu --> programs (possibly rename to wine?) ole --> dlls/ntdll/ole (ole is also used by library, maybe it should go to dlls/library?) tsx11 --> dlls/tsx11 (or maybe we should have a 'drivers' top-level directory?) graphics/tsx11 --> dlls/tsx11/graphics windows/tsx11 --> dlls/tsx11/windows unicode --> dlls/unicode Please let me know what you think. Thanks, Josh Thielen

2 1

Unknown Windows message number
by ccrayne＠crayne.org 14 Apr '02

14 Apr '02

While testing an application which I have (mostly) running under Wine, I consistently see the following message sent sometines to RICHEDIT32_WindowProc and sometimes to TOOLTIPS_WindowProc: msg: 0xc01e wp: 0 lp: 0x40596d60 Any clues as to what this message is would be welcome. -- Chuck Crayne ----------------------------------------------------------- ccrayne(a)crayne.org -----------------------------------------------------------

3 3

Regression tests, UNICODE vs ASCII
by Geoffrey Hausheer 14 Apr '02

14 Apr '02

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 14 Apr '02

14 Apr '02

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 14 Apr '02

14 Apr '02

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 13 Apr '02

13 Apr '02

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 12 Apr '02

12 Apr '02

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 12 Apr '02

12 Apr '02

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 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

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