ReceiveTempSMS
/
Sweden-Number
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.
This commit is contained in:
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->s_event = 0;
req->c_event = 0; req->c_event = 0;
SERVER_CALL(); SERVER_CALL();
ret = (req->state & WS_FD_NONBLOCKING) == 0; ret = (req->state & FD_WINE_NONBLOCKING) == 0;
} }
SERVER_END_REQ; SERVER_END_REQ;
return ret; return ret;
@ -743,7 +743,7 @@ static void WSOCK32_async_accept(SOCKET s, SOCKET as)
else else
ERR("accept queue too small\n"); ERR("accept queue too small\n");
/* now signal our AsyncSelect handler */ /* 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 #endif
} else SetLastError(wsaErrno()); } else SetLastError(wsaErrno());
close(fd); close(fd);
if (omask & WS_FD_SERVEVENT) if (omask & FD_WINE_SERVEVENT)
WSOCK32_async_accept(s, as); WSOCK32_async_accept(s, as);
return 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 */ /* tell wineserver that a connection is in progress */
_enable_event(s, FD_CONNECT|FD_READ|FD_WRITE, _enable_event(s, FD_CONNECT|FD_READ|FD_WRITE,
WS_FD_CONNECT|WS_FD_READ|WS_FD_WRITE, FD_CONNECT|FD_READ|FD_WRITE,
WS_FD_CONNECTED|WS_FD_LISTENING); FD_WINE_CONNECTED|FD_WINE_LISTENING);
if (_is_blocking(s)) if (_is_blocking(s))
{ {
int result; int result;
@ -997,8 +997,8 @@ connect_success:
free(name); free(name);
#endif #endif
_enable_event(s, FD_CONNECT|FD_READ|FD_WRITE, _enable_event(s, FD_CONNECT|FD_READ|FD_WRITE,
WS_FD_CONNECTED|WS_FD_READ|WS_FD_WRITE, FD_WINE_CONNECTED|FD_READ|FD_WRITE,
WS_FD_CONNECT|WS_FD_LISTENING); FD_CONNECT|FD_WINE_LISTENING);
return 0; return 0;
} }
@ -1550,9 +1550,9 @@ INT WINAPI WSOCK32_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
} }
close(fd); close(fd);
if (*argp) if (*argp)
_enable_event(s, 0, WS_FD_NONBLOCKING, 0); _enable_event(s, 0, FD_WINE_NONBLOCKING, 0);
else else
_enable_event(s, 0, 0, WS_FD_NONBLOCKING); _enable_event(s, 0, 0, FD_WINE_NONBLOCKING);
return 0; return 0;
case WS_SIOCATMARK: case WS_SIOCATMARK:
@ -1610,8 +1610,8 @@ INT WINAPI WSOCK32_listen(SOCKET s, INT backlog)
{ {
close(fd); close(fd);
_enable_event(s, FD_ACCEPT, _enable_event(s, FD_ACCEPT,
WS_FD_LISTENING, FD_WINE_LISTENING,
WS_FD_CONNECT|WS_FD_CONNECTED); FD_CONNECT|FD_WINE_CONNECTED);
return 0; return 0;
} }
SetLastError(wsaErrno()); SetLastError(wsaErrno());
@ -2096,14 +2096,14 @@ INT WINAPI WSOCK32_shutdown(SOCKET s, INT how)
switch( how ) switch( how )
{ {
case 0: /* drop receives */ case 0: /* drop receives */
_enable_event(s, 0, 0, WS_FD_READ); _enable_event(s, 0, 0, FD_READ);
#ifdef SHUT_RD #ifdef SHUT_RD
how = SHUT_RD; how = SHUT_RD;
#endif #endif
break; break;
case 1: /* drop sends */ case 1: /* drop sends */
_enable_event(s, 0, 0, WS_FD_WRITE); _enable_event(s, 0, 0, FD_WRITE);
#ifdef SHUT_WR #ifdef SHUT_WR
how = SHUT_WR; how = SHUT_WR;
#endif #endif
@ -2122,7 +2122,7 @@ INT WINAPI WSOCK32_shutdown(SOCKET s, INT how)
{ {
if( how > 1 ) 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); close(fd);
return 0; return 0;
@ -2660,12 +2660,12 @@ VOID CALLBACK WINSOCK_DoAsyncEvent( ULONG_PTR ptr )
if ( (GetLastError() == WSAENOTSOCK) || (GetLastError() == WSAEINVAL) ) if ( (GetLastError() == WSAENOTSOCK) || (GetLastError() == WSAEINVAL) )
{ {
/* orphaned event (socket closed or something) */ /* orphaned event (socket closed or something) */
pmask = WS_FD_SERVEVENT; pmask = FD_WINE_SERVEVENT;
orphan = TRUE; orphan = TRUE;
} }
/* check for accepted sockets that needs to inherit WSAAsyncSelect */ /* check for accepted sockets that needs to inherit WSAAsyncSelect */
if (pmask & WS_FD_SERVEVENT) { if (pmask & FD_WINE_SERVEVENT) {
int q; int q;
for (q=0; q<WS_ACCEPT_QUEUE; q++) for (q=0; q<WS_ACCEPT_QUEUE; q++)
if (accept_old[q] == info->sock) { 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); WSAAsyncSelect(as, info->hWnd, info->uMsg, info->lEvent);
} }
} }
pmask &= ~WS_FD_SERVEVENT; pmask &= ~FD_WINE_SERVEVENT;
} }
/* dispatch network events */ /* dispatch network events */
for (i=0; i<FD_MAX_EVENTS; i++) 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->lEvent = lEvent;
info->service = SERVICE_AddObject( hObj, WINSOCK_DoAsyncEvent, (ULONG_PTR)info ); 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) { if (err) {
/* SERVICE_Delete closes the event object */ /* SERVICE_Delete closes the event object */
SERVICE_Delete( info->service ); 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 flags to be used with the WSAAsyncSelect() call.
*/ */
#define FD_READ WS_FD_READ #define FD_READ 0x00000001
#define FD_WRITE WS_FD_WRITE #define FD_WRITE 0x00000002
#define FD_OOB WS_FD_OOB #define FD_OOB 0x00000004
#define FD_ACCEPT WS_FD_ACCEPT #define FD_ACCEPT 0x00000008
#define FD_CONNECT WS_FD_CONNECT #define FD_CONNECT 0x00000010
#define FD_CLOSE WS_FD_CLOSE #define FD_CLOSE 0x00000020
#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 WS_FD_LISTENING 0x10000000 /* internal per-socket flags */ /* internal per-socket flags */
#define WS_FD_NONBLOCKING 0x20000000 #ifdef __WINE__
#define WS_FD_CONNECTED 0x40000000 #define FD_WINE_LISTENING 0x10000000
#define WS_FD_RAW 0x80000000 #define FD_WINE_NONBLOCKING 0x20000000
#define WS_FD_SERVEVENT 0x01000000 #define FD_WINE_CONNECTED 0x40000000
#define WS_FD_INTERNAL 0xFFFF0000 #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 * 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) { if (sock->obj.select == -1) {
/* previously unconnected socket, is this reselect supposed to connect it? */ /* 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 */ /* ok, it is, attach it to the wineserver's main poll loop */
add_select_user( &sock->obj ); 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 ); assert( sock->obj.ops == &sock_ops );
if (debug_level) if (debug_level)
fprintf(stderr, "socket %d select event: %x\n", sock->obj.fd, event); fprintf(stderr, "socket %d select event: %x\n", sock->obj.fd, event);
if (sock->state & WS_FD_CONNECT) if (sock->state & FD_CONNECT)
{ {
/* connecting */ /* connecting */
if (event & POLLOUT) if (event & POLLOUT)
{ {
/* we got connected */ /* we got connected */
sock->state |= WS_FD_CONNECTED|WS_FD_READ|WS_FD_WRITE; sock->state |= FD_WINE_CONNECTED|FD_READ|FD_WRITE;
sock->state &= ~WS_FD_CONNECT; sock->state &= ~FD_CONNECT;
sock->pmask |= FD_CONNECT; sock->pmask |= FD_CONNECT;
sock->errors[FD_CONNECT_BIT] = 0; sock->errors[FD_CONNECT_BIT] = 0;
if (debug_level) if (debug_level)
@ -132,14 +132,14 @@ static void sock_poll_event( struct object *obj, int event )
else if (event & (POLLERR|POLLHUP)) else if (event & (POLLERR|POLLHUP))
{ {
/* we didn't get connected? */ /* we didn't get connected? */
sock->state &= ~WS_FD_CONNECT; sock->state &= ~FD_CONNECT;
sock->pmask |= FD_CONNECT; sock->pmask |= FD_CONNECT;
sock->errors[FD_CONNECT_BIT] = sock_error( sock->obj.fd ); sock->errors[FD_CONNECT_BIT] = sock_error( sock->obj.fd );
if (debug_level) if (debug_level)
fprintf(stderr, "socket %d connection failure\n", sock->obj.fd); fprintf(stderr, "socket %d connection failure\n", sock->obj.fd);
} }
} else } else
if (sock->state & WS_FD_LISTENING) if (sock->state & FD_WINE_LISTENING)
{ {
/* listening */ /* listening */
if (event & POLLIN) 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); fprintf(stderr, "socket %d got OOB data\n", sock->obj.fd);
} }
if (((event & POLLERR) || ((event & (POLLIN|POLLHUP)) == POLLHUP)) if (((event & POLLERR) || ((event & (POLLIN|POLLHUP)) == POLLHUP))
&& (sock->state & (WS_FD_READ|WS_FD_WRITE))) { && (sock->state & (FD_READ|FD_WRITE))) {
/* socket closing */ /* socket closing */
sock->errors[FD_CLOSE_BIT] = sock_error( sock->obj.fd ); 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; sock->pmask |= FD_CLOSE;
if (debug_level) if (debug_level)
fprintf(stderr, "socket %d aborted by error %d\n", 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 ); assert( obj->ops == &sock_ops );
if (sock->state & WS_FD_CONNECT) if (sock->state & FD_CONNECT)
/* connecting, wait for writable */ /* connecting, wait for writable */
return POLLOUT; return POLLOUT;
if (sock->state & WS_FD_LISTENING) if (sock->state & FD_WINE_LISTENING)
/* listening, wait for readable */ /* listening, wait for readable */
return (sock->hmask & FD_ACCEPT) ? 0 : POLLIN; 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, /* if the service thread was waiting for the event object,
* we should now signal it, to let the service thread * we should now signal it, to let the service thread
* object detect that it is now orphaned... */ * object detect that it is now orphaned... */
if (sock->mask & WS_FD_SERVEVENT) if (sock->mask & FD_WINE_SERVEVENT)
set_event( sock->event ); set_event( sock->event );
/* we're through with it */ /* we're through with it */
release_object( sock->event ); 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 */ fcntl(sockfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
if (!(sock = alloc_object( &sock_ops, -1 ))) return NULL; if (!(sock = alloc_object( &sock_ops, -1 ))) return NULL;
sock->obj.fd = sockfd; 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->mask = 0;
sock->hmask = 0; sock->hmask = 0;
sock->pmask = 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 */ /* newly created socket gets the same properties of the listening socket */
fcntl(acceptfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */ fcntl(acceptfd, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
acceptsock->obj.fd = acceptfd; acceptsock->obj.fd = acceptfd;
acceptsock->state = WS_FD_CONNECTED|WS_FD_READ|WS_FD_WRITE; acceptsock->state = FD_WINE_CONNECTED|FD_READ|FD_WRITE;
if (sock->state & WS_FD_NONBLOCKING) if (sock->state & FD_WINE_NONBLOCKING)
acceptsock->state |= WS_FD_NONBLOCKING; acceptsock->state |= FD_WINE_NONBLOCKING;
acceptsock->mask = sock->mask; acceptsock->mask = sock->mask;
acceptsock->hmask = 0; acceptsock->hmask = 0;
acceptsock->pmask = 0; acceptsock->pmask = 0;
acceptsock->event = NULL; 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 ); acceptsock->event = (struct event *)grab_object( sock->event );
sock_reselect( acceptsock ); 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); if (debug_level && sock->event) fprintf(stderr, "event ptr: %p\n", sock->event);
sock_reselect( sock ); sock_reselect( sock );
if (sock->mask) if (sock->mask)
sock->state |= WS_FD_NONBLOCKING; sock->state |= FD_WINE_NONBLOCKING;
/* if a network event is pending, signal the event object /* if a network event is pending, signal the event object
it is possible that FD_CONNECT or FD_ACCEPT network events has happened 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)
{ {
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, /* if the service thread was waiting for the old event object,
* we should now signal it, to let the service thread * we should now signal it, to let the service thread
* object detect that it is now orphaned... */ * object detect that it is now orphaned... */
@ -559,9 +559,9 @@ DECL_HANDLER(enable_socket_event)
sock_reselect( sock ); sock_reselect( sock );
/* service trigger */ /* 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 (sock->event) {
if (debug_level) fprintf(stderr, "signalling service event ptr %p\n", sock->event); if (debug_level) fprintf(stderr, "signalling service event ptr %p\n", sock->event);
set_event(sock->event); set_event(sock->event);