marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Rename the regular WS_FD_XXX macros to FD_XXX. 

Rename the Wine specific WS_FD_XXX macros to FD_WINE_XXX.
oldstable
Francois Gouget 2001-08-24 19:14:56 +00:00 committed by Alexandre Julliard
parent a0f98f13d9
commit 126e6b8175
3 changed files with 53 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
dlls/winsock/socket.c
View File

@ -252,7 +252,7 @@ static int _is_blocking(SOCKET s)
req->s_event = 0;
req->c_event = 0;
SERVER_CALL();
ret = (req->state & WS_FD_NONBLOCKING) == 0;
ret = (req->state & FD_WINE_NONBLOCKING) == 0;
}
SERVER_END_REQ;
return ret;
@ -743,7 +743,7 @@ static void WSOCK32_async_accept(SOCKET s, SOCKET as)
else
ERR("accept queue too small\n");
/* now signal our AsyncSelect handler */
_enable_event(s, WS_FD_SERVEVENT, 0, 0);
_enable_event(s, FD_WINE_SERVEVENT, 0, 0);
}
/**********************************************************************/
@ -801,7 +801,7 @@ SOCKET WINAPI WSOCK32_accept(SOCKET s, struct sockaddr *addr,
#endif
} else SetLastError(wsaErrno());
close(fd);
if (omask & WS_FD_SERVEVENT)
if (omask & FD_WINE_SERVEVENT)
WSOCK32_async_accept(s, as);
return as;
}
@ -960,8 +960,8 @@ INT WINAPI WSOCK32_connect(SOCKET s, struct sockaddr *name, INT namelen)
{
/* tell wineserver that a connection is in progress */
_enable_event(s, FD_CONNECT|FD_READ|FD_WRITE,
WS_FD_CONNECT|WS_FD_READ|WS_FD_WRITE,
WS_FD_CONNECTED|WS_FD_LISTENING);
FD_CONNECT|FD_READ|FD_WRITE,
FD_WINE_CONNECTED|FD_WINE_LISTENING);
if (_is_blocking(s))
{
int result;
@ -997,8 +997,8 @@ connect_success:
free(name);
#endif
_enable_event(s, FD_CONNECT|FD_READ|FD_WRITE,
WS_FD_CONNECTED|WS_FD_READ|WS_FD_WRITE,
WS_FD_CONNECT|WS_FD_LISTENING);
FD_WINE_CONNECTED|FD_READ|FD_WRITE,
FD_CONNECT|FD_WINE_LISTENING);
return 0;
}
@ -1550,9 +1550,9 @@ INT WINAPI WSOCK32_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
}
close(fd);
if (*argp)
_enable_event(s, 0, WS_FD_NONBLOCKING, 0);
_enable_event(s, 0, FD_WINE_NONBLOCKING, 0);
else
_enable_event(s, 0, 0, WS_FD_NONBLOCKING);
_enable_event(s, 0, 0, FD_WINE_NONBLOCKING);
return 0;
case WS_SIOCATMARK:
@ -1610,8 +1610,8 @@ INT WINAPI WSOCK32_listen(SOCKET s, INT backlog)
{
close(fd);
_enable_event(s, FD_ACCEPT,
WS_FD_LISTENING,
WS_FD_CONNECT|WS_FD_CONNECTED);
FD_WINE_LISTENING,
FD_CONNECT|FD_WINE_CONNECTED);
return 0;
}
SetLastError(wsaErrno());
@ -2096,14 +2096,14 @@ INT WINAPI WSOCK32_shutdown(SOCKET s, INT how)
switch( how )
{
case 0: /* drop receives */
_enable_event(s, 0, 0, WS_FD_READ);
_enable_event(s, 0, 0, FD_READ);
#ifdef SHUT_RD
how = SHUT_RD;
#endif
break;
case 1: /* drop sends */
_enable_event(s, 0, 0, WS_FD_WRITE);
_enable_event(s, 0, 0, FD_WRITE);
#ifdef SHUT_WR
how = SHUT_WR;
#endif
@ -2122,7 +2122,7 @@ INT WINAPI WSOCK32_shutdown(SOCKET s, INT how)
{
if( how > 1 )
{
_enable_event(s, 0, 0, WS_FD_CONNECTED|WS_FD_LISTENING);
_enable_event(s, 0, 0, FD_WINE_CONNECTED|FD_WINE_LISTENING);
}
close(fd);
return 0;
@ -2660,12 +2660,12 @@ VOID CALLBACK WINSOCK_DoAsyncEvent( ULONG_PTR ptr )
if ( (GetLastError() == WSAENOTSOCK) || (GetLastError() == WSAEINVAL) )
{
/* orphaned event (socket closed or something) */
pmask = WS_FD_SERVEVENT;
pmask = FD_WINE_SERVEVENT;
orphan = TRUE;
}
/* check for accepted sockets that needs to inherit WSAAsyncSelect */
if (pmask & WS_FD_SERVEVENT) {
if (pmask & FD_WINE_SERVEVENT) {
int q;
for (q=0; q<WS_ACCEPT_QUEUE; q++)
if (accept_old[q] == info->sock) {
@ -2677,7 +2677,7 @@ VOID CALLBACK WINSOCK_DoAsyncEvent( ULONG_PTR ptr )
WSAAsyncSelect(as, info->hWnd, info->uMsg, info->lEvent);
}
}
pmask &= ~WS_FD_SERVEVENT;
pmask &= ~FD_WINE_SERVEVENT;
}
/* dispatch network events */
for (i=0; i<FD_MAX_EVENTS; i++)
@ -2723,7 +2723,7 @@ INT WINAPI WSAAsyncSelect(SOCKET s, HWND hWnd, UINT uMsg, LONG lEvent)
info->lEvent = lEvent;
info->service = SERVICE_AddObject( hObj, WINSOCK_DoAsyncEvent, (ULONG_PTR)info );
err = WSAEventSelect( s, hObj, lEvent | WS_FD_SERVEVENT );
err = WSAEventSelect( s, hObj, lEvent | FD_WINE_SERVEVENT );
if (err) {
/* SERVICE_Delete closes the event object */
SERVICE_Delete( info->service );

33
include/winsock.h
View File

@ -264,25 +264,22 @@ typedef struct WSAData {
/*
* Define flags to be used with the WSAAsyncSelect() call.
*/
#define FD_READ WS_FD_READ
#define FD_WRITE WS_FD_WRITE
#define FD_OOB WS_FD_OOB
#define FD_ACCEPT WS_FD_ACCEPT
#define FD_CONNECT WS_FD_CONNECT
#define FD_CLOSE WS_FD_CLOSE
#define WS_FD_READ 0x0001
#define WS_FD_WRITE 0x0002
#define WS_FD_OOB 0x0004
#define WS_FD_ACCEPT 0x0008
#define WS_FD_CONNECT 0x0010
#define WS_FD_CLOSE 0x0020
#define FD_READ 0x00000001
#define FD_WRITE 0x00000002
#define FD_OOB 0x00000004
#define FD_ACCEPT 0x00000008
#define FD_CONNECT 0x00000010
#define FD_CLOSE 0x00000020
#define WS_FD_LISTENING 0x10000000 /* internal per-socket flags */
#define WS_FD_NONBLOCKING 0x20000000
#define WS_FD_CONNECTED 0x40000000
#define WS_FD_RAW 0x80000000
#define WS_FD_SERVEVENT 0x01000000
#define WS_FD_INTERNAL 0xFFFF0000
/* internal per-socket flags */
#ifdef __WINE__
#define FD_WINE_LISTENING 0x10000000
#define FD_WINE_NONBLOCKING 0x20000000
#define FD_WINE_CONNECTED 0x40000000
#define FD_WINE_RAW 0x80000000
#define FD_WINE_SERVEVENT 0x01000000
#define FD_WINE_INTERNAL 0xFFFF0000
#endif
/*
* All Windows Sockets error constants are biased by WSABASEERR from

40
server/sock.c
View File

@ -84,7 +84,7 @@ static void sock_reselect( struct sock *sock )
if (sock->obj.select == -1) {
/* previously unconnected socket, is this reselect supposed to connect it? */
if (!(sock->state & ~WS_FD_NONBLOCKING)) return;
if (!(sock->state & ~FD_WINE_NONBLOCKING)) return;
/* ok, it is, attach it to the wineserver's main poll loop */
add_select_user( &sock->obj );
}
@ -116,14 +116,14 @@ static void sock_poll_event( struct object *obj, int event )
assert( sock->obj.ops == &sock_ops );
if (debug_level)
fprintf(stderr, "socket %d select event: %x\n", sock->obj.fd, event);
if (sock->state & WS_FD_CONNECT)
if (sock->state & FD_CONNECT)
{
/* connecting */
if (event & POLLOUT)
{
/* we got connected */
sock->state |= WS_FD_CONNECTED|WS_FD_READ|WS_FD_WRITE;
sock->state &= ~WS_FD_CONNECT;
sock->state |= FD_WINE_CONNECTED|FD_READ|FD_WRITE;
sock->state &= ~FD_CONNECT;
sock->pmask |= FD_CONNECT;
sock->errors[FD_CONNECT_BIT] = 0;
if (debug_level)
@ -132,14 +132,14 @@ static void sock_poll_event( struct object *obj, int event )
else if (event & (POLLERR|POLLHUP))
{
/* we didn't get connected? */
sock->state &= ~WS_FD_CONNECT;
sock->state &= ~FD_CONNECT;
sock->pmask |= FD_CONNECT;
sock->errors[FD_CONNECT_BIT] = sock_error( sock->obj.fd );
if (debug_level)
fprintf(stderr, "socket %d connection failure\n", sock->obj.fd);
}
} else
if (sock->state & WS_FD_LISTENING)
if (sock->state & FD_WINE_LISTENING)
{
/* listening */
if (event & POLLIN)
@ -193,10 +193,10 @@ static void sock_poll_event( struct object *obj, int event )
fprintf(stderr, "socket %d got OOB data\n", sock->obj.fd);
}
if (((event & POLLERR) || ((event & (POLLIN|POLLHUP)) == POLLHUP))
&& (sock->state & (WS_FD_READ|WS_FD_WRITE))) {
&& (sock->state & (FD_READ|FD_WRITE))) {
/* socket closing */
sock->errors[FD_CLOSE_BIT] = sock_error( sock->obj.fd );
sock->state &= ~(WS_FD_CONNECTED|WS_FD_READ|WS_FD_WRITE);
sock->state &= ~(FD_WINE_CONNECTED|FD_READ|FD_WRITE);
sock->pmask |= FD_CLOSE;
if (debug_level)
fprintf(stderr, "socket %d aborted by error %d\n",
@ -247,10 +247,10 @@ static int sock_get_poll_events( struct object *obj )
assert( obj->ops == &sock_ops );
if (sock->state & WS_FD_CONNECT)
if (sock->state & FD_CONNECT)
/* connecting, wait for writable */
return POLLOUT;
if (sock->state & WS_FD_LISTENING)
if (sock->state & FD_WINE_LISTENING)
/* listening, wait for readable */
return (sock->hmask & FD_ACCEPT) ? 0 : POLLIN;
@ -277,7 +277,7 @@ static void sock_destroy( struct object *obj )
/* if the service thread was waiting for the event object,
* we should now signal it, to let the service thread
* object detect that it is now orphaned... */
if (sock->mask & WS_FD_SERVEVENT)
if (sock->mask & FD_WINE_SERVEVENT)
set_event( sock->event );
/* we're through with it */
release_object( sock->event );
@ -300,7 +300,7 @@ static struct object *create_socket( int family, int type, int protocol )
fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
if (!(sock = alloc_object( &sock_ops, -1 ))) return NULL;
sock->obj.fd = sockfd;
sock->state = (type != SOCK_STREAM) ? (WS_FD_READ|WS_FD_WRITE) : 0;
sock->state = (type != SOCK_STREAM) ? (FD_READ|FD_WRITE) : 0;
sock->mask = 0;
sock->hmask = 0;
sock->pmask = 0;
@ -343,14 +343,14 @@ static struct object *accept_socket( handle_t handle )
/* newly created socket gets the same properties of the listening socket */
fcntl(acceptfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
acceptsock->obj.fd = acceptfd;
acceptsock->state = WS_FD_CONNECTED|WS_FD_READ|WS_FD_WRITE;
if (sock->state & WS_FD_NONBLOCKING)
acceptsock->state |= WS_FD_NONBLOCKING;
acceptsock->state = FD_WINE_CONNECTED|FD_READ|FD_WRITE;
if (sock->state & FD_WINE_NONBLOCKING)
acceptsock->state |= FD_WINE_NONBLOCKING;
acceptsock->mask = sock->mask;
acceptsock->hmask = 0;
acceptsock->pmask = 0;
acceptsock->event = NULL;
if (sock->event && !(sock->mask & WS_FD_SERVEVENT))
if (sock->event && !(sock->mask & FD_WINE_SERVEVENT))
acceptsock->event = (struct event *)grab_object( sock->event );
sock_reselect( acceptsock );
@ -475,7 +475,7 @@ DECL_HANDLER(set_socket_event)
if (debug_level && sock->event) fprintf(stderr, "event ptr: %p\n", sock->event);
sock_reselect( sock );
if (sock->mask)
sock->state |= WS_FD_NONBLOCKING;
sock->state |= FD_WINE_NONBLOCKING;
/* if a network event is pending, signal the event object
it is possible that FD_CONNECT or FD_ACCEPT network events has happened
@ -486,7 +486,7 @@ DECL_HANDLER(set_socket_event)
if (oevent)
{
if ((oevent != sock->event) && (omask & WS_FD_SERVEVENT))
if ((oevent != sock->event) && (omask & FD_WINE_SERVEVENT))
/* if the service thread was waiting for the old event object,
* we should now signal it, to let the service thread
* object detect that it is now orphaned... */
@ -559,9 +559,9 @@ DECL_HANDLER(enable_socket_event)
sock_reselect( sock );
/* service trigger */
if (req->mask & WS_FD_SERVEVENT)
if (req->mask & FD_WINE_SERVEVENT)
{
sock->pmask |= WS_FD_SERVEVENT;
sock->pmask |= FD_WINE_SERVEVENT;
if (sock->event) {
if (debug_level) fprintf(stderr, "signalling service event ptr %p\n", sock->event);
set_event(sock->event);