Signed-off-by: Zebediah Figura zfigura@codeweavers.com --- dlls/ws2_32/protocol.c | 16 +++++++++------- dlls/ws2_32/unixlib.c | 10 ++++++++++ dlls/ws2_32/ws2_32_private.h | 1 + 3 files changed, 20 insertions(+), 7 deletions(-)
diff --git a/dlls/ws2_32/protocol.c b/dlls/ws2_32/protocol.c index c65e6b9674e..48e7e062d7f 100644 --- a/dlls/ws2_32/protocol.c +++ b/dlls/ws2_32/protocol.c @@ -913,6 +913,7 @@ struct WS_hostent * WINAPI WS_gethostbyname( const char *name ) { struct WS_hostent *host = NULL; char hostname[100]; + int ret;
TRACE( "%s\n", debugstr_a(name) );
@@ -922,9 +923,9 @@ struct WS_hostent * WINAPI WS_gethostbyname( const char *name ) return NULL; }
- if (gethostname( hostname, 100 ) == -1) + if ((ret = unix_funcs->gethostname( hostname, 100 ))) { - SetLastError( WSAENOBUFS ); + SetLastError( ret ); return NULL; }
@@ -973,7 +974,7 @@ struct WS_hostent * WINAPI WS_gethostbyname( const char *name ) int WINAPI WS_gethostname( char *name, int namelen ) { char buf[256]; - int len; + int len, ret;
TRACE( "name %p, len %d\n", name, namelen );
@@ -983,9 +984,9 @@ int WINAPI WS_gethostname( char *name, int namelen ) return -1; }
- if (gethostname( buf, sizeof(buf) ) != 0) + if ((ret = unix_funcs->gethostname( buf, sizeof(buf) ))) { - SetLastError( sock_get_error( errno ) ); + SetLastError( ret ); return -1; }
@@ -1009,6 +1010,7 @@ int WINAPI WS_gethostname( char *name, int namelen ) int WINAPI GetHostNameW( WCHAR *name, int namelen ) { char buf[256]; + int ret;
TRACE( "name %p, len %d\n", name, namelen );
@@ -1018,9 +1020,9 @@ int WINAPI GetHostNameW( WCHAR *name, int namelen ) return -1; }
- if (gethostname( buf, sizeof(buf) )) + if ((ret = unix_funcs->gethostname( buf, sizeof(buf) ))) { - SetLastError( sock_get_error( errno ) ); + SetLastError( ret ); return -1; }
diff --git a/dlls/ws2_32/unixlib.c b/dlls/ws2_32/unixlib.c index 2a5fcd1b60d..cde73198c16 100644 --- a/dlls/ws2_32/unixlib.c +++ b/dlls/ws2_32/unixlib.c @@ -30,6 +30,7 @@ #include <errno.h> #include <pthread.h> #include <stdarg.h> +#include <unistd.h> #include <sys/types.h> #ifdef HAVE_SYS_SOCKET_H # include <sys/socket.h> @@ -789,11 +790,20 @@ static int CDECL unix_gethostbyname( const char *name, struct WS_hostent *const #endif
+static int CDECL unix_gethostname( char *name, int len ) +{ + if (!gethostname( name, len )) + return 0; + return errno_from_unix( errno ); +} + + static const struct unix_funcs funcs = { unix_getaddrinfo, unix_gethostbyaddr, unix_gethostbyname, + unix_gethostname, };
NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out ) diff --git a/dlls/ws2_32/ws2_32_private.h b/dlls/ws2_32/ws2_32_private.h index 38454e1a9ba..973f24a10a9 100644 --- a/dlls/ws2_32/ws2_32_private.h +++ b/dlls/ws2_32/ws2_32_private.h @@ -203,6 +203,7 @@ struct unix_funcs int (CDECL *gethostbyaddr)( const void *addr, int len, int family, struct WS(hostent) *host, unsigned int *size ); int (CDECL *gethostbyname)( const char *name, struct WS(hostent) *host, unsigned int *size ); + int (CDECL *gethostname)( char *name, int len ); };
extern const struct unix_funcs *unix_funcs;
Signed-off-by: Zebediah Figura zfigura@codeweavers.com --- dlls/ws2_32/protocol.c | 89 +-------------- dlls/ws2_32/socket.c | 205 ----------------------------------- dlls/ws2_32/unixlib.c | 139 ++++++++++++++++++++++++ dlls/ws2_32/ws2_32_private.h | 14 +-- 4 files changed, 142 insertions(+), 305 deletions(-)
diff --git a/dlls/ws2_32/protocol.c b/dlls/ws2_32/protocol.c index 48e7e062d7f..8b39d5c3274 100644 --- a/dlls/ws2_32/protocol.c +++ b/dlls/ws2_32/protocol.c @@ -31,49 +31,6 @@ WINE_DECLARE_DEBUG_CHANNEL(winediag);
DECLARE_CRITICAL_SECTION(csWSgetXXXbyYYY);
-#define MAP_OPTION(opt) { WS_##opt, opt } - -static const int ws_eai_map[][2] = -{ - MAP_OPTION( EAI_AGAIN ), - MAP_OPTION( EAI_BADFLAGS ), - MAP_OPTION( EAI_FAIL ), - MAP_OPTION( EAI_FAMILY ), - MAP_OPTION( EAI_MEMORY ), -/* Note: EAI_NODATA is deprecated, but still used by Windows and Linux. We map - * the newer EAI_NONAME to EAI_NODATA for now until Windows changes too. */ -#ifdef EAI_NODATA - MAP_OPTION( EAI_NODATA ), -#endif -#ifdef EAI_NONAME - { WS_EAI_NODATA, EAI_NONAME }, -#endif - MAP_OPTION( EAI_SERVICE ), - MAP_OPTION( EAI_SOCKTYPE ), - { 0, 0 } -}; - -int convert_eai_u2w( int unixret ) -{ - int i; - - if (!unixret) return 0; - - for (i = 0; ws_eai_map[i][0]; i++) - { - if (ws_eai_map[i][1] == unixret) - return ws_eai_map[i][0]; - } - - if (unixret == EAI_SYSTEM) - /* There are broken versions of glibc which return EAI_SYSTEM - * and set errno to 0 instead of returning EAI_NONAME. */ - return errno ? sock_get_error( errno ) : WS_EAI_NONAME; - - FIXME("Unhandled unix EAI_xxx ret %d\n", unixret); - return unixret; -} - static char *get_fqdn(void) { char *ret; @@ -592,60 +549,16 @@ void WINAPI FreeAddrInfoExW( ADDRINFOEXW *ai ) }
-static const int ws_niflag_map[][2] = -{ - MAP_OPTION( NI_NOFQDN ), - MAP_OPTION( NI_NUMERICHOST ), - MAP_OPTION( NI_NAMEREQD ), - MAP_OPTION( NI_NUMERICSERV ), - MAP_OPTION( NI_DGRAM ), -}; - -static int convert_niflag_w2u( int winflags ) -{ - unsigned int i; - int unixflags = 0; - - for (i = 0; i < ARRAY_SIZE(ws_niflag_map); i++) - { - if (ws_niflag_map[i][0] & winflags) - { - unixflags |= ws_niflag_map[i][1]; - winflags &= ~ws_niflag_map[i][0]; - } - } - if (winflags) - FIXME("Unhandled windows NI_xxx flags 0x%x\n", winflags); - return unixflags; -} - - /*********************************************************************** * getnameinfo (ws2_32.@) */ int WINAPI WS_getnameinfo( const SOCKADDR *addr, WS_socklen_t addr_len, char *host, DWORD host_len, char *serv, DWORD serv_len, int flags ) { -#ifdef HAVE_GETNAMEINFO - int ret; - union generic_unix_sockaddr uaddr; - unsigned int uaddr_len; - TRACE( "addr %s, addr_len %d, host %p, host_len %u, serv %p, serv_len %d, flags %#x\n", debugstr_sockaddr(addr), addr_len, host, host_len, serv, serv_len, flags );
- uaddr_len = ws_sockaddr_ws2u( addr, addr_len, &uaddr ); - if (!uaddr_len) - { - SetLastError( WSAEFAULT ); - return WSA_NOT_ENOUGH_MEMORY; - } - ret = getnameinfo( &uaddr.addr, uaddr_len, host, host_len, serv, serv_len, convert_niflag_w2u(flags) ); - return convert_eai_u2w( ret ); -#else - FIXME( "getnameinfo() failed, not found during buildtime.\n" ); - return EAI_FAIL; -#endif + return unix_funcs->getnameinfo( addr, addr_len, host, host_len, serv, serv_len, flags ); }
diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c index b7c1571b8b6..ca95a1e0321 100644 --- a/dlls/ws2_32/socket.c +++ b/dlls/ws2_32/socket.c @@ -31,11 +31,6 @@
#include "ws2_32_private.h"
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) -# define sipx_network sipx_addr.x_net -# define sipx_node sipx_addr.x_host.c_host -#endif /* __FreeBSD__ */ - #define FILE_USE_FILE_POINTER_POSITION ((LONGLONG)-2)
WINE_DEFAULT_DEBUG_CHANNEL(winsock); @@ -428,76 +423,6 @@ static FARPROC blocking_hook = (FARPROC)WSA_DefaultBlockingHook; /* function prototypes */ static int ws_protocol_info(SOCKET s, int unicode, WSAPROTOCOL_INFOW *buffer, int *size);
-#define MAP_OPTION(opt) { WS_##opt, opt } - -UINT sock_get_error( int err ) -{ - switch(err) - { - case EINTR: return WSAEINTR; - case EPERM: - case EACCES: return WSAEACCES; - case EFAULT: return WSAEFAULT; - case EINVAL: return WSAEINVAL; - case EMFILE: return WSAEMFILE; - case EINPROGRESS: - case EWOULDBLOCK: return WSAEWOULDBLOCK; - case EALREADY: return WSAEALREADY; - case EBADF: - case ENOTSOCK: return WSAENOTSOCK; - case EDESTADDRREQ: return WSAEDESTADDRREQ; - case EMSGSIZE: return WSAEMSGSIZE; - case EPROTOTYPE: return WSAEPROTOTYPE; - case ENOPROTOOPT: return WSAENOPROTOOPT; - case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT; - case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT; - case EOPNOTSUPP: return WSAEOPNOTSUPP; - case EPFNOSUPPORT: return WSAEPFNOSUPPORT; - case EAFNOSUPPORT: return WSAEAFNOSUPPORT; - case EADDRINUSE: return WSAEADDRINUSE; - case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL; - case ENETDOWN: return WSAENETDOWN; - case ENETUNREACH: return WSAENETUNREACH; - case ENETRESET: return WSAENETRESET; - case ECONNABORTED: return WSAECONNABORTED; - case EPIPE: - case ECONNRESET: return WSAECONNRESET; - case ENOBUFS: return WSAENOBUFS; - case EISCONN: return WSAEISCONN; - case ENOTCONN: return WSAENOTCONN; - case ESHUTDOWN: return WSAESHUTDOWN; - case ETOOMANYREFS: return WSAETOOMANYREFS; - case ETIMEDOUT: return WSAETIMEDOUT; - case ECONNREFUSED: return WSAECONNREFUSED; - case ELOOP: return WSAELOOP; - case ENAMETOOLONG: return WSAENAMETOOLONG; - case EHOSTDOWN: return WSAEHOSTDOWN; - case EHOSTUNREACH: return WSAEHOSTUNREACH; - case ENOTEMPTY: return WSAENOTEMPTY; -#ifdef EPROCLIM - case EPROCLIM: return WSAEPROCLIM; -#endif -#ifdef EUSERS - case EUSERS: return WSAEUSERS; -#endif -#ifdef EDQUOT - case EDQUOT: return WSAEDQUOT; -#endif -#ifdef ESTALE - case ESTALE: return WSAESTALE; -#endif -#ifdef EREMOTE - case EREMOTE: return WSAEREMOTE; -#endif - - /* just in case we ever get here and there are no problems */ - case 0: return 0; - default: - WARN("Unknown errno %d!\n", err); - return WSAEOPNOTSUPP; - } -} - static DWORD NtStatusToWSAError( NTSTATUS status ) { static const struct @@ -705,136 +630,6 @@ void WINAPI WSASetLastError(INT iError) { SetLastError(iError); }
-/**********************************************************************/ - -/* Returns the length of the converted address if successful, 0 if it was too - * small to start with or unknown family or invalid address buffer. - */ -unsigned int ws_sockaddr_ws2u( const struct WS_sockaddr *wsaddr, int wsaddrlen, - union generic_unix_sockaddr *uaddr ) -{ - unsigned int uaddrlen = 0; - - if (!wsaddr) - return 0; - - switch (wsaddr->sa_family) - { -#ifdef HAS_IPX - case WS_AF_IPX: - { - const struct WS_sockaddr_ipx* wsipx=(const struct WS_sockaddr_ipx*)wsaddr; - struct sockaddr_ipx* uipx = (struct sockaddr_ipx *)uaddr; - - if (wsaddrlen<sizeof(struct WS_sockaddr_ipx)) - return 0; - - uaddrlen = sizeof(struct sockaddr_ipx); - memset( uaddr, 0, uaddrlen ); - uipx->sipx_family=AF_IPX; - uipx->sipx_port=wsipx->sa_socket; - /* copy sa_netnum and sa_nodenum to sipx_network and sipx_node - * in one go - */ - memcpy(&uipx->sipx_network,wsipx->sa_netnum,sizeof(uipx->sipx_network)+sizeof(uipx->sipx_node)); -#ifdef IPX_FRAME_NONE - uipx->sipx_type=IPX_FRAME_NONE; -#endif - break; - } -#endif - case WS_AF_INET6: { - struct sockaddr_in6* uin6 = (struct sockaddr_in6 *)uaddr; - const struct WS_sockaddr_in6* win6 = (const struct WS_sockaddr_in6*)wsaddr; - - /* Note: Windows has 2 versions of the sockaddr_in6 struct, one with - * scope_id, one without. - */ - if (wsaddrlen >= sizeof(struct WS_sockaddr_in6)) { - uaddrlen = sizeof(struct sockaddr_in6); - memset( uaddr, 0, uaddrlen ); - uin6->sin6_family = AF_INET6; - uin6->sin6_port = win6->sin6_port; - uin6->sin6_flowinfo = win6->sin6_flowinfo; -#ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID - uin6->sin6_scope_id = win6->sin6_scope_id; -#endif - memcpy(&uin6->sin6_addr,&win6->sin6_addr,16); /* 16 bytes = 128 address bits */ - break; - } - FIXME("bad size %d for WS_sockaddr_in6\n",wsaddrlen); - return 0; - } - case WS_AF_INET: { - struct sockaddr_in* uin = (struct sockaddr_in *)uaddr; - const struct WS_sockaddr_in* win = (const struct WS_sockaddr_in*)wsaddr; - - if (wsaddrlen<sizeof(struct WS_sockaddr_in)) - return 0; - uaddrlen = sizeof(struct sockaddr_in); - memset( uaddr, 0, uaddrlen ); - uin->sin_family = AF_INET; - uin->sin_port = win->sin_port; - memcpy(&uin->sin_addr,&win->sin_addr,4); /* 4 bytes = 32 address bits */ - break; - } -#ifdef HAS_IRDA - case WS_AF_IRDA: { - struct sockaddr_irda *uin = (struct sockaddr_irda *)uaddr; - const SOCKADDR_IRDA *win = (const SOCKADDR_IRDA *)wsaddr; - - if (wsaddrlen < sizeof(SOCKADDR_IRDA)) - return 0; - uaddrlen = sizeof(struct sockaddr_irda); - memset( uaddr, 0, uaddrlen ); - uin->sir_family = AF_IRDA; - if (!strncmp( win->irdaServiceName, "LSAP-SEL", strlen( "LSAP-SEL" ) )) - { - unsigned int lsap_sel = 0; - - sscanf( win->irdaServiceName, "LSAP-SEL%u", &lsap_sel ); - uin->sir_lsap_sel = lsap_sel; - } - else - { - uin->sir_lsap_sel = LSAP_ANY; - memcpy( uin->sir_name, win->irdaServiceName, 25 ); - } - memcpy( &uin->sir_addr, win->irdaDeviceID, sizeof(uin->sir_addr) ); - break; - } -#endif - case WS_AF_UNSPEC: { - /* Try to determine the needed space by the passed windows sockaddr space */ - switch (wsaddrlen) { - default: /* likely an ipv4 address */ - case sizeof(struct WS_sockaddr_in): - uaddrlen = sizeof(struct sockaddr_in); - break; -#ifdef HAS_IPX - case sizeof(struct WS_sockaddr_ipx): - uaddrlen = sizeof(struct sockaddr_ipx); - break; -#endif -#ifdef HAS_IRDA - case sizeof(SOCKADDR_IRDA): - uaddrlen = sizeof(struct sockaddr_irda); - break; -#endif - case sizeof(struct WS_sockaddr_in6): - case sizeof(struct WS_sockaddr_in6_old): - uaddrlen = sizeof(struct sockaddr_in6); - break; - } - memset( uaddr, 0, uaddrlen ); - break; - } - default: - FIXME("Unknown address family %d, return NULL.\n", wsaddr->sa_family); - return 0; - } - return uaddrlen; -}
static INT WS_DuplicateSocket(BOOL unicode, SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo) { diff --git a/dlls/ws2_32/unixlib.c b/dlls/ws2_32/unixlib.c index cde73198c16..240389aeeaa 100644 --- a/dlls/ws2_32/unixlib.c +++ b/dlls/ws2_32/unixlib.c @@ -98,6 +98,15 @@ static const int addrinfo_flag_map[][2] = MAP( AI_ADDRCONFIG ), };
+static const int nameinfo_flag_map[][2] = +{ + MAP( NI_DGRAM ), + MAP( NI_NAMEREQD ), + MAP( NI_NOFQDN ), + MAP( NI_NUMERICHOST ), + MAP( NI_NUMERICSERV ), +}; + static const int family_map[][2] = { MAP( AF_UNSPEC ), @@ -170,6 +179,25 @@ static int addrinfo_flags_to_unix( int flags ) return unix_flags; }
+static int nameinfo_flags_to_unix( int flags ) +{ + int unix_flags = 0; + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(nameinfo_flag_map); ++i) + { + if (flags & nameinfo_flag_map[i][0]) + { + unix_flags |= nameinfo_flag_map[i][1]; + flags &= ~nameinfo_flag_map[i][0]; + } + } + + if (flags) + FIXME( "unhandled flags %#x\n", flags ); + return unix_flags; +} + static int family_from_unix( int family ) { unsigned int i; @@ -471,6 +499,103 @@ static int sockaddr_from_unix( const union unix_sockaddr *uaddr, struct WS_socka } }
+static socklen_t sockaddr_to_unix( const struct WS_sockaddr *wsaddr, int wsaddrlen, union unix_sockaddr *uaddr ) +{ + memset( uaddr, 0, sizeof(*uaddr) ); + + switch (wsaddr->sa_family) + { + case WS_AF_INET: + { + struct WS_sockaddr_in win = {0}; + + if (wsaddrlen < sizeof(win)) return 0; + memcpy( &win, wsaddr, sizeof(win) ); + uaddr->in.sin_family = AF_INET; + uaddr->in.sin_port = win.sin_port; + memcpy( &uaddr->in.sin_addr, &win.sin_addr, sizeof(win.sin_addr) ); + return sizeof(uaddr->in); + } + + case WS_AF_INET6: + { + struct WS_sockaddr_in6 win = {0}; + + if (wsaddrlen < sizeof(win)) return 0; + memcpy( &win, wsaddr, sizeof(win) ); + uaddr->in6.sin6_family = AF_INET6; + uaddr->in6.sin6_port = win.sin6_port; + uaddr->in6.sin6_flowinfo = win.sin6_flowinfo; + memcpy( &uaddr->in6.sin6_addr, &win.sin6_addr, sizeof(win.sin6_addr) ); +#ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID + uaddr->in6.sin6_scope_id = win.sin6_scope_id; +#endif + return sizeof(uaddr->in6); + } + +#ifdef HAS_IPX + case WS_AF_IPX: + { + struct WS_sockaddr_ipx win = {0}; + + if (wsaddrlen < sizeof(win)) return 0; + memcpy( &win, wsaddr, sizeof(win) ); + uaddr->ipx.sipx_family = AF_IPX; + memcpy( &uaddr->ipx.sipx_network, win.sa_netnum, sizeof(win.sa_netnum) ); + memcpy( &uaddr->ipx.sipx_node, win.sa_nodenum, sizeof(win.sa_nodenum) ); + uaddr->ipx.sipx_port = win.sa_socket; + return sizeof(uaddr->ipx); + } +#endif + +#ifdef HAS_IRDA + case WS_AF_IRDA: + { + SOCKADDR_IRDA win = {0}; + unsigned int lsap_sel; + + if (wsaddrlen < sizeof(win)) return 0; + memcpy( &win, wsaddr, sizeof(win) ); + uaddr->irda.sir_family = AF_IRDA; + if (sscanf( win.irdaServiceName, "LSAP-SEL%u", &lsap_sel ) == 1) + uaddr->irda.sir_lsap_sel = lsap_sel; + else + { + uaddr->irda.sir_lsap_sel = LSAP_ANY; + memcpy( uaddr->irda.sir_name, win.irdaServiceName, sizeof(win.irdaServiceName) ); + } + memcpy( &uaddr->irda.sir_addr, win.irdaDeviceID, sizeof(win.irdaDeviceID) ); + return sizeof(uaddr->irda); + } +#endif + + case WS_AF_UNSPEC: + switch (wsaddrlen) + { + default: /* likely an ipv4 address */ + case sizeof(struct WS_sockaddr_in): + return sizeof(uaddr->in); + +#ifdef HAS_IPX + case sizeof(struct WS_sockaddr_ipx): + return sizeof(uaddr->ipx); +#endif + +#ifdef HAS_IRDA + case sizeof(SOCKADDR_IRDA): + return sizeof(uaddr->irda); +#endif + + case sizeof(struct WS_sockaddr_in6): + return sizeof(uaddr->in6); + } + + default: + FIXME( "unknown address family %u\n", wsaddr->sa_family ); + return 0; + } +} + static BOOL addrinfo_in_list( const struct WS_addrinfo *list, const struct WS_addrinfo *ai ) { const struct WS_addrinfo *cursor = list; @@ -798,12 +923,26 @@ static int CDECL unix_gethostname( char *name, int len ) }
+static int CDECL unix_getnameinfo( const struct WS(sockaddr) *addr, int addr_len, char *host, + DWORD host_len, char *serv, DWORD serv_len, int flags ) +{ + union unix_sockaddr unix_addr; + socklen_t unix_addr_len; + + unix_addr_len = sockaddr_to_unix( addr, addr_len, &unix_addr ); + + return addrinfo_err_from_unix( getnameinfo( &unix_addr.addr, unix_addr_len, host, host_len, + serv, serv_len, nameinfo_flags_to_unix( flags ) ) ); +} + + static const struct unix_funcs funcs = { unix_getaddrinfo, unix_gethostbyaddr, unix_gethostbyname, unix_gethostname, + unix_getnameinfo, };
NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out ) diff --git a/dlls/ws2_32/ws2_32_private.h b/dlls/ws2_32/ws2_32_private.h index 973f24a10a9..923d92a58a5 100644 --- a/dlls/ws2_32/ws2_32_private.h +++ b/dlls/ws2_32/ws2_32_private.h @@ -165,20 +165,8 @@
static const char magic_loopback_addr[] = {127, 12, 34, 56};
-union generic_unix_sockaddr -{ - struct sockaddr addr; - char data[128]; /* should be big enough for all families */ -}; - -int convert_eai_u2w( int ret ) DECLSPEC_HIDDEN; -unsigned int ws_sockaddr_ws2u( const struct WS_sockaddr *win_addr, int win_addr_len, - union generic_unix_sockaddr *unix_addr ) DECLSPEC_HIDDEN; - const char *debugstr_sockaddr( const struct WS_sockaddr *addr ) DECLSPEC_HIDDEN;
-UINT sock_get_error( int err ) DECLSPEC_HIDDEN; - struct per_thread_data { HANDLE sync_event; /* event to wait on for synchronous ioctls */ @@ -204,6 +192,8 @@ struct unix_funcs struct WS(hostent) *host, unsigned int *size ); int (CDECL *gethostbyname)( const char *name, struct WS(hostent) *host, unsigned int *size ); int (CDECL *gethostname)( char *name, int len ); + int (CDECL *getnameinfo)( const struct WS(sockaddr) *addr, int addr_len, char *host, + DWORD host_len, char *serv, DWORD serv_len, int flags ); };
extern const struct unix_funcs *unix_funcs;
Signed-off-by: Zebediah Figura zfigura@codeweavers.com --- dlls/ws2_32/Makefile.in | 2 +- dlls/ws2_32/protocol.c | 267 ++++++++++++++++++++++++++++++---------- 2 files changed, 203 insertions(+), 66 deletions(-)
diff --git a/dlls/ws2_32/Makefile.in b/dlls/ws2_32/Makefile.in index 77983bba66f..691c8fe1d65 100644 --- a/dlls/ws2_32/Makefile.in +++ b/dlls/ws2_32/Makefile.in @@ -1,7 +1,7 @@ EXTRADEFS = -DUSE_WS_PREFIX MODULE = ws2_32.dll IMPORTLIB = ws2_32 -DELAYIMPORTS = iphlpapi user32 +DELAYIMPORTS = advapi32 iphlpapi user32 EXTRALIBS = $(POLL_LIBS)
C_SRCS = \ diff --git a/dlls/ws2_32/protocol.c b/dlls/ws2_32/protocol.c index 8b39d5c3274..6c3ab8ea4ce 100644 --- a/dlls/ws2_32/protocol.c +++ b/dlls/ws2_32/protocol.c @@ -981,33 +981,71 @@ static int list_dup( char **src, char **dst, int item_size ) return p - (char *)dst; }
-static const struct -{ - int prot; - const char *names[3]; -} -protocols[] = -{ - { 0, {"ip", "IP"}}, - { 1, {"icmp", "ICMP"}}, - { 3, {"ggp", "GGP"}}, - { 6, {"tcp", "TCP"}}, - { 8, {"egp", "EGP"}}, - {12, {"pup", "PUP"}}, - {17, {"udp", "UDP"}}, - {20, {"hmp", "HMP"}}, - {22, {"xns-idp", "XNS-IDP"}}, - {27, {"rdp", "RDP"}}, - {41, {"ipv6", "IPv6"}}, - {43, {"ipv6-route", "IPv6-Route"}}, - {44, {"ipv6-frag", "IPv6-Frag"}}, - {50, {"esp", "ESP"}}, - {51, {"ah", "AH"}}, - {58, {"ipv6-icmp", "IPv6-ICMP"}}, - {59, {"ipv6-nonxt", "IPv6-NoNxt"}}, - {60, {"ipv6-opts", "IPv6-Opts"}}, - {66, {"rvd", "RVD"}}, -}; + +static const char *map_etc_file( const WCHAR *filename, DWORD *ret_size ) +{ + static const WCHAR key_pathW[] = {'S','y','s','t','e','m', + '\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t', + '\','S','e','r','v','i','c','e','s', + '\','t','c','p','i','p', + '\','P','a','r','a','m','e','t','e','r','s',0}; + static const WCHAR databasepathW[] = {'D','a','t','a','b','a','s','e','P','a','t','h',0}; + static const WCHAR backslashW[] = {'\',0}; + WCHAR path[MAX_PATH]; + DWORD size = sizeof(path); + HANDLE file, mapping; + const char *view; + LONG ret; + + if ((ret = RegGetValueW( HKEY_LOCAL_MACHINE, key_pathW, databasepathW, RRF_RT_REG_SZ, NULL, path, &size ))) + { + ERR( "failed to get database path, error %u\n", ret ); + return NULL; + } + lstrcatW( path, backslashW ); + lstrcatW( path, filename ); + + file = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL ); + if (file == INVALID_HANDLE_VALUE) + { + ERR( "failed to open %s, error %u\n", debugstr_w( path ), GetLastError() ); + return NULL; + } + + size = GetFileSize( file, NULL ); + + mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, size, NULL ); + CloseHandle( file ); + if (!mapping) + { + ERR( "failed to create mapping, error %u\n", GetLastError() ); + return NULL; + } + + view = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, size ); + CloseHandle( mapping ); + if (!view) + ERR( "failed to map file, error %u\n", GetLastError() ); + + *ret_size = size; + return view; +} + +/* returns "end" if there was no space */ +static char *next_space( const char *p, const char *end ) +{ + while (p < end && !isspace( *p )) + ++p; + return (char *)p; +} + +/* returns "end" if there was no non-space */ +static char *next_non_space( const char *p, const char *end ) +{ + while (p < end && isspace( *p )) + ++p; + return (char *)p; +}
static struct WS_protoent *get_protoent_buffer( unsigned int size ) { @@ -1024,18 +1062,111 @@ static struct WS_protoent *get_protoent_buffer( unsigned int size ) return data->pe_buffer; }
-static struct WS_protoent *create_protoent( const char *name, char **aliases, int prot ) +/* Parse the first valid line into a protoent structure, returning NULL if + * there is no valid line. Updates cursor to point to the start of the next + * line or the end of the file. */ +static struct WS_protoent *get_next_protocol( const char **cursor, const char *end ) { - struct WS_protoent *ret; - unsigned int size = sizeof(*ret) + strlen( name ) + sizeof(char *) + list_size( aliases, 0 ); + const char *p = *cursor;
- if (!(ret = get_protoent_buffer( size ))) return NULL; - ret->p_proto = prot; - ret->p_name = (char *)(ret + 1); - strcpy( ret->p_name, name ); - ret->p_aliases = (char **)ret->p_name + strlen( name ) / sizeof(char *) + 1; - list_dup( aliases, ret->p_aliases, 0 ); - return ret; + while (p < end) + { + const char *line_end, *next_line; + size_t needed_size, line_len; + unsigned int alias_count = 0; + struct WS_protoent *proto; + const char *name; + int number; + char *q; + + for (line_end = p; line_end < end && *line_end != '\n' && *line_end != '#'; ++line_end) + ; + TRACE( "parsing line %s\n", debugstr_an(p, line_end - p) ); + + for (next_line = line_end; next_line < end && *next_line != '\n'; ++next_line) + ; + if (next_line < end) + ++next_line; /* skip over the newline */ + + p = next_non_space( p, line_end ); + if (p == line_end) + { + p = next_line; + continue; + } + + /* parse the name */ + + name = p; + line_len = line_end - name; + + p = next_space( p, line_end ); + if (p == line_end) + { + p = next_line; + continue; + } + + p = next_non_space( p, line_end ); + + /* parse the number */ + + number = atoi( p ); + + p = next_space( p, line_end ); + p = next_non_space( p, line_end ); + + /* we will copy the entire line after the protoent structure, then + * replace spaces with null bytes as necessary */ + + while (p < line_end) + { + ++alias_count; + + p = next_space( p, line_end ); + p = next_non_space( p, line_end ); + } + needed_size = sizeof(*proto) + line_len + 1 + (alias_count + 1) * sizeof(char *); + + if (!(proto = get_protoent_buffer( needed_size ))) + { + SetLastError( WSAENOBUFS ); + return NULL; + } + + proto->p_proto = number; + proto->p_aliases = (char **)(proto + 1); + proto->p_name = (char *)(proto->p_aliases + alias_count + 1); + + memcpy( proto->p_name, name, line_len ); + proto->p_name[line_len] = 0; + + line_end = proto->p_name + line_len; + + q = proto->p_name; + q = next_space( q, line_end ); + *q++ = 0; + q = next_non_space( q, line_end ); + /* skip over the number */ + q = next_space( q, line_end ); + q = next_non_space( q, line_end ); + + alias_count = 0; + while (q < line_end) + { + proto->p_aliases[alias_count++] = q; + q = next_space( q, line_end ); + if (q < line_end) *q++ = 0; + q = next_non_space( q, line_end ); + } + proto->p_aliases[alias_count] = NULL; + + *cursor = next_line; + return proto; + } + + SetLastError( WSANO_DATA ); + return NULL; }
@@ -1044,25 +1175,28 @@ static struct WS_protoent *create_protoent( const char *name, char **aliases, in */ struct WS_protoent * WINAPI WS_getprotobyname( const char *name ) { - struct WS_protoent *retval = NULL; - unsigned int i; + static const WCHAR protocolW[] = {'p','r','o','t','o','c','o','l',0}; + struct WS_protoent *proto; + const char *file, *cursor; + DWORD size; + + TRACE( "%s\n", debugstr_a(name) );
- for (i = 0; i < ARRAY_SIZE(protocols); i++) + if (!(file = map_etc_file( protocolW, &size ))) { - if (!_strnicmp( protocols[i].names[0], name, -1 )) - { - retval = create_protoent( protocols[i].names[0], (char **)protocols[i].names + 1, - protocols[i].prot ); - break; - } + SetLastError( WSANO_DATA ); + return NULL; } - if (!retval) + + cursor = file; + while ((proto = get_next_protocol( &cursor, file + size ))) { - WARN( "protocol %s not found\n", debugstr_a(name) ); - SetLastError( WSANO_DATA ); + if (!strcasecmp( proto->p_name, name )) + break; } - TRACE( "%s ret %p\n", debugstr_a(name), retval ); - return retval; + + UnmapViewOfFile( file ); + return proto; }
@@ -1071,25 +1205,28 @@ struct WS_protoent * WINAPI WS_getprotobyname( const char *name ) */ struct WS_protoent * WINAPI WS_getprotobynumber( int number ) { - struct WS_protoent *retval = NULL; - unsigned int i; + static const WCHAR protocolW[] = {'p','r','o','t','o','c','o','l',0}; + struct WS_protoent *proto; + const char *file, *cursor; + DWORD size;
- for (i = 0; i < ARRAY_SIZE(protocols); i++) + TRACE( "%d\n", number ); + + if (!(file = map_etc_file( protocolW, &size ))) { - if (protocols[i].prot == number) - { - retval = create_protoent( protocols[i].names[0], (char **)protocols[i].names + 1, - protocols[i].prot ); - break; - } + SetLastError( WSANO_DATA ); + return NULL; } - if (!retval) + + cursor = file; + while ((proto = get_next_protocol( &cursor, file + size ))) { - WARN( "protocol %d not found\n", number ); - SetLastError( WSANO_DATA ); + if (proto->p_proto == number) + break; } - TRACE( "%d ret %p\n", number, retval ); - return retval; + + UnmapViewOfFile( file ); + return proto; }
Zebediah Figura zfigura@codeweavers.com writes:
- file = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
- if (file == INVALID_HANDLE_VALUE)
- {
ERR( "failed to open %s, error %u\n", debugstr_w( path ), GetLastError() );
return NULL;
- }
- size = GetFileSize( file, NULL );
- mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, size, NULL );
- CloseHandle( file );
- if (!mapping)
- {
ERR( "failed to create mapping, error %u\n", GetLastError() );
return NULL;
- }
- view = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, size );
- CloseHandle( mapping );
- if (!view)
ERR( "failed to map file, error %u\n", GetLastError() );
I'd suggest malloc+read instead of a file mapping, so that we don't waste 64K of address space to load a 400-byte file.
On 8/5/21 3:49 AM, Alexandre Julliard wrote:
Zebediah Figura zfigura@codeweavers.com writes:
- file = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
- if (file == INVALID_HANDLE_VALUE)
- {
ERR( "failed to open %s, error %u\n", debugstr_w( path ), GetLastError() );
return NULL;
- }
- size = GetFileSize( file, NULL );
- mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, size, NULL );
- CloseHandle( file );
- if (!mapping)
- {
ERR( "failed to create mapping, error %u\n", GetLastError() );
return NULL;
- }
- view = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, size );
- CloseHandle( mapping );
- if (!view)
ERR( "failed to map file, error %u\n", GetLastError() );
I'd suggest malloc+read instead of a file mapping, so that we don't waste 64K of address space to load a 400-byte file.
Sure; thanks for fixing that up :-)
Signed-off-by: Zebediah Figura zfigura@codeweavers.com --- dlls/ws2_32/protocol.c | 247 +++++++++++++++++++++++------------------ 1 file changed, 141 insertions(+), 106 deletions(-)
diff --git a/dlls/ws2_32/protocol.c b/dlls/ws2_32/protocol.c index 6c3ab8ea4ce..e280da84205 100644 --- a/dlls/ws2_32/protocol.c +++ b/dlls/ws2_32/protocol.c @@ -29,8 +29,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(winsock); WINE_DECLARE_DEBUG_CHANNEL(winediag);
-DECLARE_CRITICAL_SECTION(csWSgetXXXbyYYY); - static char *get_fqdn(void) { char *ret; @@ -949,39 +947,6 @@ int WINAPI GetHostNameW( WCHAR *name, int namelen ) }
-static int list_size( char **list, int item_size ) -{ - int i, size = 0; - if (list) - { - for (i = 0; list[i]; i++) - size += (item_size ? item_size : strlen(list[i]) + 1); - size += (i + 1) * sizeof(char *); - } - return size; -} - -static int list_dup( char **src, char **dst, int item_size ) -{ - char *p; - int i; - - for (i = 0; src[i]; i++) - ; - p = (char *)(dst + i + 1); - - for (i = 0; src[i]; i++) - { - int count = item_size ? item_size : strlen(src[i]) + 1; - memcpy( p, src[i], count ); - dst[i] = p; - p += count; - } - dst[i] = NULL; - return p - (char *)dst; -} - - static const char *map_etc_file( const WCHAR *filename, DWORD *ret_size ) { static const WCHAR key_pathW[] = {'S','y','s','t','e','m', @@ -1230,20 +1195,6 @@ struct WS_protoent * WINAPI WS_getprotobynumber( int number ) }
-static char *strdup_lower( const char *str ) -{ - char *ret = HeapAlloc( GetProcessHeap(), 0, strlen(str) + 1 ); - int i; - - if (ret) - { - for (i = 0; str[i]; i++) ret[i] = tolower( str[i] ); - ret[i] = 0; - } - else SetLastError( WSAENOBUFS ); - return ret; -} - static struct WS_servent *get_servent_buffer( int size ) { struct per_thread_data *data = get_per_thread_data(); @@ -1258,31 +1209,120 @@ static struct WS_servent *get_servent_buffer( int size ) return data->se_buffer; }
-static struct WS_servent *servent_from_unix( const struct servent *p_se ) +/* Parse the first valid line into a servent structure, returning NULL if + * there is no valid line. Updates cursor to point to the start of the next + * line or the end of the file. */ +static struct WS_servent *get_next_service( const char **cursor, const char *end ) { - char *p; - struct WS_servent *p_to; + const char *p = *cursor; + + while (p < end) + { + const char *line_end, *next_line; + size_t needed_size, line_len; + unsigned int alias_count = 0; + struct WS_servent *serv; + const char *name; + int port; + char *q;
- int size = (sizeof(*p_se) + - strlen(p_se->s_proto) + 1 + - strlen(p_se->s_name) + 1 + - list_size(p_se->s_aliases, 0)); + for (line_end = p; line_end < end && *line_end != '\n' && *line_end != '#'; ++line_end) + ; + TRACE( "parsing line %s\n", debugstr_an(p, line_end - p) );
- if (!(p_to = get_servent_buffer( size ))) return NULL; - p_to->s_port = p_se->s_port; + for (next_line = line_end; next_line < end && *next_line != '\n'; ++next_line) + ; + if (next_line < end) + ++next_line; /* skip over the newline */
- p = (char *)(p_to + 1); - p_to->s_name = p; - strcpy( p, p_se->s_name ); - p += strlen(p) + 1; + p = next_non_space( p, line_end ); + if (p == line_end) + { + p = next_line; + continue; + }
- p_to->s_proto = p; - strcpy( p, p_se->s_proto ); - p += strlen(p) + 1; + /* parse the name */
- p_to->s_aliases = (char **)p; - list_dup( p_se->s_aliases, p_to->s_aliases, 0 ); - return p_to; + name = p; + line_len = line_end - name; + + p = next_space( p, line_end ); + if (p == line_end) + { + p = next_line; + continue; + } + + p = next_non_space( p, line_end ); + + /* parse the port */ + + port = atoi( p ); + p = memchr( p, '/', line_end - p ); + if (!p) + { + p = next_line; + continue; + } + + p = next_space( p, line_end ); + p = next_non_space( p, line_end ); + + /* we will copy the entire line after the servent structure, then + * replace spaces with null bytes as necessary */ + + while (p < line_end) + { + ++alias_count; + + p = next_space( p, line_end ); + p = next_non_space( p, line_end ); + } + needed_size = sizeof(*serv) + line_len + 1 + (alias_count + 1) * sizeof(char *); + + if (!(serv = get_servent_buffer( needed_size ))) + { + SetLastError( WSAENOBUFS ); + return NULL; + } + + serv->s_port = htons( port ); + serv->s_aliases = (char **)(serv + 1); + serv->s_name = (char *)(serv->s_aliases + alias_count + 1); + + memcpy( serv->s_name, name, line_len ); + serv->s_name[line_len] = 0; + + line_end = serv->s_name + line_len; + + q = serv->s_name; + q = next_space( q, line_end ); + *q++ = 0; + q = next_non_space( q, line_end ); + /* skip over the number */ + q = memchr( q, '/', line_end - q ); + serv->s_proto = ++q; + q = next_space( q, line_end ); + if (q < line_end) *q++ = 0; + q = next_non_space( q, line_end ); + + alias_count = 0; + while (q < line_end) + { + serv->s_aliases[alias_count++] = q; + q = next_space( q, line_end ); + if (q < line_end) *q++ = 0; + q = next_non_space( q, line_end ); + } + serv->s_aliases[alias_count] = NULL; + + *cursor = next_line; + return serv; + } + + SetLastError( WSANO_DATA ); + return NULL; }
@@ -1291,34 +1331,28 @@ static struct WS_servent *servent_from_unix( const struct servent *p_se ) */ struct WS_servent * WINAPI WS_getservbyname( const char *name, const char *proto ) { - struct WS_servent *retval = NULL; - struct servent *serv; - char *name_str; - char *proto_str = NULL; + static const WCHAR servicesW[] = {'s','e','r','v','i','c','e','s',0}; + struct WS_servent *serv; + const char *file, *cursor; + DWORD size;
- if (!(name_str = strdup_lower( name ))) return NULL; + TRACE( "name %s, proto %s\n", debugstr_a(name), debugstr_a(proto) );
- if (proto && *proto) + if (!(file = map_etc_file( servicesW, &size ))) { - if (!(proto_str = strdup_lower( proto ))) - { - HeapFree( GetProcessHeap(), 0, name_str ); - return NULL; - } + SetLastError( WSANO_DATA ); + return NULL; }
- EnterCriticalSection( &csWSgetXXXbyYYY ); - serv = getservbyname( name_str, proto_str ); - if (serv) - retval = servent_from_unix( serv ); - else - SetLastError( WSANO_DATA ); - LeaveCriticalSection( &csWSgetXXXbyYYY ); + cursor = file; + while ((serv = get_next_service( &cursor, file + size ))) + { + if (!strcasecmp( serv->s_name, name ) && (!proto || !strcasecmp( serv->s_proto, proto ))) + break; + }
- HeapFree( GetProcessHeap(), 0, proto_str ); - HeapFree( GetProcessHeap(), 0, name_str ); - TRACE( "%s, %s ret %p\n", debugstr_a(name), debugstr_a(proto), retval ); - return retval; + UnmapViewOfFile( file ); + return serv; }
@@ -1327,27 +1361,28 @@ struct WS_servent * WINAPI WS_getservbyname( const char *name, const char *proto */ struct WS_servent * WINAPI WS_getservbyport( int port, const char *proto ) { - struct WS_servent *retval = NULL; -#ifdef HAVE_GETSERVBYPORT - struct servent *serv; - char *proto_str = NULL; + static const WCHAR servicesW[] = {'s','e','r','v','i','c','e','s',0}; + struct WS_servent *serv; + const char *file, *cursor; + DWORD size;
- if (proto && *proto) + TRACE( "port %d, proto %s\n", port, debugstr_a(proto) ); + + if (!(file = map_etc_file( servicesW, &size ))) { - if (!(proto_str = strdup_lower( proto ))) return NULL; + SetLastError( WSANO_DATA ); + return NULL; }
- EnterCriticalSection( &csWSgetXXXbyYYY ); - if ((serv = getservbyport( port, proto_str ))) - retval = servent_from_unix( serv ); - else - SetLastError( WSANO_DATA ); - LeaveCriticalSection( &csWSgetXXXbyYYY ); + cursor = file; + while ((serv = get_next_service( &cursor, file + size ))) + { + if (serv->s_port == port && (!proto || !strcasecmp( serv->s_proto, proto ))) + break; + }
- HeapFree( GetProcessHeap(), 0, proto_str ); -#endif - TRACE( "%d (i.e. port %d), %s ret %p\n", port, (int)ntohl(port), debugstr_a(proto), retval ); - return retval; + UnmapViewOfFile( file ); + return serv; }
Signed-off-by: Zebediah Figura zfigura@codeweavers.com --- dlls/ws2_32/Makefile.in | 2 + dlls/ws2_32/async.c | 3 - dlls/ws2_32/protocol.c | 74 ++++++++++++++----------- dlls/ws2_32/socket.c | 40 ++++++++------ dlls/ws2_32/ws2_32_private.h | 103 ----------------------------------- 5 files changed, 66 insertions(+), 156 deletions(-)
diff --git a/dlls/ws2_32/Makefile.in b/dlls/ws2_32/Makefile.in index 691c8fe1d65..643fe399d92 100644 --- a/dlls/ws2_32/Makefile.in +++ b/dlls/ws2_32/Makefile.in @@ -4,6 +4,8 @@ IMPORTLIB = ws2_32 DELAYIMPORTS = advapi32 iphlpapi user32 EXTRALIBS = $(POLL_LIBS)
+EXTRADLLFLAGS = -mno-cygwin + C_SRCS = \ async.c \ protocol.c \ diff --git a/dlls/ws2_32/async.c b/dlls/ws2_32/async.c index 56c60fc2ef8..d81f78257c9 100644 --- a/dlls/ws2_32/async.c +++ b/dlls/ws2_32/async.c @@ -34,9 +34,6 @@ * whole stuff did not work anyway to other changes). */
-#include "config.h" -#include "wine/port.h" - #include <stdarg.h> #include "windef.h" #include "winbase.h" diff --git a/dlls/ws2_32/protocol.c b/dlls/ws2_32/protocol.c index e280da84205..c2bbacca04a 100644 --- a/dlls/ws2_32/protocol.c +++ b/dlls/ws2_32/protocol.c @@ -22,13 +22,31 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "config.h" - #include "ws2_32_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(winsock); WINE_DECLARE_DEBUG_CHANNEL(winediag);
+static inline unsigned short ntohs( unsigned short netshort ) +{ + return RtlUshortByteSwap( netshort ); +} + +static inline unsigned short htons( unsigned short hostshort ) +{ + return RtlUshortByteSwap( hostshort ); +} + +static inline unsigned int ntohl( unsigned int netlong ) +{ + return RtlUlongByteSwap( netlong ); +} + +static inline unsigned int htonl( unsigned int hostlong ) +{ + return RtlUlongByteSwap( hostlong ); +} + static char *get_fqdn(void) { char *ret; @@ -135,7 +153,7 @@ int WINAPI WS_getaddrinfo( const char *node, const char *service, { WS_freeaddrinfo( *info ); *info = NULL; - return EAI_NONAME; + return WS_EAI_NONAME; } } } @@ -293,7 +311,7 @@ static int WS_getaddrinfoW( const WCHAR *nodename, const WCHAR *servname, const struct WS_addrinfo *hints, ADDRINFOEXW **res, OVERLAPPED *overlapped, LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine ) { - int ret = EAI_MEMORY, len, i; + int ret = WS_EAI_MEMORY, len, i; char *nodenameA = NULL, *servnameA = NULL; struct WS_addrinfo *resA; WCHAR *local_nodenameW = (WCHAR *)nodename; @@ -323,7 +341,7 @@ static int WS_getaddrinfoW( const WCHAR *nodename, const WCHAR *servname, if (!len) { ERR("Failed to convert %s to punycode\n", debugstr_w(nodename)); - ret = EAI_FAIL; + ret = WS_EAI_FAIL; goto end; } if (!(local_nodenameW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) goto end; @@ -455,7 +473,7 @@ int WINAPI GetAddrInfoW(const WCHAR *nodename, const WCHAR *servname, const ADDR { struct WS_addrinfo *hintsA = NULL; ADDRINFOEXW *resex; - int ret = EAI_MEMORY; + int ret = WS_EAI_MEMORY;
TRACE( "nodename %s, servname %s, hints %p, result %p\n", debugstr_w(nodename), debugstr_w(servname), hints, res ); @@ -570,11 +588,11 @@ int WINAPI GetNameInfoW( const SOCKADDR *addr, WS_socklen_t addr_len, WCHAR *hos char *hostA = NULL, *servA = NULL;
if (host && (!(hostA = HeapAlloc( GetProcessHeap(), 0, host_len )))) - return EAI_MEMORY; + return WS_EAI_MEMORY; if (serv && (!(servA = HeapAlloc( GetProcessHeap(), 0, serv_len )))) { HeapFree( GetProcessHeap(), 0, hostA ); - return EAI_MEMORY; + return WS_EAI_MEMORY; }
ret = WS_getnameinfo( addr, addr_len, hostA, host_len, servA, serv_len, flags ); @@ -683,7 +701,7 @@ struct WS_hostent * WINAPI WS_gethostbyaddr( const char *addr, int len, int fami
struct route { - struct in_addr addr; + struct WS_in_addr addr; IF_INDEX interface; DWORD metric, default_route; }; @@ -770,7 +788,7 @@ static struct WS_hostent *get_local_ips( char *hostname ) /* If no IP is found in the next step (for whatever reason) * then fall back to the magic loopback address. */ - memcpy( &route_addrs[numroutes].addr.s_addr, magic_loopback_addr, 4 ); + memcpy( &route_addrs[numroutes].addr.WS_s_addr, magic_loopback_addr, 4 ); numroutes++; } if (numroutes == 0) @@ -784,20 +802,20 @@ static struct WS_hostent *get_local_ips( char *hostname ) char *ip = k->IpAddressList.IpAddress.String;
if (route_addrs[i].interface == k->Index) - route_addrs[i].addr.s_addr = inet_addr(ip); + route_addrs[i].addr.WS_s_addr = WS_inet_addr(ip); } }
/* Allocate a hostent and enough memory for all the IPs, * including the NULL at the end of the list. */ - hostlist = create_hostent( hostname, 1, 0, numroutes+1, sizeof(struct in_addr) ); + hostlist = create_hostent( hostname, 1, 0, numroutes+1, sizeof(struct WS_in_addr) ); if (hostlist == NULL) goto cleanup; hostlist->h_addr_list[numroutes] = NULL; hostlist->h_aliases[0] = NULL; - hostlist->h_addrtype = AF_INET; - hostlist->h_length = sizeof(struct in_addr); + hostlist->h_addrtype = WS_AF_INET; + hostlist->h_length = sizeof(struct WS_in_addr);
/* Reorder the entries before placing them in the host list. Windows expects * the IP list in order from highest priority to lowest (the critical thing @@ -807,7 +825,7 @@ static struct WS_hostent *get_local_ips( char *hostname ) qsort( route_addrs, numroutes, sizeof(struct route), compare_routes_by_metric_asc );
for (i = 0; i < numroutes; i++) - *(struct in_addr *)hostlist->h_addr_list[i] = route_addrs[i].addr; + *(struct WS_in_addr *)hostlist->h_addr_list[i] = route_addrs[i].addr;
cleanup: HeapFree( GetProcessHeap(), 0, route_addrs ); @@ -949,26 +967,20 @@ int WINAPI GetHostNameW( WCHAR *name, int namelen )
static const char *map_etc_file( const WCHAR *filename, DWORD *ret_size ) { - static const WCHAR key_pathW[] = {'S','y','s','t','e','m', - '\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t', - '\','S','e','r','v','i','c','e','s', - '\','t','c','p','i','p', - '\','P','a','r','a','m','e','t','e','r','s',0}; - static const WCHAR databasepathW[] = {'D','a','t','a','b','a','s','e','P','a','t','h',0}; - static const WCHAR backslashW[] = {'\',0}; WCHAR path[MAX_PATH]; DWORD size = sizeof(path); HANDLE file, mapping; const char *view; LONG ret;
- if ((ret = RegGetValueW( HKEY_LOCAL_MACHINE, key_pathW, databasepathW, RRF_RT_REG_SZ, NULL, path, &size ))) + if ((ret = RegGetValueW( HKEY_LOCAL_MACHINE, L"System\CurrentControlSet\Services\tcpip\Parameters", + L"DatabasePath", RRF_RT_REG_SZ, NULL, path, &size ))) { ERR( "failed to get database path, error %u\n", ret ); return NULL; } - lstrcatW( path, backslashW ); - lstrcatW( path, filename ); + wcscat( path, L"\" ); + wcscat( path, filename );
file = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL ); if (file == INVALID_HANDLE_VALUE) @@ -1140,14 +1152,13 @@ static struct WS_protoent *get_next_protocol( const char **cursor, const char *e */ struct WS_protoent * WINAPI WS_getprotobyname( const char *name ) { - static const WCHAR protocolW[] = {'p','r','o','t','o','c','o','l',0}; struct WS_protoent *proto; const char *file, *cursor; DWORD size;
TRACE( "%s\n", debugstr_a(name) );
- if (!(file = map_etc_file( protocolW, &size ))) + if (!(file = map_etc_file( L"protocol", &size ))) { SetLastError( WSANO_DATA ); return NULL; @@ -1170,14 +1181,13 @@ struct WS_protoent * WINAPI WS_getprotobyname( const char *name ) */ struct WS_protoent * WINAPI WS_getprotobynumber( int number ) { - static const WCHAR protocolW[] = {'p','r','o','t','o','c','o','l',0}; struct WS_protoent *proto; const char *file, *cursor; DWORD size;
TRACE( "%d\n", number );
- if (!(file = map_etc_file( protocolW, &size ))) + if (!(file = map_etc_file( L"protocol", &size ))) { SetLastError( WSANO_DATA ); return NULL; @@ -1331,14 +1341,13 @@ static struct WS_servent *get_next_service( const char **cursor, const char *end */ struct WS_servent * WINAPI WS_getservbyname( const char *name, const char *proto ) { - static const WCHAR servicesW[] = {'s','e','r','v','i','c','e','s',0}; struct WS_servent *serv; const char *file, *cursor; DWORD size;
TRACE( "name %s, proto %s\n", debugstr_a(name), debugstr_a(proto) );
- if (!(file = map_etc_file( servicesW, &size ))) + if (!(file = map_etc_file( L"services", &size ))) { SetLastError( WSANO_DATA ); return NULL; @@ -1361,14 +1370,13 @@ struct WS_servent * WINAPI WS_getservbyname( const char *name, const char *proto */ struct WS_servent * WINAPI WS_getservbyport( int port, const char *proto ) { - static const WCHAR servicesW[] = {'s','e','r','v','i','c','e','s',0}; struct WS_servent *serv; const char *file, *cursor; DWORD size;
TRACE( "port %d, proto %s\n", port, debugstr_a(proto) );
- if (!(file = map_etc_file( servicesW, &size ))) + if (!(file = map_etc_file( L"services", &size ))) { SetLastError( WSANO_DATA ); return NULL; diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c index ca95a1e0321..3947ed22689 100644 --- a/dlls/ws2_32/socket.c +++ b/dlls/ws2_32/socket.c @@ -26,11 +26,18 @@ * clients and servers (www.winsite.com got a lot of those). */
-#include "config.h" -#include "wine/port.h" - #include "ws2_32_private.h"
+static inline unsigned short ntohs( unsigned short netshort ) +{ + return RtlUshortByteSwap( netshort ); +} + +static inline unsigned int ntohl( unsigned int netlong ) +{ + return RtlUlongByteSwap( netlong ); +} + #define FILE_USE_FILE_POINTER_POSITION ((LONGLONG)-2)
WINE_DEFAULT_DEBUG_CHANNEL(winsock); @@ -53,7 +60,7 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .iMinSockAddr = sizeof(struct WS_sockaddr_in), .iSocketType = WS_SOCK_STREAM, .iProtocol = WS_IPPROTO_TCP, - .szProtocol = {'T','C','P','/','I','P',0}, + .szProtocol = L"TCP/IP", }, { .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_SUPPORT_BROADCAST @@ -69,7 +76,7 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .iSocketType = WS_SOCK_DGRAM, .iProtocol = WS_IPPROTO_UDP, .dwMessageSize = 0xffbb, - .szProtocol = {'U','D','P','/','I','P',0}, + .szProtocol = L"UDP/IP", }, { .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_EXPEDITED_DATA | XP1_GRACEFUL_CLOSE @@ -84,7 +91,7 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .iMinSockAddr = sizeof(struct WS_sockaddr_in6), .iSocketType = WS_SOCK_STREAM, .iProtocol = WS_IPPROTO_TCP, - .szProtocol = {'T','C','P','/','I','P','v','6',0}, + .szProtocol = L"TCP/IPv6", }, { .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_SUPPORT_BROADCAST @@ -100,7 +107,7 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .iSocketType = WS_SOCK_DGRAM, .iProtocol = WS_IPPROTO_UDP, .dwMessageSize = 0xffbb, - .szProtocol = {'U','D','P','/','I','P','v','6',0}, + .szProtocol = L"UDP/IPv6", }, { .dwServiceFlags1 = XP1_PARTIAL_MESSAGE | XP1_SUPPORT_BROADCAST @@ -117,7 +124,7 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .iProtocol = WS_NSPROTO_IPX, .iProtocolMaxOffset = 255, .dwMessageSize = 0x240, - .szProtocol = {'I','P','X',0}, + .szProtocol = L"IPX", }, { .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_PSEUDO_STREAM | XP1_MESSAGE_ORIENTED @@ -133,7 +140,7 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .iSocketType = WS_SOCK_SEQPACKET, .iProtocol = WS_NSPROTO_SPX, .dwMessageSize = UINT_MAX, - .szProtocol = {'S','P','X',0}, + .szProtocol = L"SPX", }, { .dwServiceFlags1 = XP1_IFS_HANDLES | XP1_GRACEFUL_CLOSE | XP1_PSEUDO_STREAM @@ -149,7 +156,7 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .iSocketType = WS_SOCK_SEQPACKET, .iProtocol = WS_NSPROTO_SPXII, .dwMessageSize = UINT_MAX, - .szProtocol = {'S','P','X',' ','I','I',0}, + .szProtocol = L"SPX II", }, };
@@ -1388,9 +1395,9 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, return -1;
if (infow.iAddressFamily == WS_AF_INET) - addr_size = sizeof(struct sockaddr_in); + addr_size = sizeof(struct WS_sockaddr_in); else if (infow.iAddressFamily == WS_AF_INET6) - addr_size = sizeof(struct sockaddr_in6); + addr_size = sizeof(struct WS_sockaddr_in6); else { FIXME( "family %d is unsupported for SO_BSP_STATE\n", infow.iAddressFamily ); @@ -1507,7 +1514,7 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, if (!ws_protocol_info( s, TRUE, &info, &size )) return -1;
- if (info.iSocketType == SOCK_DGRAM) + if (info.iSocketType == WS_SOCK_DGRAM) { SetLastError( WSAENOPROTOOPT ); return -1; @@ -2061,7 +2068,7 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID
sockaddr[i].sin_family = WS_AF_INET; sockaddr[i].sin_port = 0; - sockaddr[i].sin_addr.WS_s_addr = inet_addr(p->IpAddressList.IpAddress.String); + sockaddr[i].sin_addr.WS_s_addr = WS_inet_addr(p->IpAddressList.IpAddress.String); i++; }
@@ -3222,7 +3229,6 @@ SOCKET WINAPI WSASocketW(int af, int type, int protocol, LPWSAPROTOCOL_INFOW lpProtocolInfo, GROUP g, DWORD flags) { - static const WCHAR afdW[] = {'\','D','e','v','i','c','e','\','A','f','d',0}; struct afd_create_params create_params; OBJECT_ATTRIBUTES attr; UNICODE_STRING string; @@ -3302,7 +3308,7 @@ SOCKET WINAPI WSASocketW(int af, int type, int protocol, } }
- RtlInitUnicodeString(&string, afdW); + RtlInitUnicodeString(&string, L"\Device\Afd"); InitializeObjectAttributes(&attr, &string, (flags & WSA_FLAG_NO_HANDLE_INHERIT) ? 0 : OBJ_INHERIT, NULL, NULL); if ((status = NtOpenFile(&handle, GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, &attr, &io, 0, (flags & WSA_FLAG_OVERLAPPED) ? 0 : FILE_SYNCHRONOUS_IO_NONALERT))) @@ -3323,7 +3329,7 @@ SOCKET WINAPI WSASocketW(int af, int type, int protocol, err = RtlNtStatusToDosError( status ); if (err == WSAEACCES) /* raw socket denied */ { - if (type == SOCK_RAW) + if (type == WS_SOCK_RAW) ERR_(winediag)("Failed to create a socket of type SOCK_RAW, this requires special permissions.\n"); else ERR_(winediag)("Failed to create socket, this requires special permissions.\n"); diff --git a/dlls/ws2_32/ws2_32_private.h b/dlls/ws2_32/ws2_32_private.h index 923d92a58a5..57778c76461 100644 --- a/dlls/ws2_32/ws2_32_private.h +++ b/dlls/ws2_32/ws2_32_private.h @@ -22,109 +22,7 @@ #include <stdarg.h> #include <stdio.h> #include <string.h> -#include <sys/types.h> #include <limits.h> -#ifdef HAVE_SYS_IPC_H -# include <sys/ipc.h> -#endif -#ifdef HAVE_SYS_IOCTL_H -# include <sys/ioctl.h> -#endif -#ifdef HAVE_SYS_FILIO_H -# include <sys/filio.h> -#endif -#ifdef HAVE_SYS_SOCKIO_H -# include <sys/sockio.h> -#endif - -#if defined(__EMX__) -# include <sys/so_ioctl.h> -#endif - -#ifdef HAVE_SYS_PARAM_H -# include <sys/param.h> -#endif - -#ifdef HAVE_SYS_MSG_H -# include <sys/msg.h> -#endif -#ifdef HAVE_SYS_WAIT_H -# include <sys/wait.h> -#endif -#ifdef HAVE_SYS_UIO_H -# include <sys/uio.h> -#endif -#ifdef HAVE_SYS_SOCKET_H -#include <sys/socket.h> -#endif -#ifdef HAVE_NETINET_IN_H -# include <netinet/in.h> -#endif -#ifdef HAVE_NETINET_TCP_H -# include <netinet/tcp.h> -#endif -#ifdef HAVE_ARPA_INET_H -# include <arpa/inet.h> -#endif -#include <ctype.h> -#include <fcntl.h> -#include <errno.h> -#ifdef HAVE_NETDB_H -#include <netdb.h> -#endif -#ifdef HAVE_UNISTD_H -# include <unistd.h> -#endif -#include <stdlib.h> -#ifdef HAVE_ARPA_NAMESER_H -# include <arpa/nameser.h> -#endif -#ifdef HAVE_RESOLV_H -# include <resolv.h> -#endif -#ifdef HAVE_NET_IF_H -# define if_indextoname unix_if_indextoname -# define if_nametoindex unix_if_nametoindex -# include <net/if.h> -# undef if_indextoname -# undef if_nametoindex -#endif -#ifdef HAVE_IFADDRS_H -# include <ifaddrs.h> -#endif - -#ifdef HAVE_NETIPX_IPX_H -# include <netipx/ipx.h> -#elif defined(HAVE_LINUX_IPX_H) -# ifdef HAVE_ASM_TYPES_H -# include <asm/types.h> -# endif -# ifdef HAVE_LINUX_TYPES_H -# include <linux/types.h> -# endif -# include <linux/ipx.h> -#endif -#if defined(SOL_IPX) || defined(SO_DEFAULT_HEADERS) -# define HAS_IPX -#endif - -#ifdef HAVE_LINUX_IRDA_H -# ifdef HAVE_LINUX_TYPES_H -# include <linux/types.h> -# endif -# include <linux/irda.h> -# define HAS_IRDA -#endif - -#ifdef HAVE_POLL_H -#include <poll.h> -#endif -#ifdef HAVE_SYS_POLL_H -# include <sys/poll.h> -#endif -#ifdef HAVE_SYS_TIME_H -# include <sys/time.h> -#endif
#define NONAMELESSUNION #define NONAMELESSSTRUCT @@ -153,7 +51,6 @@ #include "wine/server.h" #include "wine/debug.h" #include "wine/exception.h" -#include "wine/unicode.h" #include "wine/heap.h"
#define DECLARE_CRITICAL_SECTION(cs) \
Signed-off-by: Zebediah Figura zfigura@codeweavers.com --- dlls/ws2_32/Makefile.in | 1 - dlls/ws2_32/async.c | 30 +- dlls/ws2_32/protocol.c | 269 +++++------ dlls/ws2_32/socket.c | 870 +++++++++++++++++------------------ dlls/ws2_32/unixlib.c | 1 + dlls/ws2_32/ws2_32.spec | 62 +-- dlls/ws2_32/ws2_32_private.h | 8 +- 7 files changed, 598 insertions(+), 643 deletions(-)
diff --git a/dlls/ws2_32/Makefile.in b/dlls/ws2_32/Makefile.in index 643fe399d92..78c1633c921 100644 --- a/dlls/ws2_32/Makefile.in +++ b/dlls/ws2_32/Makefile.in @@ -1,4 +1,3 @@ -EXTRADEFS = -DUSE_WS_PREFIX MODULE = ws2_32.dll IMPORTLIB = ws2_32 DELAYIMPORTS = advapi32 iphlpapi user32 diff --git a/dlls/ws2_32/async.c b/dlls/ws2_32/async.c index d81f78257c9..5eecddda062 100644 --- a/dlls/ws2_32/async.c +++ b/dlls/ws2_32/async.c @@ -128,15 +128,15 @@ static int list_dup(char** l_src, char* ref, int item_size)
/* ----- hostent */
-static LPARAM copy_he(void *base, int size, const struct WS_hostent *he) +static LPARAM copy_he(void *base, int size, const struct hostent *he) { char *p; int needed; - struct WS_hostent *to = base; + struct hostent *to = base;
if (!he) return MAKELPARAM( 0, GetLastError() );
- needed = sizeof(struct WS_hostent) + strlen(he->h_name) + 1 + + needed = sizeof(struct hostent) + strlen(he->h_name) + 1 + list_size(he->h_aliases, 0) + list_size(he->h_addr_list, he->h_length ); if (size < needed) return MAKELPARAM( needed, WSAENOBUFS ); @@ -156,7 +156,7 @@ static LPARAM copy_he(void *base, int size, const struct WS_hostent *he) static LPARAM async_gethostbyname( struct async_query_header *query ) { struct async_query_gethostbyname *aq = CONTAINING_RECORD( query, struct async_query_gethostbyname, query ); - struct WS_hostent *he = WS_gethostbyname( aq->host_name ); + struct hostent *he = gethostbyname( aq->host_name );
return copy_he( query->sbuf, query->sbuflen, he ); } @@ -164,22 +164,22 @@ static LPARAM async_gethostbyname( struct async_query_header *query ) static LPARAM async_gethostbyaddr( struct async_query_header *query ) { struct async_query_gethostbyaddr *aq = CONTAINING_RECORD( query, struct async_query_gethostbyaddr, query ); - struct WS_hostent *he = WS_gethostbyaddr( aq->host_addr, aq->host_len, aq->host_type ); + struct hostent *he = gethostbyaddr( aq->host_addr, aq->host_len, aq->host_type );
return copy_he( query->sbuf, query->sbuflen, he ); }
/* ----- protoent */
-static LPARAM copy_pe(void *base, int size, const struct WS_protoent* pe) +static LPARAM copy_pe( void *base, int size, const struct protoent *pe ) { char *p; int needed; - struct WS_protoent *to = base; + struct protoent *to = base;
if (!pe) return MAKELPARAM( 0, GetLastError() );
- needed = sizeof(struct WS_protoent) + strlen(pe->p_name) + 1 + list_size(pe->p_aliases, 0); + needed = sizeof(struct protoent) + strlen( pe->p_name ) + 1 + list_size( pe->p_aliases, 0 ); if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
to->p_proto = pe->p_proto; @@ -194,7 +194,7 @@ static LPARAM copy_pe(void *base, int size, const struct WS_protoent* pe) static LPARAM async_getprotobyname( struct async_query_header *query ) { struct async_query_getprotobyname *aq = CONTAINING_RECORD( query, struct async_query_getprotobyname, query ); - struct WS_protoent *pe = WS_getprotobyname( aq->proto_name ); + struct protoent *pe = getprotobyname( aq->proto_name );
return copy_pe( query->sbuf, query->sbuflen, pe ); } @@ -202,22 +202,22 @@ static LPARAM async_getprotobyname( struct async_query_header *query ) static LPARAM async_getprotobynumber( struct async_query_header *query ) { struct async_query_getprotobynumber *aq = CONTAINING_RECORD( query, struct async_query_getprotobynumber, query ); - struct WS_protoent *pe = WS_getprotobynumber( aq->proto_number ); + struct protoent *pe = getprotobynumber( aq->proto_number );
return copy_pe( query->sbuf, query->sbuflen, pe ); }
/* ----- servent */
-static LPARAM copy_se(void *base, int size, const struct WS_servent* se) +static LPARAM copy_se( void *base, int size, const struct servent *se ) { char *p; int needed; - struct WS_servent *to = base; + struct servent *to = base;
if (!se) return MAKELPARAM( 0, GetLastError() );
- needed = sizeof(struct WS_servent) + strlen(se->s_proto) + strlen(se->s_name) + 2 + list_size(se->s_aliases, 0); + needed = sizeof(struct servent) + strlen( se->s_proto ) + strlen( se->s_name ) + 2 + list_size( se->s_aliases, 0 ); if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
to->s_port = se->s_port; @@ -234,7 +234,7 @@ static LPARAM copy_se(void *base, int size, const struct WS_servent* se) static LPARAM async_getservbyname( struct async_query_header *query ) { struct async_query_getservbyname *aq = CONTAINING_RECORD( query, struct async_query_getservbyname, query ); - struct WS_servent *se = WS_getservbyname( aq->serv_name, aq->serv_proto ); + struct servent *se = getservbyname( aq->serv_name, aq->serv_proto );
return copy_se( query->sbuf, query->sbuflen, se ); } @@ -242,7 +242,7 @@ static LPARAM async_getservbyname( struct async_query_header *query ) static LPARAM async_getservbyport( struct async_query_header *query ) { struct async_query_getservbyport *aq = CONTAINING_RECORD( query, struct async_query_getservbyport, query ); - struct WS_servent *se = WS_getservbyport( aq->serv_port, aq->serv_proto ); + struct servent *se = getservbyport( aq->serv_port, aq->serv_proto );
return copy_se( query->sbuf, query->sbuflen, se ); } diff --git a/dlls/ws2_32/protocol.c b/dlls/ws2_32/protocol.c index c2bbacca04a..28f47d4aa30 100644 --- a/dlls/ws2_32/protocol.c +++ b/dlls/ws2_32/protocol.c @@ -27,26 +27,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(winsock); WINE_DECLARE_DEBUG_CHANNEL(winediag);
-static inline unsigned short ntohs( unsigned short netshort ) -{ - return RtlUshortByteSwap( netshort ); -} - -static inline unsigned short htons( unsigned short hostshort ) -{ - return RtlUshortByteSwap( hostshort ); -} - -static inline unsigned int ntohl( unsigned int netlong ) -{ - return RtlUlongByteSwap( netlong ); -} - -static inline unsigned int htonl( unsigned int hostlong ) -{ - return RtlUlongByteSwap( hostlong ); -} - static char *get_fqdn(void) { char *ret; @@ -65,9 +45,9 @@ static char *get_fqdn(void)
/* call Unix getaddrinfo, allocating a large enough buffer */ static int do_getaddrinfo( const char *node, const char *service, - const struct WS_addrinfo *hints, struct WS_addrinfo **info ) + const struct addrinfo *hints, struct addrinfo **info ) { - struct WS_addrinfo *buffer, *new_buffer; + struct addrinfo *buffer, *new_buffer; unsigned int size = 1024; int ret;
@@ -95,8 +75,8 @@ static int do_getaddrinfo( const char *node, const char *service, /*********************************************************************** * getaddrinfo (ws2_32.@) */ -int WINAPI WS_getaddrinfo( const char *node, const char *service, - const struct WS_addrinfo *hints, struct WS_addrinfo **info ) +int WINAPI getaddrinfo( const char *node, const char *service, + const struct addrinfo *hints, struct addrinfo **info ) { char *nodev6 = NULL, *fqdn = NULL; int ret; @@ -118,7 +98,7 @@ int WINAPI WS_getaddrinfo( const char *node, const char *service, if (!(fqdn = get_fqdn())) return WSA_NOT_ENOUGH_MEMORY; node = fqdn; } - else if (!hints || hints->ai_family == WS_AF_UNSPEC || hints->ai_family == WS_AF_INET6) + else if (!hints || hints->ai_family == AF_UNSPEC || hints->ai_family == AF_INET6) { /* [ipv6] or [ipv6]:portnumber are supported by Windows */ char *close_bracket; @@ -135,7 +115,7 @@ int WINAPI WS_getaddrinfo( const char *node, const char *service,
ret = do_getaddrinfo( node, service, hints, info );
- if (ret && (!hints || !(hints->ai_flags & WS_AI_NUMERICHOST)) && node) + if (ret && (!hints || !(hints->ai_flags & AI_NUMERICHOST)) && node) { if (!fqdn && !(fqdn = get_fqdn())) { @@ -149,11 +129,11 @@ int WINAPI WS_getaddrinfo( const char *node, const char *service, * is invalid */ ERR_(winediag)( "Failed to resolve your host name IP\n" ); ret = do_getaddrinfo( NULL, service, hints, info ); - if (!ret && hints && (hints->ai_flags & WS_AI_CANONNAME) && *info && !(*info)->ai_canonname) + if (!ret && hints && (hints->ai_flags & AI_CANONNAME) && *info && !(*info)->ai_canonname) { - WS_freeaddrinfo( *info ); + freeaddrinfo( *info ); *info = NULL; - return WS_EAI_NONAME; + return EAI_NONAME; } } } @@ -163,7 +143,7 @@ int WINAPI WS_getaddrinfo( const char *node, const char *service,
if (!ret && TRACE_ON(winsock)) { - struct WS_addrinfo *ai; + struct addrinfo *ai;
for (ai = *info; ai != NULL; ai = ai->ai_next) { @@ -178,7 +158,7 @@ int WINAPI WS_getaddrinfo( const char *node, const char *service, }
-static ADDRINFOEXW *addrinfo_AtoW( const struct WS_addrinfo *ai ) +static ADDRINFOEXW *addrinfo_AtoW( const struct addrinfo *ai ) { ADDRINFOEXW *ret;
@@ -217,7 +197,7 @@ static ADDRINFOEXW *addrinfo_AtoW( const struct WS_addrinfo *ai ) return ret; }
-static ADDRINFOEXW *addrinfo_list_AtoW( const struct WS_addrinfo *info ) +static ADDRINFOEXW *addrinfo_list_AtoW( const struct addrinfo *info ) { ADDRINFOEXW *ret, *infoW;
@@ -235,11 +215,11 @@ static ADDRINFOEXW *addrinfo_list_AtoW( const struct WS_addrinfo *info ) return ret; }
-static struct WS_addrinfo *addrinfo_WtoA( const struct WS_addrinfoW *ai ) +static struct addrinfo *addrinfo_WtoA( const struct addrinfoW *ai ) { - struct WS_addrinfo *ret; + struct addrinfo *ret;
- if (!(ret = HeapAlloc( GetProcessHeap(), 0, sizeof(struct WS_addrinfo) ))) return NULL; + if (!(ret = HeapAlloc( GetProcessHeap(), 0, sizeof(struct addrinfo) ))) return NULL; ret->ai_flags = ai->ai_flags; ret->ai_family = ai->ai_family; ret->ai_socktype = ai->ai_socktype; @@ -260,13 +240,13 @@ static struct WS_addrinfo *addrinfo_WtoA( const struct WS_addrinfoW *ai ) } if (ai->ai_addr) { - if (!(ret->ai_addr = HeapAlloc( GetProcessHeap(), 0, sizeof(struct WS_sockaddr) ))) + if (!(ret->ai_addr = HeapAlloc( GetProcessHeap(), 0, sizeof(struct sockaddr) ))) { HeapFree( GetProcessHeap(), 0, ret->ai_canonname ); HeapFree( GetProcessHeap(), 0, ret ); return NULL; } - memcpy( ret->ai_addr, ai->ai_addr, sizeof(struct WS_sockaddr) ); + memcpy( ret->ai_addr, ai->ai_addr, sizeof(struct sockaddr) ); } return ret; } @@ -278,7 +258,7 @@ struct getaddrinfo_args ADDRINFOEXW **result; char *nodename; char *servname; - struct WS_addrinfo *hints; + struct addrinfo *hints; };
static void WINAPI getaddrinfo_callback(TP_CALLBACK_INSTANCE *instance, void *context) @@ -287,15 +267,15 @@ static void WINAPI getaddrinfo_callback(TP_CALLBACK_INSTANCE *instance, void *co OVERLAPPED *overlapped = args->overlapped; HANDLE event = overlapped->hEvent; LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine = args->completion_routine; - struct WS_addrinfo *res; + struct addrinfo *res; int ret;
- ret = WS_getaddrinfo( args->nodename, args->servname, args->hints, &res ); + ret = getaddrinfo( args->nodename, args->servname, args->hints, &res ); if (res) { *args->result = addrinfo_list_AtoW(res); overlapped->u.Pointer = args->result; - WS_freeaddrinfo(res); + freeaddrinfo(res); }
HeapFree( GetProcessHeap(), 0, args->nodename ); @@ -307,13 +287,13 @@ static void WINAPI getaddrinfo_callback(TP_CALLBACK_INSTANCE *instance, void *co if (event) SetEvent( event ); }
-static int WS_getaddrinfoW( const WCHAR *nodename, const WCHAR *servname, - const struct WS_addrinfo *hints, ADDRINFOEXW **res, OVERLAPPED *overlapped, +static int getaddrinfoW( const WCHAR *nodename, const WCHAR *servname, + const struct addrinfo *hints, ADDRINFOEXW **res, OVERLAPPED *overlapped, LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine ) { - int ret = WS_EAI_MEMORY, len, i; + int ret = EAI_MEMORY, len, i; char *nodenameA = NULL, *servnameA = NULL; - struct WS_addrinfo *resA; + struct addrinfo *resA; WCHAR *local_nodenameW = (WCHAR *)nodename;
*res = NULL; @@ -329,7 +309,7 @@ static int WS_getaddrinfoW( const WCHAR *nodename, const WCHAR *servname, } if (nodename[i]) { - if (hints && (hints->ai_flags & WS_AI_DISABLE_IDN_ENCODING)) + if (hints && (hints->ai_flags & AI_DISABLE_IDN_ENCODING)) { /* Name requires conversion but it was disabled */ ret = WSAHOST_NOT_FOUND; @@ -341,7 +321,7 @@ static int WS_getaddrinfoW( const WCHAR *nodename, const WCHAR *servname, if (!len) { ERR("Failed to convert %s to punycode\n", debugstr_w(nodename)); - ret = WS_EAI_FAIL; + ret = EAI_FAIL; goto end; } if (!(local_nodenameW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) goto end; @@ -379,7 +359,7 @@ static int WS_getaddrinfoW( const WCHAR *nodename, const WCHAR *servname, args->servname = servnameA; if (hints) { - args->hints = (struct WS_addrinfo *)(args + 1); + args->hints = (struct addrinfo *)(args + 1); args->hints->ai_flags = hints->ai_flags; args->hints->ai_family = hints->ai_family; args->hints->ai_socktype = hints->ai_socktype; @@ -401,11 +381,11 @@ static int WS_getaddrinfoW( const WCHAR *nodename, const WCHAR *servname, return ERROR_IO_PENDING; }
- ret = WS_getaddrinfo( nodenameA, servnameA, hints, &resA ); + ret = getaddrinfo( nodenameA, servnameA, hints, &resA ); if (!ret) { *res = addrinfo_list_AtoW( resA ); - WS_freeaddrinfo( resA ); + freeaddrinfo( resA ); }
end: @@ -422,7 +402,7 @@ end: */ int WINAPI GetAddrInfoExW( const WCHAR *name, const WCHAR *servname, DWORD namespace, GUID *namespace_id, const ADDRINFOEXW *hints, ADDRINFOEXW **result, - struct WS_timeval *timeout, OVERLAPPED *overlapped, + struct timeval *timeout, OVERLAPPED *overlapped, LPLOOKUPSERVICE_COMPLETION_ROUTINE completion_routine, HANDLE *handle ) { int ret; @@ -439,7 +419,7 @@ int WINAPI GetAddrInfoExW( const WCHAR *name, const WCHAR *servname, DWORD names if (handle) FIXME( "Unsupported cancel handle\n" );
- ret = WS_getaddrinfoW( name, servname, (struct WS_addrinfo *)hints, result, overlapped, completion_routine ); + ret = getaddrinfoW( name, servname, (struct addrinfo *)hints, result, overlapped, completion_routine ); if (ret) return ret; if (handle) *handle = (HANDLE)0xdeadbeef; return 0; @@ -471,17 +451,17 @@ int WINAPI GetAddrInfoExCancel( HANDLE *handle ) */ int WINAPI GetAddrInfoW(const WCHAR *nodename, const WCHAR *servname, const ADDRINFOW *hints, ADDRINFOW **res) { - struct WS_addrinfo *hintsA = NULL; + struct addrinfo *hintsA = NULL; ADDRINFOEXW *resex; - int ret = WS_EAI_MEMORY; + int ret = EAI_MEMORY;
TRACE( "nodename %s, servname %s, hints %p, result %p\n", debugstr_w(nodename), debugstr_w(servname), hints, res );
*res = NULL; if (hints) hintsA = addrinfo_WtoA( hints ); - ret = WS_getaddrinfoW( nodename, servname, hintsA, &resex, NULL, NULL ); - WS_freeaddrinfo( hintsA ); + ret = getaddrinfoW( nodename, servname, hintsA, &resex, NULL, NULL ); + freeaddrinfo( hintsA ); if (ret) return ret;
if (resex) @@ -502,7 +482,7 @@ int WINAPI GetAddrInfoW(const WCHAR *nodename, const WCHAR *servname, const ADDR /*********************************************************************** * freeaddrinfo (ws2_32.@) */ -void WINAPI WS_freeaddrinfo( struct WS_addrinfo *info ) +void WINAPI freeaddrinfo( struct addrinfo *info ) { TRACE( "%p\n", info );
@@ -568,7 +548,7 @@ void WINAPI FreeAddrInfoExW( ADDRINFOEXW *ai ) /*********************************************************************** * getnameinfo (ws2_32.@) */ -int WINAPI WS_getnameinfo( const SOCKADDR *addr, WS_socklen_t addr_len, char *host, +int WINAPI getnameinfo( const SOCKADDR *addr, socklen_t addr_len, char *host, DWORD host_len, char *serv, DWORD serv_len, int flags ) { TRACE( "addr %s, addr_len %d, host %p, host_len %u, serv %p, serv_len %d, flags %#x\n", @@ -581,21 +561,21 @@ int WINAPI WS_getnameinfo( const SOCKADDR *addr, WS_socklen_t addr_len, char *ho /*********************************************************************** * GetNameInfoW (ws2_32.@) */ -int WINAPI GetNameInfoW( const SOCKADDR *addr, WS_socklen_t addr_len, WCHAR *host, +int WINAPI GetNameInfoW( const SOCKADDR *addr, socklen_t addr_len, WCHAR *host, DWORD host_len, WCHAR *serv, DWORD serv_len, int flags ) { int ret; char *hostA = NULL, *servA = NULL;
if (host && (!(hostA = HeapAlloc( GetProcessHeap(), 0, host_len )))) - return WS_EAI_MEMORY; + return EAI_MEMORY; if (serv && (!(servA = HeapAlloc( GetProcessHeap(), 0, serv_len )))) { HeapFree( GetProcessHeap(), 0, hostA ); - return WS_EAI_MEMORY; + return EAI_MEMORY; }
- ret = WS_getnameinfo( addr, addr_len, hostA, host_len, servA, serv_len, flags ); + ret = getnameinfo( addr, addr_len, hostA, host_len, servA, serv_len, flags ); if (!ret) { if (host) MultiByteToWideChar( CP_ACP, 0, hostA, -1, host, host_len ); @@ -608,7 +588,7 @@ int WINAPI GetNameInfoW( const SOCKADDR *addr, WS_socklen_t addr_len, WCHAR *hos }
-static struct WS_hostent *get_hostent_buffer( unsigned int size ) +static struct hostent *get_hostent_buffer( unsigned int size ) { struct per_thread_data *data = get_per_thread_data(); if (data->he_buffer) @@ -632,12 +612,12 @@ static struct WS_hostent *get_hostent_buffer( unsigned int size ) * the list has no items ("aliases" and "addresses" must be * at least "1", a truly empty list is invalid). */ -static struct WS_hostent *create_hostent( char *name, int alias_count, int aliases_size, - int address_count, int address_length ) +static struct hostent *create_hostent( char *name, int alias_count, int aliases_size, + int address_count, int address_length ) { - struct WS_hostent *p_to; + struct hostent *p_to; char *p; - unsigned int size = sizeof(struct WS_hostent), i; + unsigned int size = sizeof(struct hostent), i;
size += strlen(name) + 1; size += alias_count * sizeof(char *); @@ -679,10 +659,10 @@ static struct WS_hostent *create_hostent( char *name, int alias_count, int alias /*********************************************************************** * gethostbyaddr (ws2_32.51) */ -struct WS_hostent * WINAPI WS_gethostbyaddr( const char *addr, int len, int family ) +struct hostent * WINAPI gethostbyaddr( const char *addr, int len, int family ) { unsigned int size = 1024; - struct WS_hostent *host; + struct hostent *host; int ret;
if (!(host = get_hostent_buffer( size ))) @@ -701,7 +681,7 @@ struct WS_hostent * WINAPI WS_gethostbyaddr( const char *addr, int len, int fami
struct route { - struct WS_in_addr addr; + struct in_addr addr; IF_INDEX interface; DWORD metric, default_route; }; @@ -727,11 +707,11 @@ static int compare_routes_by_metric_asc( const void *left, const void *right ) * Please note that the returned hostent is only freed when the thread * closes and is replaced if another hostent is requested. */ -static struct WS_hostent *get_local_ips( char *hostname ) +static struct hostent *get_local_ips( char *hostname ) { int numroutes = 0, i, j, default_routes = 0; IP_ADAPTER_INFO *adapters = NULL, *k; - struct WS_hostent *hostlist = NULL; + struct hostent *hostlist = NULL; MIB_IPFORWARDTABLE *routes = NULL; struct route *route_addrs = NULL; DWORD adap_size, route_size, n; @@ -788,7 +768,7 @@ static struct WS_hostent *get_local_ips( char *hostname ) /* If no IP is found in the next step (for whatever reason) * then fall back to the magic loopback address. */ - memcpy( &route_addrs[numroutes].addr.WS_s_addr, magic_loopback_addr, 4 ); + memcpy( &route_addrs[numroutes].addr.s_addr, magic_loopback_addr, 4 ); numroutes++; } if (numroutes == 0) @@ -802,20 +782,20 @@ static struct WS_hostent *get_local_ips( char *hostname ) char *ip = k->IpAddressList.IpAddress.String;
if (route_addrs[i].interface == k->Index) - route_addrs[i].addr.WS_s_addr = WS_inet_addr(ip); + route_addrs[i].addr.s_addr = inet_addr(ip); } }
/* Allocate a hostent and enough memory for all the IPs, * including the NULL at the end of the list. */ - hostlist = create_hostent( hostname, 1, 0, numroutes+1, sizeof(struct WS_in_addr) ); + hostlist = create_hostent( hostname, 1, 0, numroutes+1, sizeof(struct in_addr) ); if (hostlist == NULL) goto cleanup; hostlist->h_addr_list[numroutes] = NULL; hostlist->h_aliases[0] = NULL; - hostlist->h_addrtype = WS_AF_INET; - hostlist->h_length = sizeof(struct WS_in_addr); + hostlist->h_addrtype = AF_INET; + hostlist->h_length = sizeof(struct in_addr);
/* Reorder the entries before placing them in the host list. Windows expects * the IP list in order from highest priority to lowest (the critical thing @@ -825,7 +805,7 @@ static struct WS_hostent *get_local_ips( char *hostname ) qsort( route_addrs, numroutes, sizeof(struct route), compare_routes_by_metric_asc );
for (i = 0; i < numroutes; i++) - *(struct WS_in_addr *)hostlist->h_addr_list[i] = route_addrs[i].addr; + *(struct in_addr *)hostlist->h_addr_list[i] = route_addrs[i].addr;
cleanup: HeapFree( GetProcessHeap(), 0, route_addrs ); @@ -838,9 +818,9 @@ cleanup: /*********************************************************************** * gethostbyname (ws2_32.52) */ -struct WS_hostent * WINAPI WS_gethostbyname( const char *name ) +struct hostent * WINAPI gethostbyname( const char *name ) { - struct WS_hostent *host = NULL; + struct hostent *host = NULL; char hostname[100]; int ret;
@@ -900,7 +880,7 @@ struct WS_hostent * WINAPI WS_gethostbyname( const char *name ) /*********************************************************************** * gethostname (ws2_32.57) */ -int WINAPI WS_gethostname( char *name, int namelen ) +int WINAPI gethostname( char *name, int namelen ) { char buf[256]; int len, ret; @@ -1024,7 +1004,8 @@ static char *next_non_space( const char *p, const char *end ) return (char *)p; }
-static struct WS_protoent *get_protoent_buffer( unsigned int size ) + +static struct protoent *get_protoent_buffer( unsigned int size ) { struct per_thread_data *data = get_per_thread_data();
@@ -1042,7 +1023,7 @@ static struct WS_protoent *get_protoent_buffer( unsigned int size ) /* Parse the first valid line into a protoent structure, returning NULL if * there is no valid line. Updates cursor to point to the start of the next * line or the end of the file. */ -static struct WS_protoent *get_next_protocol( const char **cursor, const char *end ) +static struct protoent *get_next_protocol( const char **cursor, const char *end ) { const char *p = *cursor;
@@ -1051,7 +1032,7 @@ static struct WS_protoent *get_next_protocol( const char **cursor, const char *e const char *line_end, *next_line; size_t needed_size, line_len; unsigned int alias_count = 0; - struct WS_protoent *proto; + struct protoent *proto; const char *name; int number; char *q; @@ -1150,9 +1131,9 @@ static struct WS_protoent *get_next_protocol( const char **cursor, const char *e /*********************************************************************** * getprotobyname (ws2_32.53) */ -struct WS_protoent * WINAPI WS_getprotobyname( const char *name ) +struct protoent * WINAPI getprotobyname( const char *name ) { - struct WS_protoent *proto; + struct protoent *proto; const char *file, *cursor; DWORD size;
@@ -1179,9 +1160,9 @@ struct WS_protoent * WINAPI WS_getprotobyname( const char *name ) /*********************************************************************** * getprotobynumber (ws2_32.54) */ -struct WS_protoent * WINAPI WS_getprotobynumber( int number ) +struct protoent * WINAPI getprotobynumber( int number ) { - struct WS_protoent *proto; + struct protoent *proto; const char *file, *cursor; DWORD size;
@@ -1205,7 +1186,7 @@ struct WS_protoent * WINAPI WS_getprotobynumber( int number ) }
-static struct WS_servent *get_servent_buffer( int size ) +static struct servent *get_servent_buffer( int size ) { struct per_thread_data *data = get_per_thread_data(); if (data->se_buffer) @@ -1222,7 +1203,7 @@ static struct WS_servent *get_servent_buffer( int size ) /* Parse the first valid line into a servent structure, returning NULL if * there is no valid line. Updates cursor to point to the start of the next * line or the end of the file. */ -static struct WS_servent *get_next_service( const char **cursor, const char *end ) +static struct servent *get_next_service( const char **cursor, const char *end ) { const char *p = *cursor;
@@ -1231,7 +1212,7 @@ static struct WS_servent *get_next_service( const char **cursor, const char *end const char *line_end, *next_line; size_t needed_size, line_len; unsigned int alias_count = 0; - struct WS_servent *serv; + struct servent *serv; const char *name; int port; char *q; @@ -1339,9 +1320,9 @@ static struct WS_servent *get_next_service( const char **cursor, const char *end /*********************************************************************** * getservbyname (ws2_32.55) */ -struct WS_servent * WINAPI WS_getservbyname( const char *name, const char *proto ) +struct servent * WINAPI getservbyname( const char *name, const char *proto ) { - struct WS_servent *serv; + struct servent *serv; const char *file, *cursor; DWORD size;
@@ -1368,9 +1349,9 @@ struct WS_servent * WINAPI WS_getservbyname( const char *name, const char *proto /*********************************************************************** * getservbyport (ws2_32.56) */ -struct WS_servent * WINAPI WS_getservbyport( int port, const char *proto ) +struct servent * WINAPI getservbyport( int port, const char *proto ) { - struct WS_servent *serv; + struct servent *serv; const char *file, *cursor; DWORD size;
@@ -1397,9 +1378,9 @@ struct WS_servent * WINAPI WS_getservbyport( int port, const char *proto ) /*********************************************************************** * inet_ntoa (ws2_32.12) */ -char * WINAPI WS_inet_ntoa( struct WS_in_addr in ) +char * WINAPI inet_ntoa( struct in_addr in ) { - unsigned int long_ip = ntohl( in.WS_s_addr ); + unsigned int long_ip = ntohl( in.s_addr ); struct per_thread_data *data = get_per_thread_data();
sprintf( data->ntoa_buffer, "%u.%u.%u.%u", @@ -1415,7 +1396,7 @@ char * WINAPI WS_inet_ntoa( struct WS_in_addr in ) /*********************************************************************** * inet_ntop (ws2_32.@) */ -const char * WINAPI WS_inet_ntop( int family, void *addr, char *buffer, SIZE_T len ) +const char * WINAPI inet_ntop( int family, void *addr, char *buffer, SIZE_T len ) { NTSTATUS status; ULONG size = min( len, (ULONG)-1 ); @@ -1429,12 +1410,12 @@ const char * WINAPI WS_inet_ntop( int family, void *addr, char *buffer, SIZE_T l
switch (family) { - case WS_AF_INET: + case AF_INET: { status = RtlIpv4AddressToStringExA( (IN_ADDR *)addr, 0, buffer, &size ); break; } - case WS_AF_INET6: + case AF_INET6: { status = RtlIpv6AddressToStringExA( (IN6_ADDR *)addr, 0, 0, buffer, &size ); break; @@ -1452,7 +1433,7 @@ const char * WINAPI WS_inet_ntop( int family, void *addr, char *buffer, SIZE_T l /*********************************************************************** * inet_pton (ws2_32.@) */ -int WINAPI WS_inet_pton( int family, const char *addr, void *buffer ) +int WINAPI inet_pton( int family, const char *addr, void *buffer ) { NTSTATUS status; const char *terminator; @@ -1467,10 +1448,10 @@ int WINAPI WS_inet_pton( int family, const char *addr, void *buffer )
switch (family) { - case WS_AF_INET: + case AF_INET: status = RtlIpv4StringToAddressA(addr, TRUE, &terminator, buffer); break; - case WS_AF_INET6: + case AF_INET6: status = RtlIpv6StringToAddressA(addr, &terminator, buffer); break; default: @@ -1506,7 +1487,7 @@ int WINAPI InetPtonW( int family, const WCHAR *addr, void *buffer ) } WideCharToMultiByte( CP_ACP, 0, addr, -1, addrA, len, NULL, NULL );
- ret = WS_inet_pton( family, addrA, buffer ); + ret = inet_pton( family, addrA, buffer ); if (!ret) SetLastError( WSAEINVAL );
HeapFree( GetProcessHeap(), 0, addrA ); @@ -1518,12 +1499,12 @@ int WINAPI InetPtonW( int family, const WCHAR *addr, void *buffer ) */ const WCHAR * WINAPI InetNtopW( int family, void *addr, WCHAR *buffer, SIZE_T len ) { - char bufferA[WS_INET6_ADDRSTRLEN]; + char bufferA[INET6_ADDRSTRLEN]; PWSTR ret = NULL;
TRACE( "family %d, addr %p, buffer %p, len %ld\n", family, addr, buffer, len );
- if (WS_inet_ntop( family, addr, bufferA, sizeof(bufferA) )) + if (inet_ntop( family, addr, bufferA, sizeof(bufferA) )) { if (MultiByteToWideChar( CP_ACP, 0, bufferA, -1, buffer, len )) ret = buffer; @@ -1538,7 +1519,7 @@ const WCHAR * WINAPI InetNtopW( int family, void *addr, WCHAR *buffer, SIZE_T le * WSAStringToAddressA (ws2_32.@) */ int WINAPI WSAStringToAddressA( char *string, int family, WSAPROTOCOL_INFOA *protocol_info, - struct WS_sockaddr *addr, int *addr_len ) + struct sockaddr *addr, int *addr_len ) { NTSTATUS status;
@@ -1557,17 +1538,17 @@ int WINAPI WSAStringToAddressA( char *string, int family, WSAPROTOCOL_INFOA *pro
switch (family) { - case WS_AF_INET: + case AF_INET: { - struct WS_sockaddr_in *addr4 = (struct WS_sockaddr_in *)addr; + struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
- if (*addr_len < sizeof(struct WS_sockaddr_in)) + if (*addr_len < sizeof(struct sockaddr_in)) { - *addr_len = sizeof(struct WS_sockaddr_in); + *addr_len = sizeof(struct sockaddr_in); SetLastError( WSAEFAULT ); return -1; } - memset( addr, 0, sizeof(struct WS_sockaddr_in) ); + memset( addr, 0, sizeof(struct sockaddr_in) );
status = RtlIpv4StringToAddressExA( string, FALSE, &addr4->sin_addr, &addr4->sin_port ); if (status != STATUS_SUCCESS) @@ -1575,21 +1556,21 @@ int WINAPI WSAStringToAddressA( char *string, int family, WSAPROTOCOL_INFOA *pro SetLastError( WSAEINVAL ); return -1; } - addr4->sin_family = WS_AF_INET; - *addr_len = sizeof(struct WS_sockaddr_in); + addr4->sin_family = AF_INET; + *addr_len = sizeof(struct sockaddr_in); return 0; } - case WS_AF_INET6: + case AF_INET6: { - struct WS_sockaddr_in6 *addr6 = (struct WS_sockaddr_in6 *)addr; + struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
- if (*addr_len < sizeof(struct WS_sockaddr_in6)) + if (*addr_len < sizeof(struct sockaddr_in6)) { - *addr_len = sizeof(struct WS_sockaddr_in6); + *addr_len = sizeof(struct sockaddr_in6); SetLastError( WSAEFAULT ); return -1; } - memset( addr, 0, sizeof(struct WS_sockaddr_in6) ); + memset( addr, 0, sizeof(struct sockaddr_in6) );
status = RtlIpv6StringToAddressExA( string, &addr6->sin6_addr, &addr6->sin6_scope_id, &addr6->sin6_port ); if (status != STATUS_SUCCESS) @@ -1597,8 +1578,8 @@ int WINAPI WSAStringToAddressA( char *string, int family, WSAPROTOCOL_INFOA *pro SetLastError( WSAEINVAL ); return -1; } - addr6->sin6_family = WS_AF_INET6; - *addr_len = sizeof(struct WS_sockaddr_in6); + addr6->sin6_family = AF_INET6; + *addr_len = sizeof(struct sockaddr_in6); return 0; } default: @@ -1614,7 +1595,7 @@ int WINAPI WSAStringToAddressA( char *string, int family, WSAPROTOCOL_INFOA *pro * WSAStringToAddressW (ws2_32.@) */ int WINAPI WSAStringToAddressW( WCHAR *string, int family, WSAPROTOCOL_INFOW *protocol_info, - struct WS_sockaddr *addr, int *addr_len ) + struct sockaddr *addr, int *addr_len ) { WSAPROTOCOL_INFOA infoA; WSAPROTOCOL_INFOA *protocol_infoA = NULL; @@ -1660,7 +1641,7 @@ int WINAPI WSAStringToAddressW( WCHAR *string, int family, WSAPROTOCOL_INFOW *pr /*********************************************************************** * WSAAddressToStringA (ws2_32.@) */ -int WINAPI WSAAddressToStringA( struct WS_sockaddr *addr, DWORD addr_len, +int WINAPI WSAAddressToStringA( struct sockaddr *addr, DWORD addr_len, WSAPROTOCOL_INFOA *info, char *string, DWORD *string_len ) { char buffer[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */ @@ -1673,13 +1654,13 @@ int WINAPI WSAAddressToStringA( struct WS_sockaddr *addr, DWORD addr_len,
switch (addr->sa_family) { - case WS_AF_INET: + case AF_INET: { - const struct WS_sockaddr_in *addr4 = (const struct WS_sockaddr_in *)addr; - unsigned int long_ip = ntohl( addr4->sin_addr.WS_s_addr ); + const struct sockaddr_in *addr4 = (const struct sockaddr_in *)addr; + unsigned int long_ip = ntohl( addr4->sin_addr.s_addr ); char *p;
- if (addr_len < sizeof(struct WS_sockaddr_in)) return -1; + if (addr_len < sizeof(struct sockaddr_in)) return -1; sprintf( buffer, "%u.%u.%u.%u:%u", (long_ip >> 24) & 0xff, (long_ip >> 16) & 0xff, @@ -1691,17 +1672,17 @@ int WINAPI WSAAddressToStringA( struct WS_sockaddr *addr, DWORD addr_len, if (!addr4->sin_port) *p = 0; break; } - case WS_AF_INET6: + case AF_INET6: { - struct WS_sockaddr_in6 *addr6 = (struct WS_sockaddr_in6 *)addr; + struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr; size_t len;
buffer[0] = 0; - if (addr_len < sizeof(struct WS_sockaddr_in6)) return -1; + if (addr_len < sizeof(struct sockaddr_in6)) return -1; if (addr6->sin6_port) strcpy( buffer, "[" ); len = strlen( buffer ); - if (!WS_inet_ntop( WS_AF_INET6, &addr6->sin6_addr, &buffer[len], sizeof(buffer) - len )) + if (!inet_ntop( AF_INET6, &addr6->sin6_addr, &buffer[len], sizeof(buffer) - len )) { SetLastError( WSAEINVAL ); return -1; @@ -1737,7 +1718,7 @@ int WINAPI WSAAddressToStringA( struct WS_sockaddr *addr, DWORD addr_len, /*********************************************************************** * WSAAddressToStringW (ws2_32.@) */ -int WINAPI WSAAddressToStringW( struct WS_sockaddr *addr, DWORD addr_len, +int WINAPI WSAAddressToStringW( struct sockaddr *addr, DWORD addr_len, WSAPROTOCOL_INFOW *info, WCHAR *string, DWORD *string_len ) { INT ret; @@ -1756,20 +1737,20 @@ int WINAPI WSAAddressToStringW( struct WS_sockaddr *addr, DWORD addr_len, /*********************************************************************** * inet_addr (ws2_32.11) */ -WS_u_long WINAPI WS_inet_addr( const char *str ) +u_long WINAPI inet_addr( const char *str ) { - WS_u_long addr; + u_long addr;
- if (WS_inet_pton( WS_AF_INET, str, &addr ) == 1) + if (inet_pton( AF_INET, str, &addr ) == 1) return addr; - return WS_INADDR_NONE; + return INADDR_NONE; }
/*********************************************************************** * htonl (ws2_32.8) */ -WS_u_long WINAPI WS_htonl( WS_u_long hostlong ) +u_long WINAPI WS_htonl( u_long hostlong ) { return htonl( hostlong ); } @@ -1778,7 +1759,7 @@ WS_u_long WINAPI WS_htonl( WS_u_long hostlong ) /*********************************************************************** * htons (ws2_32.9) */ -WS_u_short WINAPI WS_htons( WS_u_short hostshort ) +u_short WINAPI WS_htons( u_short hostshort ) { return htons( hostshort ); } @@ -1787,7 +1768,7 @@ WS_u_short WINAPI WS_htons( WS_u_short hostshort ) /*********************************************************************** * WSAHtonl (ws2_32.@) */ -int WINAPI WSAHtonl( SOCKET s, WS_u_long hostlong, WS_u_long *netlong ) +int WINAPI WSAHtonl( SOCKET s, u_long hostlong, u_long *netlong ) { if (netlong) { @@ -1802,7 +1783,7 @@ int WINAPI WSAHtonl( SOCKET s, WS_u_long hostlong, WS_u_long *netlong ) /*********************************************************************** * WSAHtons (ws2_32.@) */ -int WINAPI WSAHtons( SOCKET s, WS_u_short hostshort, WS_u_short *netshort ) +int WINAPI WSAHtons( SOCKET s, u_short hostshort, u_short *netshort ) { if (netshort) { @@ -1817,7 +1798,7 @@ int WINAPI WSAHtons( SOCKET s, WS_u_short hostshort, WS_u_short *netshort ) /*********************************************************************** * ntohl (ws2_32.14) */ -WS_u_long WINAPI WS_ntohl( WS_u_long netlong ) +u_long WINAPI WS_ntohl( u_long netlong ) { return ntohl( netlong ); } @@ -1826,7 +1807,7 @@ WS_u_long WINAPI WS_ntohl( WS_u_long netlong ) /*********************************************************************** * ntohs (ws2_32.15) */ -WS_u_short WINAPI WS_ntohs( WS_u_short netshort ) +u_short WINAPI WS_ntohs( u_short netshort ) { return ntohs( netshort ); } @@ -1835,7 +1816,7 @@ WS_u_short WINAPI WS_ntohs( WS_u_short netshort ) /*********************************************************************** * WSANtohl (ws2_32.@) */ -int WINAPI WSANtohl( SOCKET s, WS_u_long netlong, WS_u_long *hostlong ) +int WINAPI WSANtohl( SOCKET s, u_long netlong, u_long *hostlong ) { if (!hostlong) return WSAEFAULT;
@@ -1847,7 +1828,7 @@ int WINAPI WSANtohl( SOCKET s, WS_u_long netlong, WS_u_long *hostlong ) /*********************************************************************** * WSANtohs (ws2_32.@) */ -int WINAPI WSANtohs( SOCKET s, WS_u_short netshort, WS_u_short *hostshort ) +int WINAPI WSANtohs( SOCKET s, u_short netshort, u_short *hostshort ) { if (!hostshort) return WSAEFAULT;
diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c index 3947ed22689..933aff9a99c 100644 --- a/dlls/ws2_32/socket.c +++ b/dlls/ws2_32/socket.c @@ -28,16 +28,6 @@
#include "ws2_32_private.h"
-static inline unsigned short ntohs( unsigned short netshort ) -{ - return RtlUshortByteSwap( netshort ); -} - -static inline unsigned int ntohl( unsigned int netlong ) -{ - return RtlUlongByteSwap( netlong ); -} - #define FILE_USE_FILE_POINTER_POSITION ((LONGLONG)-2)
WINE_DEFAULT_DEBUG_CHANNEL(winsock); @@ -55,11 +45,11 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .dwCatalogEntryId = 1001, .ProtocolChain.ChainLen = 1, .iVersion = 2, - .iAddressFamily = WS_AF_INET, - .iMaxSockAddr = sizeof(struct WS_sockaddr_in), - .iMinSockAddr = sizeof(struct WS_sockaddr_in), - .iSocketType = WS_SOCK_STREAM, - .iProtocol = WS_IPPROTO_TCP, + .iAddressFamily = AF_INET, + .iMaxSockAddr = sizeof(struct sockaddr_in), + .iMinSockAddr = sizeof(struct sockaddr_in), + .iSocketType = SOCK_STREAM, + .iProtocol = IPPROTO_TCP, .szProtocol = L"TCP/IP", }, { @@ -70,11 +60,11 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .dwCatalogEntryId = 1002, .ProtocolChain.ChainLen = 1, .iVersion = 2, - .iAddressFamily = WS_AF_INET, - .iMaxSockAddr = sizeof(struct WS_sockaddr_in), - .iMinSockAddr = sizeof(struct WS_sockaddr_in), - .iSocketType = WS_SOCK_DGRAM, - .iProtocol = WS_IPPROTO_UDP, + .iAddressFamily = AF_INET, + .iMaxSockAddr = sizeof(struct sockaddr_in), + .iMinSockAddr = sizeof(struct sockaddr_in), + .iSocketType = SOCK_DGRAM, + .iProtocol = IPPROTO_UDP, .dwMessageSize = 0xffbb, .szProtocol = L"UDP/IP", }, @@ -86,11 +76,11 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .dwCatalogEntryId = 1004, .ProtocolChain.ChainLen = 1, .iVersion = 2, - .iAddressFamily = WS_AF_INET6, - .iMaxSockAddr = sizeof(struct WS_sockaddr_in6), - .iMinSockAddr = sizeof(struct WS_sockaddr_in6), - .iSocketType = WS_SOCK_STREAM, - .iProtocol = WS_IPPROTO_TCP, + .iAddressFamily = AF_INET6, + .iMaxSockAddr = sizeof(struct sockaddr_in6), + .iMinSockAddr = sizeof(struct sockaddr_in6), + .iSocketType = SOCK_STREAM, + .iProtocol = IPPROTO_TCP, .szProtocol = L"TCP/IPv6", }, { @@ -101,11 +91,11 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .dwCatalogEntryId = 1005, .ProtocolChain.ChainLen = 1, .iVersion = 2, - .iAddressFamily = WS_AF_INET6, - .iMaxSockAddr = sizeof(struct WS_sockaddr_in6), - .iMinSockAddr = sizeof(struct WS_sockaddr_in6), - .iSocketType = WS_SOCK_DGRAM, - .iProtocol = WS_IPPROTO_UDP, + .iAddressFamily = AF_INET6, + .iMaxSockAddr = sizeof(struct sockaddr_in6), + .iMinSockAddr = sizeof(struct sockaddr_in6), + .iSocketType = SOCK_DGRAM, + .iProtocol = IPPROTO_UDP, .dwMessageSize = 0xffbb, .szProtocol = L"UDP/IPv6", }, @@ -117,11 +107,11 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .dwCatalogEntryId = 1030, .ProtocolChain.ChainLen = 1, .iVersion = 2, - .iAddressFamily = WS_AF_IPX, - .iMaxSockAddr = sizeof(struct WS_sockaddr), - .iMinSockAddr = sizeof(struct WS_sockaddr_ipx), - .iSocketType = WS_SOCK_DGRAM, - .iProtocol = WS_NSPROTO_IPX, + .iAddressFamily = AF_IPX, + .iMaxSockAddr = sizeof(struct sockaddr), + .iMinSockAddr = sizeof(struct sockaddr_ipx), + .iSocketType = SOCK_DGRAM, + .iProtocol = NSPROTO_IPX, .iProtocolMaxOffset = 255, .dwMessageSize = 0x240, .szProtocol = L"IPX", @@ -134,11 +124,11 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .dwCatalogEntryId = 1031, .ProtocolChain.ChainLen = 1, .iVersion = 2, - .iAddressFamily = WS_AF_IPX, - .iMaxSockAddr = sizeof(struct WS_sockaddr), - .iMinSockAddr = sizeof(struct WS_sockaddr_ipx), - .iSocketType = WS_SOCK_SEQPACKET, - .iProtocol = WS_NSPROTO_SPX, + .iAddressFamily = AF_IPX, + .iMaxSockAddr = sizeof(struct sockaddr), + .iMinSockAddr = sizeof(struct sockaddr_ipx), + .iSocketType = SOCK_SEQPACKET, + .iProtocol = NSPROTO_SPX, .dwMessageSize = UINT_MAX, .szProtocol = L"SPX", }, @@ -150,11 +140,11 @@ static const WSAPROTOCOL_INFOW supported_protocols[] = .dwCatalogEntryId = 1033, .ProtocolChain.ChainLen = 1, .iVersion = 2, - .iAddressFamily = WS_AF_IPX, - .iMaxSockAddr = sizeof(struct WS_sockaddr), - .iMinSockAddr = sizeof(struct WS_sockaddr_ipx), - .iSocketType = WS_SOCK_SEQPACKET, - .iProtocol = WS_NSPROTO_SPXII, + .iAddressFamily = AF_IPX, + .iMaxSockAddr = sizeof(struct sockaddr), + .iMinSockAddr = sizeof(struct sockaddr_ipx), + .iSocketType = SOCK_SEQPACKET, + .iProtocol = NSPROTO_SPXII, .dwMessageSize = UINT_MAX, .szProtocol = L"SPX II", }, @@ -165,41 +155,41 @@ DECLARE_CRITICAL_SECTION(cs_socket_list); static SOCKET *socket_list; static unsigned int socket_list_size;
-const char *debugstr_sockaddr( const struct WS_sockaddr *a ) +const char *debugstr_sockaddr( const struct sockaddr *a ) { if (!a) return "(nil)"; switch (a->sa_family) { - case WS_AF_INET: + case AF_INET: { char buf[16]; const char *p; - struct WS_sockaddr_in *sin = (struct WS_sockaddr_in *)a; + struct sockaddr_in *sin = (struct sockaddr_in *)a;
- p = WS_inet_ntop( WS_AF_INET, &sin->sin_addr, buf, sizeof(buf) ); + p = inet_ntop( AF_INET, &sin->sin_addr, buf, sizeof(buf) ); if (!p) p = "(unknown IPv4 address)";
return wine_dbg_sprintf("{ family AF_INET, address %s, port %d }", p, ntohs(sin->sin_port)); } - case WS_AF_INET6: + case AF_INET6: { char buf[46]; const char *p; - struct WS_sockaddr_in6 *sin = (struct WS_sockaddr_in6 *)a; + struct sockaddr_in6 *sin = (struct sockaddr_in6 *)a;
- p = WS_inet_ntop( WS_AF_INET6, &sin->sin6_addr, buf, sizeof(buf) ); + p = inet_ntop( AF_INET6, &sin->sin6_addr, buf, sizeof(buf) ); if (!p) p = "(unknown IPv6 address)"; return wine_dbg_sprintf("{ family AF_INET6, address %s, flow label %#x, port %d, scope %u }", p, sin->sin6_flowinfo, ntohs(sin->sin6_port), sin->sin6_scope_id ); } - case WS_AF_IPX: + case AF_IPX: { int i; char netnum[16], nodenum[16]; - struct WS_sockaddr_ipx *sin = (struct WS_sockaddr_ipx *)a; + struct sockaddr_ipx *sin = (struct sockaddr_ipx *)a;
for (i = 0;i < 4; i++) sprintf(netnum + i * 2, "%02X", (unsigned char) sin->sa_netnum[i]); for (i = 0;i < 6; i++) sprintf(nodenum + i * 2, "%02X", (unsigned char) sin->sa_nodenum[i]); @@ -207,7 +197,7 @@ const char *debugstr_sockaddr( const struct WS_sockaddr *a ) return wine_dbg_sprintf("{ family AF_IPX, address %s.%s, ipx socket %d }", netnum, nodenum, sin->sa_socket); } - case WS_AF_IRDA: + case AF_IRDA: { DWORD addr;
@@ -231,100 +221,100 @@ static inline const char *debugstr_sockopt(int level, int optname)
switch(level) { - DEBUG_SOCKLEVEL(WS_SOL_SOCKET); + DEBUG_SOCKLEVEL(SOL_SOCKET); switch(optname) { - DEBUG_SOCKOPT(WS_SO_ACCEPTCONN); - DEBUG_SOCKOPT(WS_SO_BROADCAST); - DEBUG_SOCKOPT(WS_SO_BSP_STATE); - DEBUG_SOCKOPT(WS_SO_CONDITIONAL_ACCEPT); - DEBUG_SOCKOPT(WS_SO_CONNECT_TIME); - DEBUG_SOCKOPT(WS_SO_DEBUG); - DEBUG_SOCKOPT(WS_SO_DONTLINGER); - DEBUG_SOCKOPT(WS_SO_DONTROUTE); - DEBUG_SOCKOPT(WS_SO_ERROR); - DEBUG_SOCKOPT(WS_SO_EXCLUSIVEADDRUSE); - DEBUG_SOCKOPT(WS_SO_GROUP_ID); - DEBUG_SOCKOPT(WS_SO_GROUP_PRIORITY); - DEBUG_SOCKOPT(WS_SO_KEEPALIVE); - DEBUG_SOCKOPT(WS_SO_LINGER); - DEBUG_SOCKOPT(WS_SO_MAX_MSG_SIZE); - DEBUG_SOCKOPT(WS_SO_OOBINLINE); - DEBUG_SOCKOPT(WS_SO_OPENTYPE); - DEBUG_SOCKOPT(WS_SO_PROTOCOL_INFOA); - DEBUG_SOCKOPT(WS_SO_PROTOCOL_INFOW); - DEBUG_SOCKOPT(WS_SO_RCVBUF); - DEBUG_SOCKOPT(WS_SO_RCVTIMEO); - DEBUG_SOCKOPT(WS_SO_REUSEADDR); - DEBUG_SOCKOPT(WS_SO_SNDBUF); - DEBUG_SOCKOPT(WS_SO_SNDTIMEO); - DEBUG_SOCKOPT(WS_SO_TYPE); - DEBUG_SOCKOPT(WS_SO_UPDATE_CONNECT_CONTEXT); + DEBUG_SOCKOPT(SO_ACCEPTCONN); + DEBUG_SOCKOPT(SO_BROADCAST); + DEBUG_SOCKOPT(SO_BSP_STATE); + DEBUG_SOCKOPT(SO_CONDITIONAL_ACCEPT); + DEBUG_SOCKOPT(SO_CONNECT_TIME); + DEBUG_SOCKOPT(SO_DEBUG); + DEBUG_SOCKOPT(SO_DONTLINGER); + DEBUG_SOCKOPT(SO_DONTROUTE); + DEBUG_SOCKOPT(SO_ERROR); + DEBUG_SOCKOPT(SO_EXCLUSIVEADDRUSE); + DEBUG_SOCKOPT(SO_GROUP_ID); + DEBUG_SOCKOPT(SO_GROUP_PRIORITY); + DEBUG_SOCKOPT(SO_KEEPALIVE); + DEBUG_SOCKOPT(SO_LINGER); + DEBUG_SOCKOPT(SO_MAX_MSG_SIZE); + DEBUG_SOCKOPT(SO_OOBINLINE); + DEBUG_SOCKOPT(SO_OPENTYPE); + DEBUG_SOCKOPT(SO_PROTOCOL_INFOA); + DEBUG_SOCKOPT(SO_PROTOCOL_INFOW); + DEBUG_SOCKOPT(SO_RCVBUF); + DEBUG_SOCKOPT(SO_RCVTIMEO); + DEBUG_SOCKOPT(SO_REUSEADDR); + DEBUG_SOCKOPT(SO_SNDBUF); + DEBUG_SOCKOPT(SO_SNDTIMEO); + DEBUG_SOCKOPT(SO_TYPE); + DEBUG_SOCKOPT(SO_UPDATE_CONNECT_CONTEXT); } break;
- DEBUG_SOCKLEVEL(WS_NSPROTO_IPX); + DEBUG_SOCKLEVEL(NSPROTO_IPX); switch(optname) { - DEBUG_SOCKOPT(WS_IPX_PTYPE); - DEBUG_SOCKOPT(WS_IPX_FILTERPTYPE); - DEBUG_SOCKOPT(WS_IPX_DSTYPE); - DEBUG_SOCKOPT(WS_IPX_RECVHDR); - DEBUG_SOCKOPT(WS_IPX_MAXSIZE); - DEBUG_SOCKOPT(WS_IPX_ADDRESS); - DEBUG_SOCKOPT(WS_IPX_MAX_ADAPTER_NUM); + DEBUG_SOCKOPT(IPX_PTYPE); + DEBUG_SOCKOPT(IPX_FILTERPTYPE); + DEBUG_SOCKOPT(IPX_DSTYPE); + DEBUG_SOCKOPT(IPX_RECVHDR); + DEBUG_SOCKOPT(IPX_MAXSIZE); + DEBUG_SOCKOPT(IPX_ADDRESS); + DEBUG_SOCKOPT(IPX_MAX_ADAPTER_NUM); } break;
- DEBUG_SOCKLEVEL(WS_SOL_IRLMP); + DEBUG_SOCKLEVEL(SOL_IRLMP); switch(optname) { - DEBUG_SOCKOPT(WS_IRLMP_ENUMDEVICES); + DEBUG_SOCKOPT(IRLMP_ENUMDEVICES); } break;
- DEBUG_SOCKLEVEL(WS_IPPROTO_TCP); + DEBUG_SOCKLEVEL(IPPROTO_TCP); switch(optname) { - DEBUG_SOCKOPT(WS_TCP_BSDURGENT); - DEBUG_SOCKOPT(WS_TCP_EXPEDITED_1122); - DEBUG_SOCKOPT(WS_TCP_NODELAY); + DEBUG_SOCKOPT(TCP_BSDURGENT); + DEBUG_SOCKOPT(TCP_EXPEDITED_1122); + DEBUG_SOCKOPT(TCP_NODELAY); } break;
- DEBUG_SOCKLEVEL(WS_IPPROTO_IP); + DEBUG_SOCKLEVEL(IPPROTO_IP); switch(optname) { - DEBUG_SOCKOPT(WS_IP_ADD_MEMBERSHIP); - DEBUG_SOCKOPT(WS_IP_DONTFRAGMENT); - DEBUG_SOCKOPT(WS_IP_DROP_MEMBERSHIP); - DEBUG_SOCKOPT(WS_IP_HDRINCL); - DEBUG_SOCKOPT(WS_IP_MULTICAST_IF); - DEBUG_SOCKOPT(WS_IP_MULTICAST_LOOP); - DEBUG_SOCKOPT(WS_IP_MULTICAST_TTL); - DEBUG_SOCKOPT(WS_IP_OPTIONS); - DEBUG_SOCKOPT(WS_IP_PKTINFO); - DEBUG_SOCKOPT(WS_IP_RECEIVE_BROADCAST); - DEBUG_SOCKOPT(WS_IP_TOS); - DEBUG_SOCKOPT(WS_IP_TTL); - DEBUG_SOCKOPT(WS_IP_UNICAST_IF); + DEBUG_SOCKOPT(IP_ADD_MEMBERSHIP); + DEBUG_SOCKOPT(IP_DONTFRAGMENT); + DEBUG_SOCKOPT(IP_DROP_MEMBERSHIP); + DEBUG_SOCKOPT(IP_HDRINCL); + DEBUG_SOCKOPT(IP_MULTICAST_IF); + DEBUG_SOCKOPT(IP_MULTICAST_LOOP); + DEBUG_SOCKOPT(IP_MULTICAST_TTL); + DEBUG_SOCKOPT(IP_OPTIONS); + DEBUG_SOCKOPT(IP_PKTINFO); + DEBUG_SOCKOPT(IP_RECEIVE_BROADCAST); + DEBUG_SOCKOPT(IP_TOS); + DEBUG_SOCKOPT(IP_TTL); + DEBUG_SOCKOPT(IP_UNICAST_IF); } break;
- DEBUG_SOCKLEVEL(WS_IPPROTO_IPV6); + DEBUG_SOCKLEVEL(IPPROTO_IPV6); switch(optname) { - DEBUG_SOCKOPT(WS_IPV6_ADD_MEMBERSHIP); - DEBUG_SOCKOPT(WS_IPV6_DROP_MEMBERSHIP); - DEBUG_SOCKOPT(WS_IPV6_HOPLIMIT); - DEBUG_SOCKOPT(WS_IPV6_MULTICAST_IF); - DEBUG_SOCKOPT(WS_IPV6_MULTICAST_HOPS); - DEBUG_SOCKOPT(WS_IPV6_MULTICAST_LOOP); - DEBUG_SOCKOPT(WS_IPV6_PKTINFO); - DEBUG_SOCKOPT(WS_IPV6_UNICAST_HOPS); - DEBUG_SOCKOPT(WS_IPV6_V6ONLY); - DEBUG_SOCKOPT(WS_IPV6_UNICAST_IF); - DEBUG_SOCKOPT(WS_IPV6_DONTFRAG); + DEBUG_SOCKOPT(IPV6_ADD_MEMBERSHIP); + DEBUG_SOCKOPT(IPV6_DROP_MEMBERSHIP); + DEBUG_SOCKOPT(IPV6_HOPLIMIT); + DEBUG_SOCKOPT(IPV6_MULTICAST_IF); + DEBUG_SOCKOPT(IPV6_MULTICAST_HOPS); + DEBUG_SOCKOPT(IPV6_MULTICAST_LOOP); + DEBUG_SOCKOPT(IPV6_PKTINFO); + DEBUG_SOCKOPT(IPV6_UNICAST_HOPS); + DEBUG_SOCKOPT(IPV6_V6ONLY); + DEBUG_SOCKOPT(IPV6_UNICAST_IF); + DEBUG_SOCKOPT(IPV6_DONTFRAG); } break; } @@ -332,11 +322,11 @@ static inline const char *debugstr_sockopt(int level, int optname) #undef DEBUG_SOCKOPT
if (!strlevel) - strlevel = wine_dbg_sprintf("WS_0x%x", level); + strlevel = wine_dbg_sprintf("0x%x", level); if (!stropt) - stropt = wine_dbg_sprintf("WS_0x%x", optname); + stropt = wine_dbg_sprintf("0x%x", optname);
- return wine_dbg_sprintf("level %s, name %s", strlevel + 3, stropt + 3); + return wine_dbg_sprintf("level %s, name %s", strlevel, stropt); }
static inline const char *debugstr_optval(const char *optval, int optlenval) @@ -420,8 +410,8 @@ static BOOL socket_list_remove( SOCKET socket ) return FALSE; }
-#define WS_MAX_SOCKETS_PER_PROCESS 128 /* reasonable guess */ -#define WS_MAX_UDP_DATAGRAM 1024 +#define MAX_SOCKETS_PER_PROCESS 128 /* reasonable guess */ +#define MAX_UDP_DATAGRAM 1024 static INT WINAPI WSA_DefaultBlockingHook( FARPROC x );
int num_startup; @@ -589,8 +579,8 @@ int WINAPI WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) lpWSAData->wHighVersion = 0x0202; strcpy(lpWSAData->szDescription, "WinSock 2.0" ); strcpy(lpWSAData->szSystemStatus, "Running" ); - lpWSAData->iMaxSockets = WS_MAX_SOCKETS_PER_PROCESS; - lpWSAData->iMaxUdpDg = WS_MAX_UDP_DATAGRAM; + lpWSAData->iMaxSockets = MAX_SOCKETS_PER_PROCESS; + lpWSAData->iMaxUdpDg = MAX_UDP_DATAGRAM; /* don't do anything with lpWSAData->lpVendorInfo */ /* (some apps don't allocate the space for this field) */
@@ -637,7 +627,6 @@ void WINAPI WSASetLastError(INT iError) { SetLastError(iError); }
- static INT WS_DuplicateSocket(BOOL unicode, SOCKET s, DWORD dwProcessId, LPWSAPROTOCOL_INFOW lpProtocolInfo) { HANDLE hProcess; @@ -725,7 +714,7 @@ static BOOL ws_protocol_info(SOCKET s, int unicode, WSAPROTOCOL_INFOW *buffer, i /*********************************************************************** * accept (WS2_32.1) */ -SOCKET WINAPI WS_accept( SOCKET s, struct WS_sockaddr *addr, int *len ) +SOCKET WINAPI accept( SOCKET s, struct sockaddr *addr, int *len ) { IO_STATUS_BLOCK io; NTSTATUS status; @@ -757,9 +746,9 @@ SOCKET WINAPI WS_accept( SOCKET s, struct WS_sockaddr *addr, int *len ) CloseHandle( SOCKET2HANDLE(ret) ); return INVALID_SOCKET; } - if (addr && len && WS_getpeername( ret, addr, len )) + if (addr && len && getpeername( ret, addr, len )) { - WS_closesocket( ret ); + closesocket( ret ); return INVALID_SOCKET; }
@@ -867,9 +856,9 @@ static BOOL WINAPI WS2_TransmitFile( SOCKET s, HANDLE file, DWORD file_len, DWOR /*********************************************************************** * GetAcceptExSockaddrs */ -static void WINAPI WS2_GetAcceptExSockaddrs(PVOID buffer, DWORD data_size, DWORD local_size, DWORD remote_size, - struct WS_sockaddr **local_addr, LPINT local_addr_len, - struct WS_sockaddr **remote_addr, LPINT remote_addr_len) +static void WINAPI WS2_GetAcceptExSockaddrs( void *buffer, DWORD data_size, DWORD local_size, DWORD remote_size, + struct sockaddr **local_addr, LPINT local_addr_len, + struct sockaddr **remote_addr, LPINT remote_addr_len ) { char *cbuf = buffer; TRACE("(%p, %d, %d, %d, %p, %p, %p, %p)\n", buffer, data_size, local_size, remote_size, local_addr, @@ -877,12 +866,12 @@ static void WINAPI WS2_GetAcceptExSockaddrs(PVOID buffer, DWORD data_size, DWORD cbuf += data_size;
*local_addr_len = *(int *) cbuf; - *local_addr = (struct WS_sockaddr *)(cbuf + sizeof(int)); + *local_addr = (struct sockaddr *)(cbuf + sizeof(int));
cbuf += local_size;
*remote_addr_len = *(int *) cbuf; - *remote_addr = (struct WS_sockaddr *)(cbuf + sizeof(int)); + *remote_addr = (struct sockaddr *)(cbuf + sizeof(int)); }
@@ -893,7 +882,7 @@ static void WINAPI socket_apc( void *apc_user, IO_STATUS_BLOCK *io, ULONG reserv }
static int WS2_recv_base( SOCKET s, WSABUF *buffers, DWORD buffer_count, DWORD *ret_size, DWORD *flags, - struct WS_sockaddr *addr, int *addr_len, OVERLAPPED *overlapped, + struct sockaddr *addr, int *addr_len, OVERLAPPED *overlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE completion, WSABUF *control ) { IO_STATUS_BLOCK iosb, *piosb = &iosb; @@ -948,7 +937,7 @@ static int WS2_recv_base( SOCKET s, WSABUF *buffers, DWORD buffer_count, DWORD * }
static int WS2_sendto( SOCKET s, WSABUF *buffers, DWORD buffer_count, DWORD *ret_size, DWORD flags, - const struct WS_sockaddr *addr, int addr_len, OVERLAPPED *overlapped, + const struct sockaddr *addr, int addr_len, OVERLAPPED *overlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE completion ) { IO_STATUS_BLOCK iosb, *piosb = &iosb; @@ -1059,10 +1048,10 @@ static int WINAPI WS2_WSARecvMsg( SOCKET s, LPWSAMSG msg, LPDWORD lpNumberOfByte /*********************************************************************** * bind (ws2_32.2) */ -int WINAPI WS_bind( SOCKET s, const struct WS_sockaddr *addr, int len ) +int WINAPI bind( SOCKET s, const struct sockaddr *addr, int len ) { struct afd_bind_params *params; - struct WS_sockaddr *ret_addr; + struct sockaddr *ret_addr; IO_STATUS_BLOCK io; HANDLE sync_event; NTSTATUS status; @@ -1077,31 +1066,31 @@ int WINAPI WS_bind( SOCKET s, const struct WS_sockaddr *addr, int len )
switch (addr->sa_family) { - case WS_AF_INET: - if (len < sizeof(struct WS_sockaddr_in)) + case AF_INET: + if (len < sizeof(struct sockaddr_in)) { SetLastError( WSAEFAULT ); return -1; } break;
- case WS_AF_INET6: - if (len < sizeof(struct WS_sockaddr_in6)) + case AF_INET6: + if (len < sizeof(struct sockaddr_in6)) { SetLastError( WSAEFAULT ); return -1; } break;
- case WS_AF_IPX: - if (len < sizeof(struct WS_sockaddr_ipx)) + case AF_IPX: + if (len < sizeof(struct sockaddr_ipx)) { SetLastError( WSAEFAULT ); return -1; } break;
- case WS_AF_IRDA: + case AF_IRDA: if (len < sizeof(SOCKADDR_IRDA)) { SetLastError( WSAEFAULT ); @@ -1149,7 +1138,7 @@ int WINAPI WS_bind( SOCKET s, const struct WS_sockaddr *addr, int len ) /*********************************************************************** * closesocket (ws2_32.3) */ -int WINAPI WS_closesocket( SOCKET s ) +int WINAPI closesocket( SOCKET s ) { TRACE( "%#lx\n", s );
@@ -1173,7 +1162,7 @@ int WINAPI WS_closesocket( SOCKET s ) /*********************************************************************** * connect (ws2_32.4) */ -int WINAPI WS_connect( SOCKET s, const struct WS_sockaddr *addr, int len ) +int WINAPI connect( SOCKET s, const struct sockaddr *addr, int len ) { struct afd_connect_params *params; IO_STATUS_BLOCK io; @@ -1214,17 +1203,17 @@ int WINAPI WS_connect( SOCKET s, const struct WS_sockaddr *addr, int len ) /*********************************************************************** * WSAConnect (WS2_32.30) */ -int WINAPI WSAConnect( SOCKET s, const struct WS_sockaddr* name, int namelen, +int WINAPI WSAConnect( SOCKET s, const struct sockaddr *name, int namelen, LPWSABUF lpCallerData, LPWSABUF lpCalleeData, LPQOS lpSQOS, LPQOS lpGQOS ) { if ( lpCallerData || lpCalleeData || lpSQOS || lpGQOS ) FIXME("unsupported parameters!\n"); - return WS_connect( s, name, namelen ); + return connect( s, name, namelen ); }
-static BOOL WINAPI WS2_ConnectEx( SOCKET s, const struct WS_sockaddr *name, int namelen, +static BOOL WINAPI WS2_ConnectEx( SOCKET s, const struct sockaddr *name, int namelen, void *send_buffer, DWORD send_len, DWORD *ret_len, OVERLAPPED *overlapped ) { struct afd_connect_params *params; @@ -1297,7 +1286,7 @@ static BOOL WINAPI WS2_DisconnectEx( SOCKET s, OVERLAPPED *overlapped, DWORD fla /*********************************************************************** * getpeername (ws2_32.5) */ -int WINAPI WS_getpeername( SOCKET s, struct WS_sockaddr *addr, int *len ) +int WINAPI getpeername( SOCKET s, struct sockaddr *addr, int *len ) { IO_STATUS_BLOCK io; NTSTATUS status; @@ -1328,7 +1317,7 @@ int WINAPI WS_getpeername( SOCKET s, struct WS_sockaddr *addr, int *len ) /*********************************************************************** * getsockname (ws2_32.6) */ -int WINAPI WS_getsockname( SOCKET s, struct WS_sockaddr *addr, int *len ) +int WINAPI getsockname( SOCKET s, struct sockaddr *addr, int *len ) { IO_STATUS_BLOCK io; NTSTATUS status; @@ -1364,8 +1353,7 @@ static int server_getsockopt( SOCKET s, ULONG code, char *optval, int *optlen ) /*********************************************************************** * getsockopt (WS2_32.7) */ -INT WINAPI WS_getsockopt(SOCKET s, INT level, - INT optname, char *optval, INT *optlen) +int WINAPI getsockopt( SOCKET s, int level, int optname, char *optval, int *optlen ) { INT ret = 0;
@@ -1375,17 +1363,17 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level,
switch(level) { - case WS_SOL_SOCKET: + case SOL_SOCKET: { switch(optname) { - case WS_SO_ACCEPTCONN: + case SO_ACCEPTCONN: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_ACCEPTCONN, optval, optlen );
- case WS_SO_BROADCAST: + case SO_BROADCAST: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_BROADCAST, optval, optlen );
- case WS_SO_BSP_STATE: + case SO_BSP_STATE: { CSADDR_INFO *csinfo = (CSADDR_INFO *)optval; WSAPROTOCOL_INFOW infow; @@ -1394,10 +1382,10 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, if (!ws_protocol_info( s, TRUE, &infow, &addr_size )) return -1;
- if (infow.iAddressFamily == WS_AF_INET) - addr_size = sizeof(struct WS_sockaddr_in); - else if (infow.iAddressFamily == WS_AF_INET6) - addr_size = sizeof(struct WS_sockaddr_in6); + if (infow.iAddressFamily == AF_INET) + addr_size = sizeof(struct sockaddr_in); + else if (infow.iAddressFamily == AF_INET6) + addr_size = sizeof(struct sockaddr_in6); else { FIXME( "family %d is unsupported for SO_BSP_STATE\n", infow.iAddressFamily ); @@ -1412,18 +1400,18 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, return -1; }
- csinfo->LocalAddr.lpSockaddr = (struct WS_sockaddr *)(csinfo + 1); - csinfo->RemoteAddr.lpSockaddr = (struct WS_sockaddr *)((char *)(csinfo + 1) + addr_size); + csinfo->LocalAddr.lpSockaddr = (struct sockaddr *)(csinfo + 1); + csinfo->RemoteAddr.lpSockaddr = (struct sockaddr *)((char *)(csinfo + 1) + addr_size);
csinfo->LocalAddr.iSockaddrLength = addr_size; - if (WS_getsockname( s, csinfo->LocalAddr.lpSockaddr, &csinfo->LocalAddr.iSockaddrLength ) < 0) + if (getsockname( s, csinfo->LocalAddr.lpSockaddr, &csinfo->LocalAddr.iSockaddrLength ) < 0) { csinfo->LocalAddr.lpSockaddr = NULL; csinfo->LocalAddr.iSockaddrLength = 0; }
csinfo->RemoteAddr.iSockaddrLength = addr_size; - if (WS_getpeername( s, csinfo->RemoteAddr.lpSockaddr, &csinfo->RemoteAddr.iSockaddrLength ) < 0) + if (getpeername( s, csinfo->RemoteAddr.lpSockaddr, &csinfo->RemoteAddr.iSockaddrLength ) < 0) { csinfo->RemoteAddr.lpSockaddr = NULL; csinfo->RemoteAddr.iSockaddrLength = 0; @@ -1434,15 +1422,15 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, return 0; }
- case WS_SO_DEBUG: + case SO_DEBUG: WARN( "returning 0 for SO_DEBUG\n" ); *(DWORD *)optval = 0; SetLastError( 0 ); return 0;
- case WS_SO_DONTLINGER: + case SO_DONTLINGER: { - struct WS_linger linger; + struct linger linger; int len = sizeof(linger); int ret;
@@ -1452,7 +1440,7 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, return SOCKET_ERROR; }
- if (!(ret = WS_getsockopt( s, WS_SOL_SOCKET, WS_SO_LINGER, (char *)&linger, &len ))) + if (!(ret = getsockopt( s, SOL_SOCKET, SO_LINGER, (char *)&linger, &len ))) { *(BOOL *)optval = !linger.l_onoff; *optlen = sizeof(BOOL); @@ -1460,10 +1448,10 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, return ret; }
- case WS_SO_CONNECT_TIME: + case SO_CONNECT_TIME: { static int pretendtime = 0; - struct WS_sockaddr addr; + struct sockaddr addr; int len = sizeof(addr);
if (!optlen || *optlen < sizeof(DWORD) || !optval) @@ -1471,11 +1459,11 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, SetLastError(WSAEFAULT); return SOCKET_ERROR; } - if (WS_getpeername(s, &addr, &len) == SOCKET_ERROR) + if (getpeername(s, &addr, &len) == SOCKET_ERROR) *(DWORD *)optval = ~0u; else { - if (!pretendtime) FIXME("WS_SO_CONNECT_TIME - faking results\n"); + if (!pretendtime) FIXME("SO_CONNECT_TIME - faking results\n"); *(DWORD *)optval = pretendtime++; } *optlen = sizeof(DWORD); @@ -1483,7 +1471,7 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, } /* As mentioned in setsockopt, Windows ignores this, so we * always return true here */ - case WS_SO_DONTROUTE: + case SO_DONTROUTE: if (!optlen || *optlen < sizeof(BOOL) || !optval) { SetLastError(WSAEFAULT); @@ -1493,13 +1481,13 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, *optlen = sizeof(BOOL); return 0;
- case WS_SO_ERROR: + case SO_ERROR: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_ERROR, optval, optlen );
- case WS_SO_KEEPALIVE: + case SO_KEEPALIVE: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_KEEPALIVE, optval, optlen );
- case WS_SO_LINGER: + case SO_LINGER: { WSAPROTOCOL_INFOW info; int size; @@ -1514,7 +1502,7 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, if (!ws_protocol_info( s, TRUE, &info, &size )) return -1;
- if (info.iSocketType == WS_SOCK_DGRAM) + if (info.iSocketType == SOCK_DGRAM) { SetLastError( WSAENOPROTOOPT ); return -1; @@ -1523,7 +1511,7 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_LINGER, optval, optlen ); }
- case WS_SO_MAX_MSG_SIZE: + case SO_MAX_MSG_SIZE: if (!optlen || *optlen < sizeof(int) || !optval) { SetLastError(WSAEFAULT); @@ -1534,11 +1522,11 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, *optlen = sizeof(int); return 0;
- case WS_SO_OOBINLINE: + case SO_OOBINLINE: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_OOBINLINE, optval, optlen );
/* SO_OPENTYPE does not require a valid socket handle. */ - case WS_SO_OPENTYPE: + case SO_OPENTYPE: if (!optlen || *optlen < sizeof(int) || !optval) { SetLastError(WSAEFAULT); @@ -1548,13 +1536,14 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, *optlen = sizeof(int); TRACE("getting global SO_OPENTYPE = 0x%x\n", *((int*)optval) ); return 0; - case WS_SO_PROTOCOL_INFOA: - case WS_SO_PROTOCOL_INFOW: + + case SO_PROTOCOL_INFOA: + case SO_PROTOCOL_INFOW: { int size; WSAPROTOCOL_INFOW infow;
- ret = ws_protocol_info(s, optname == WS_SO_PROTOCOL_INFOW, &infow, &size); + ret = ws_protocol_info(s, optname == SO_PROTOCOL_INFOW, &infow, &size); if (ret) { if (!optlen || !optval || *optlen < size) @@ -1569,22 +1558,22 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, return ret ? 0 : SOCKET_ERROR; }
- case WS_SO_RCVBUF: + case SO_RCVBUF: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_RCVBUF, optval, optlen );
- case WS_SO_RCVTIMEO: + case SO_RCVTIMEO: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_RCVTIMEO, optval, optlen );
- case WS_SO_REUSEADDR: + case SO_REUSEADDR: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_REUSEADDR, optval, optlen );
- case WS_SO_SNDBUF: + case SO_SNDBUF: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_SNDBUF, optval, optlen );
- case WS_SO_SNDTIMEO: + case SO_SNDTIMEO: return server_getsockopt( s, IOCTL_AFD_WINE_GET_SO_SNDTIMEO, optval, optlen );
- case WS_SO_TYPE: + case SO_TYPE: { WSAPROTOCOL_INFOW info; int size; @@ -1607,16 +1596,16 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, SetLastError(WSAENOPROTOOPT); return SOCKET_ERROR; } /* end switch(optname) */ - }/* end case WS_SOL_SOCKET */ + }/* end case SOL_SOCKET */
- case WS_NSPROTO_IPX: + case NSPROTO_IPX: { - struct WS_sockaddr_ipx addr; + struct sockaddr_ipx addr; IPX_ADDRESS_DATA *data; int namelen; switch(optname) { - case WS_IPX_ADDRESS: + case IPX_ADDRESS: /* * On a Win2000 system with one network card there are usually * three ipx devices one with a speed of 28.8kbps, 10Mbps and 100Mbps. @@ -1626,9 +1615,9 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, * query things like the linkspeed. */ FIXME("IPX_ADDRESS\n"); - namelen = sizeof(struct WS_sockaddr_ipx); - memset(&addr, 0, sizeof(struct WS_sockaddr_ipx)); - WS_getsockname(s, (struct WS_sockaddr*)&addr, &namelen); + namelen = sizeof(struct sockaddr_ipx); + memset( &addr, 0, sizeof(struct sockaddr_ipx) ); + getsockname( s, (struct sockaddr *)&addr, &namelen );
data = (IPX_ADDRESS_DATA*)optval; memcpy(data->nodenum,addr.sa_nodenum,sizeof(data->nodenum)); @@ -1641,37 +1630,37 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, * note 1MB = 1000kB in this case */ return 0;
- case WS_IPX_MAX_ADAPTER_NUM: + case IPX_MAX_ADAPTER_NUM: FIXME("IPX_MAX_ADAPTER_NUM\n"); *(int*)optval = 1; /* As noted under IPX_ADDRESS we have just one card. */ return 0;
- case WS_IPX_PTYPE: + case IPX_PTYPE: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPX_PTYPE, optval, optlen );
default: FIXME("IPX optname:%x\n", optname); return SOCKET_ERROR; }/* end switch(optname) */ - } /* end case WS_NSPROTO_IPX */ + } /* end case NSPROTO_IPX */
- case WS_SOL_IRLMP: + case SOL_IRLMP: switch(optname) { - case WS_IRLMP_ENUMDEVICES: + case IRLMP_ENUMDEVICES: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IRLMP_ENUMDEVICES, optval, optlen );
default: FIXME("IrDA optname:0x%x\n", optname); return SOCKET_ERROR; } - break; /* case WS_SOL_IRLMP */ + break; /* case SOL_IRLMP */
- /* Levels WS_IPPROTO_TCP and WS_IPPROTO_IP convert directly */ - case WS_IPPROTO_TCP: + /* Levels IPPROTO_TCP and IPPROTO_IP convert directly */ + case IPPROTO_TCP: switch(optname) { - case WS_TCP_NODELAY: + case TCP_NODELAY: return server_getsockopt( s, IOCTL_AFD_WINE_GET_TCP_NODELAY, optval, optlen );
default: @@ -1680,85 +1669,85 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level, return -1; }
- case WS_IPPROTO_IP: + case IPPROTO_IP: switch(optname) { - case WS_IP_DONTFRAGMENT: + case IP_DONTFRAGMENT: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_DONTFRAGMENT, optval, optlen );
- case WS_IP_HDRINCL: + case IP_HDRINCL: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_HDRINCL, optval, optlen );
- case WS_IP_MULTICAST_IF: + case IP_MULTICAST_IF: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_MULTICAST_IF, optval, optlen );
- case WS_IP_MULTICAST_LOOP: + case IP_MULTICAST_LOOP: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_MULTICAST_LOOP, optval, optlen );
- case WS_IP_MULTICAST_TTL: + case IP_MULTICAST_TTL: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_MULTICAST_TTL, optval, optlen );
- case WS_IP_OPTIONS: + case IP_OPTIONS: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_OPTIONS, optval, optlen );
- case WS_IP_PKTINFO: + case IP_PKTINFO: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_PKTINFO, optval, optlen );
- case WS_IP_TOS: + case IP_TOS: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_TOS, optval, optlen );
- case WS_IP_TTL: + case IP_TTL: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_TTL, optval, optlen );
- case WS_IP_UNICAST_IF: + case IP_UNICAST_IF: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IP_UNICAST_IF, optval, optlen );
default: FIXME( "unrecognized IP option %u\n", optname ); /* fall through */
- case WS_IP_ADD_MEMBERSHIP: - case WS_IP_DROP_MEMBERSHIP: + case IP_ADD_MEMBERSHIP: + case IP_DROP_MEMBERSHIP: SetLastError( WSAENOPROTOOPT ); return -1; }
- case WS_IPPROTO_IPV6: + case IPPROTO_IPV6: switch(optname) { - case WS_IPV6_DONTFRAG: + case IPV6_DONTFRAG: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_DONTFRAG, optval, optlen );
- case WS_IPV6_HOPLIMIT: + case IPV6_HOPLIMIT: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_RECVHOPLIMIT, optval, optlen );
- case WS_IPV6_MULTICAST_HOPS: + case IPV6_MULTICAST_HOPS: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_MULTICAST_HOPS, optval, optlen );
- case WS_IPV6_MULTICAST_IF: + case IPV6_MULTICAST_IF: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_MULTICAST_IF, optval, optlen );
- case WS_IPV6_MULTICAST_LOOP: + case IPV6_MULTICAST_LOOP: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_MULTICAST_LOOP, optval, optlen );
- case WS_IPV6_PKTINFO: + case IPV6_PKTINFO: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_RECVPKTINFO, optval, optlen );
- case WS_IPV6_UNICAST_HOPS: + case IPV6_UNICAST_HOPS: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_UNICAST_HOPS, optval, optlen );
- case WS_IPV6_UNICAST_IF: + case IPV6_UNICAST_IF: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_UNICAST_IF, optval, optlen );
- case WS_IPV6_V6ONLY: + case IPV6_V6ONLY: return server_getsockopt( s, IOCTL_AFD_WINE_GET_IPV6_V6ONLY, optval, optlen );
default: FIXME( "unrecognized IPv6 option %u\n", optname ); /* fall through */
- case WS_IPV6_ADD_MEMBERSHIP: - case WS_IPV6_DROP_MEMBERSHIP: + case IPV6_ADD_MEMBERSHIP: + case IPV6_DROP_MEMBERSHIP: SetLastError( WSAENOPROTOOPT ); return -1; } @@ -1773,87 +1762,84 @@ INT WINAPI WS_getsockopt(SOCKET s, INT level,
static const char *debugstr_wsaioctl(DWORD code) { - const char *name = NULL, *buf_type, *family; + const char *buf_type, *family;
-#define IOCTL_NAME(x) case x: name = #x; break +#define IOCTL_NAME(x) case x: return #x switch (code) { - IOCTL_NAME(WS_FIONBIO); - IOCTL_NAME(WS_FIONREAD); - IOCTL_NAME(WS_SIOCATMARK); - /* IOCTL_NAME(WS_SIO_ACQUIRE_PORT_RESERVATION); */ - IOCTL_NAME(WS_SIO_ADDRESS_LIST_CHANGE); - IOCTL_NAME(WS_SIO_ADDRESS_LIST_QUERY); - IOCTL_NAME(WS_SIO_ASSOCIATE_HANDLE); - /* IOCTL_NAME(WS_SIO_ASSOCIATE_PORT_RESERVATION); - IOCTL_NAME(WS_SIO_BASE_HANDLE); - IOCTL_NAME(WS_SIO_BSP_HANDLE); - IOCTL_NAME(WS_SIO_BSP_HANDLE_SELECT); - IOCTL_NAME(WS_SIO_BSP_HANDLE_POLL); - IOCTL_NAME(WS_SIO_CHK_QOS); */ - IOCTL_NAME(WS_SIO_ENABLE_CIRCULAR_QUEUEING); - IOCTL_NAME(WS_SIO_FIND_ROUTE); - IOCTL_NAME(WS_SIO_FLUSH); - IOCTL_NAME(WS_SIO_GET_BROADCAST_ADDRESS); - IOCTL_NAME(WS_SIO_GET_EXTENSION_FUNCTION_POINTER); - IOCTL_NAME(WS_SIO_GET_GROUP_QOS); - IOCTL_NAME(WS_SIO_GET_INTERFACE_LIST); - /* IOCTL_NAME(WS_SIO_GET_INTERFACE_LIST_EX); */ - IOCTL_NAME(WS_SIO_GET_QOS); - IOCTL_NAME(WS_SIO_IDEAL_SEND_BACKLOG_CHANGE); - IOCTL_NAME(WS_SIO_IDEAL_SEND_BACKLOG_QUERY); - IOCTL_NAME(WS_SIO_KEEPALIVE_VALS); - IOCTL_NAME(WS_SIO_MULTIPOINT_LOOPBACK); - IOCTL_NAME(WS_SIO_MULTICAST_SCOPE); - /* IOCTL_NAME(WS_SIO_QUERY_RSS_SCALABILITY_INFO); - IOCTL_NAME(WS_SIO_QUERY_WFP_ALE_ENDPOINT_HANDLE); */ - IOCTL_NAME(WS_SIO_RCVALL); - IOCTL_NAME(WS_SIO_RCVALL_IGMPMCAST); - IOCTL_NAME(WS_SIO_RCVALL_MCAST); - /* IOCTL_NAME(WS_SIO_RELEASE_PORT_RESERVATION); */ - IOCTL_NAME(WS_SIO_ROUTING_INTERFACE_CHANGE); - IOCTL_NAME(WS_SIO_ROUTING_INTERFACE_QUERY); - IOCTL_NAME(WS_SIO_SET_COMPATIBILITY_MODE); - IOCTL_NAME(WS_SIO_SET_GROUP_QOS); - IOCTL_NAME(WS_SIO_SET_QOS); - IOCTL_NAME(WS_SIO_TRANSLATE_HANDLE); - IOCTL_NAME(WS_SIO_UDP_CONNRESET); + IOCTL_NAME(FIONBIO); + IOCTL_NAME(FIONREAD); + IOCTL_NAME(SIOCATMARK); + /* IOCTL_NAME(SIO_ACQUIRE_PORT_RESERVATION); */ + IOCTL_NAME(SIO_ADDRESS_LIST_CHANGE); + IOCTL_NAME(SIO_ADDRESS_LIST_QUERY); + IOCTL_NAME(SIO_ASSOCIATE_HANDLE); + /* IOCTL_NAME(SIO_ASSOCIATE_PORT_RESERVATION); + IOCTL_NAME(SIO_BASE_HANDLE); + IOCTL_NAME(SIO_BSP_HANDLE); + IOCTL_NAME(SIO_BSP_HANDLE_SELECT); + IOCTL_NAME(SIO_BSP_HANDLE_POLL); + IOCTL_NAME(SIO_CHK_QOS); */ + IOCTL_NAME(SIO_ENABLE_CIRCULAR_QUEUEING); + IOCTL_NAME(SIO_FIND_ROUTE); + IOCTL_NAME(SIO_FLUSH); + IOCTL_NAME(SIO_GET_BROADCAST_ADDRESS); + IOCTL_NAME(SIO_GET_EXTENSION_FUNCTION_POINTER); + IOCTL_NAME(SIO_GET_GROUP_QOS); + IOCTL_NAME(SIO_GET_INTERFACE_LIST); + /* IOCTL_NAME(SIO_GET_INTERFACE_LIST_EX); */ + IOCTL_NAME(SIO_GET_QOS); + IOCTL_NAME(SIO_IDEAL_SEND_BACKLOG_CHANGE); + IOCTL_NAME(SIO_IDEAL_SEND_BACKLOG_QUERY); + IOCTL_NAME(SIO_KEEPALIVE_VALS); + IOCTL_NAME(SIO_MULTIPOINT_LOOPBACK); + IOCTL_NAME(SIO_MULTICAST_SCOPE); + /* IOCTL_NAME(SIO_QUERY_RSS_SCALABILITY_INFO); + IOCTL_NAME(SIO_QUERY_WFP_ALE_ENDPOINT_HANDLE); */ + IOCTL_NAME(SIO_RCVALL); + IOCTL_NAME(SIO_RCVALL_IGMPMCAST); + IOCTL_NAME(SIO_RCVALL_MCAST); + /* IOCTL_NAME(SIO_RELEASE_PORT_RESERVATION); */ + IOCTL_NAME(SIO_ROUTING_INTERFACE_CHANGE); + IOCTL_NAME(SIO_ROUTING_INTERFACE_QUERY); + IOCTL_NAME(SIO_SET_COMPATIBILITY_MODE); + IOCTL_NAME(SIO_SET_GROUP_QOS); + IOCTL_NAME(SIO_SET_QOS); + IOCTL_NAME(SIO_TRANSLATE_HANDLE); + IOCTL_NAME(SIO_UDP_CONNRESET); } #undef IOCTL_NAME
- if (name) - return name + 3; - /* If this is not a known code split its bits */ switch(code & 0x18000000) { - case WS_IOC_WS2: + case IOC_WS2: family = "IOC_WS2"; break; - case WS_IOC_PROTOCOL: + case IOC_PROTOCOL: family = "IOC_PROTOCOL"; break; - case WS_IOC_VENDOR: + case IOC_VENDOR: family = "IOC_VENDOR"; break; - default: /* WS_IOC_UNIX */ + default: /* IOC_UNIX */ { - BYTE size = (code >> 16) & WS_IOCPARM_MASK; + BYTE size = (code >> 16) & IOCPARM_MASK; char x = (code & 0xff00) >> 8; BYTE y = code & 0xff; char args[14];
- switch (code & (WS_IOC_VOID|WS_IOC_INOUT)) + switch (code & (IOC_VOID | IOC_INOUT)) { - case WS_IOC_VOID: + case IOC_VOID: buf_type = "_IO"; sprintf(args, "%d, %d", x, y); break; - case WS_IOC_IN: + case IOC_IN: buf_type = "_IOW"; sprintf(args, "'%c', %d, %d", x, y, size); break; - case WS_IOC_OUT: + case IOC_OUT: buf_type = "_IOR"; sprintf(args, "'%c', %d, %d", x, y, size); break; @@ -1866,19 +1852,19 @@ static const char *debugstr_wsaioctl(DWORD code) } }
- /* We are different from WS_IOC_UNIX. */ - switch (code & (WS_IOC_VOID|WS_IOC_INOUT)) + /* We are different from IOC_UNIX. */ + switch (code & (IOC_VOID | IOC_INOUT)) { - case WS_IOC_VOID: + case IOC_VOID: buf_type = "_WSAIO"; break; - case WS_IOC_INOUT: + case IOC_INOUT: buf_type = "_WSAIORW"; break; - case WS_IOC_IN: + case IOC_IN: buf_type = "_WSAIOW"; break; - case WS_IOC_OUT: + case IOC_OUT: buf_type = "_WSAIOR"; break; default: @@ -1960,7 +1946,7 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID
switch (code) { - case WS_FIONBIO: + case FIONBIO: { DWORD ret;
@@ -1978,29 +1964,29 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID return ret ? -1 : 0; }
- case WS_FIONREAD: + case FIONREAD: { DWORD ret;
ret = server_ioctl_sock( s, IOCTL_AFD_WINE_FIONREAD, in_buff, in_size, out_buff, out_size, ret_size, overlapped, completion ); SetLastError( ret ); - if (!ret) *ret_size = sizeof(WS_u_long); + if (!ret) *ret_size = sizeof(u_long); return ret ? -1 : 0; }
- case WS_SIOCATMARK: + case SIOCATMARK: { DWORD ret;
ret = server_ioctl_sock( s, IOCTL_AFD_WINE_SIOCATMARK, in_buff, in_size, out_buff, out_size, ret_size, overlapped, completion ); SetLastError( ret ); - if (!ret) *ret_size = sizeof(WS_u_long); + if (!ret) *ret_size = sizeof(u_long); return ret ? -1 : 0; }
- case WS_SIO_GET_INTERFACE_LIST: + case SIO_GET_INTERFACE_LIST: { DWORD ret;
@@ -2011,7 +1997,7 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID return ret ? -1 : 0; }
- case WS_SIO_ADDRESS_LIST_QUERY: + case SIO_ADDRESS_LIST_QUERY: { DWORD size, total;
@@ -2066,9 +2052,9 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID sa[i].lpSockaddr = (SOCKADDR *)&sockaddr[i]; sa[i].iSockaddrLength = sizeof(SOCKADDR);
- sockaddr[i].sin_family = WS_AF_INET; + sockaddr[i].sin_family = AF_INET; sockaddr[i].sin_port = 0; - sockaddr[i].sin_addr.WS_s_addr = WS_inet_addr(p->IpAddressList.IpAddress.String); + sockaddr[i].sin_addr.s_addr = inet_addr( p->IpAddressList.IpAddress.String ); i++; }
@@ -2088,7 +2074,7 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID } }
- case WS_SIO_GET_EXTENSION_FUNCTION_POINTER: + case SIO_GET_EXTENSION_FUNCTION_POINTER: { #define EXTENSION_FUNCTION(x, y) { x, y, #y }, static const struct @@ -2132,7 +2118,7 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID return -1; }
- case WS_SIO_KEEPALIVE_VALS: + case SIO_KEEPALIVE_VALS: { DWORD ret;
@@ -2143,25 +2129,23 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID return ret ? -1 : 0; }
- case WS_SIO_ROUTING_INTERFACE_QUERY: + case SIO_ROUTING_INTERFACE_QUERY: { - struct WS_sockaddr *daddr = (struct WS_sockaddr *)in_buff; - struct WS_sockaddr_in *daddr_in = (struct WS_sockaddr_in *)daddr; - struct WS_sockaddr_in *saddr_in = out_buff; + struct sockaddr *daddr = (struct sockaddr *)in_buff; + struct sockaddr_in *daddr_in = (struct sockaddr_in *)daddr; + struct sockaddr_in *saddr_in = out_buff; MIB_IPFORWARDROW row; PMIB_IPADDRTABLE ipAddrTable = NULL; DWORD size, i, found_index, ret = 0; NTSTATUS status = STATUS_SUCCESS;
- TRACE( "-> WS_SIO_ROUTING_INTERFACE_QUERY request\n" ); - - if (!in_buff || in_size < sizeof(struct WS_sockaddr) || - !out_buff || out_size < sizeof(struct WS_sockaddr_in)) + if (!in_buff || in_size < sizeof(struct sockaddr) || + !out_buff || out_size < sizeof(struct sockaddr_in)) { SetLastError( WSAEFAULT ); return -1; } - if (daddr->sa_family != WS_AF_INET) + if (daddr->sa_family != AF_INET) { FIXME("unsupported address family %d\n", daddr->sa_family); SetLastError( WSAEAFNOSUPPORT ); @@ -2194,19 +2178,19 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID SetLastError( WSAEFAULT ); return -1; } - saddr_in->sin_family = WS_AF_INET; + saddr_in->sin_family = AF_INET; saddr_in->sin_addr.S_un.S_addr = ipAddrTable->table[found_index].dwAddr; saddr_in->sin_port = 0; HeapFree( GetProcessHeap(), 0, ipAddrTable );
ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status), NULL, 0, ret_size, overlapped, completion ); - if (!ret) *ret_size = sizeof(struct WS_sockaddr_in); + if (!ret) *ret_size = sizeof(struct sockaddr_in); SetLastError( ret ); return ret ? -1 : 0; }
- case WS_SIO_ADDRESS_LIST_CHANGE: + case SIO_ADDRESS_LIST_CHANGE: { int force_async = !!overlapped; DWORD ret; @@ -2217,19 +2201,19 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID return ret ? -1 : 0; }
- case WS_SIO_UDP_CONNRESET: + case SIO_UDP_CONNRESET: { NTSTATUS status = STATUS_SUCCESS; DWORD ret;
- FIXME( "WS_SIO_UDP_CONNRESET stub\n" ); + FIXME( "SIO_UDP_CONNRESET stub\n" ); ret = server_ioctl_sock( s, IOCTL_AFD_WINE_COMPLETE_ASYNC, &status, sizeof(status), NULL, 0, ret_size, overlapped, completion ); SetLastError( ret ); return ret ? -1 : 0; }
- case WS_SIO_BASE_HANDLE: + case SIO_BASE_HANDLE: { NTSTATUS status; DWORD ret; @@ -2254,8 +2238,8 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID default: FIXME( "unimplemented ioctl %s\n", debugstr_wsaioctl( code ) ); /* fall through */ - case LOWORD(WS_FIONBIO): /* Netscape tries to use this */ - case WS_SIO_SET_COMPATIBILITY_MODE: + case LOWORD(FIONBIO): /* Netscape tries to use this */ + case SIO_SET_COMPATIBILITY_MODE: { NTSTATUS status = STATUS_NOT_SUPPORTED;
@@ -2279,17 +2263,17 @@ INT WINAPI WSAIoctl(SOCKET s, DWORD code, LPVOID in_buff, DWORD in_size, LPVOID /*********************************************************************** * ioctlsocket (WS2_32.10) */ -int WINAPI WS_ioctlsocket(SOCKET s, LONG cmd, WS_u_long *argp) +int WINAPI ioctlsocket( SOCKET s, LONG cmd, u_long *argp ) { DWORD ret_size; - return WSAIoctl( s, cmd, argp, sizeof(WS_u_long), argp, sizeof(WS_u_long), &ret_size, NULL, NULL ); + return WSAIoctl( s, cmd, argp, sizeof(u_long), argp, sizeof(u_long), &ret_size, NULL, NULL ); }
/*********************************************************************** * listen (ws2_32.13) */ -int WINAPI WS_listen( SOCKET s, int backlog ) +int WINAPI listen( SOCKET s, int backlog ) { struct afd_listen_params params = {.backlog = backlog}; IO_STATUS_BLOCK io; @@ -2307,7 +2291,7 @@ int WINAPI WS_listen( SOCKET s, int backlog ) /*********************************************************************** * recv (WS2_32.16) */ -int WINAPI WS_recv(SOCKET s, char *buf, int len, int flags) +int WINAPI recv( SOCKET s, char *buf, int len, int flags ) { DWORD n, dwFlags = flags; WSABUF wsabuf; @@ -2324,8 +2308,7 @@ int WINAPI WS_recv(SOCKET s, char *buf, int len, int flags) /*********************************************************************** * recvfrom (WS2_32.17) */ -int WINAPI WS_recvfrom(SOCKET s, char *buf, INT len, int flags, - struct WS_sockaddr *from, int *fromlen) +int WINAPI recvfrom( SOCKET s, char *buf, int len, int flags, struct sockaddr *from, int *fromlen ) { DWORD n, dwFlags = flags; WSABUF wsabuf; @@ -2341,7 +2324,7 @@ int WINAPI WS_recvfrom(SOCKET s, char *buf, INT len, int flags,
/* as FD_SET(), but returns 1 if the fd was added, 0 otherwise */ -static int add_fd_to_set( SOCKET fd, struct WS_fd_set *set ) +static int add_fd_to_set( SOCKET fd, struct fd_set *set ) { unsigned int i;
@@ -2351,7 +2334,7 @@ static int add_fd_to_set( SOCKET fd, struct WS_fd_set *set ) return 0; }
- if (set->fd_count < WS_FD_SETSIZE) + if (set->fd_count < FD_SETSIZE) { set->fd_array[set->fd_count++] = fd; return 1; @@ -2364,12 +2347,12 @@ static int add_fd_to_set( SOCKET fd, struct WS_fd_set *set ) /*********************************************************************** * select (ws2_32.18) */ -int WINAPI WS_select( int count, WS_fd_set *read_ptr, WS_fd_set *write_ptr, - WS_fd_set *except_ptr, const struct WS_timeval *timeout) +int WINAPI select( int count, fd_set *read_ptr, fd_set *write_ptr, + fd_set *except_ptr, const struct timeval *timeout) { - char buffer[offsetof( struct afd_poll_params, sockets[WS_FD_SETSIZE * 3] )] = {0}; + char buffer[offsetof( struct afd_poll_params, sockets[FD_SETSIZE * 3] )] = {0}; struct afd_poll_params *params = (struct afd_poll_params *)buffer; - struct WS_fd_set read, write, except; + struct fd_set read, write, except; ULONG params_size, i, j; SOCKET poll_socket = 0; IO_STATUS_BLOCK io; @@ -2379,9 +2362,9 @@ int WINAPI WS_select( int count, WS_fd_set *read_ptr, WS_fd_set *write_ptr,
TRACE( "read %p, write %p, except %p, timeout %p\n", read_ptr, write_ptr, except_ptr, timeout );
- WS_FD_ZERO( &read ); - WS_FD_ZERO( &write ); - WS_FD_ZERO( &except ); + FD_ZERO( &read ); + FD_ZERO( &write ); + FD_ZERO( &except ); if (read_ptr) read = *read_ptr; if (write_ptr) write = *write_ptr; if (except_ptr) except = *except_ptr; @@ -2437,9 +2420,9 @@ int WINAPI WS_select( int count, WS_fd_set *read_ptr, WS_fd_set *write_ptr, if (!status) { /* pointers may alias, so clear them all first */ - if (read_ptr) WS_FD_ZERO( read_ptr ); - if (write_ptr) WS_FD_ZERO( write_ptr ); - if (except_ptr) WS_FD_ZERO( except_ptr ); + if (read_ptr) FD_ZERO( read_ptr ); + if (write_ptr) FD_ZERO( write_ptr ); + if (except_ptr) FD_ZERO( except_ptr );
for (i = 0; i < params->count; ++i) { @@ -2545,18 +2528,18 @@ int WINAPI WSAPoll( WSAPOLLFD *fds, ULONG count, int timeout )
if ((INT_PTR)fds[i].fd < 0 || !socket_list_find( fds[i].fd )) { - fds[i].revents = WS_POLLNVAL; + fds[i].revents = POLLNVAL; continue; }
poll_socket = fds[i].fd; params->sockets[params->count].socket = fds[i].fd;
- if (fds[i].events & WS_POLLRDNORM) + if (fds[i].events & POLLRDNORM) flags |= AFD_POLL_ACCEPT | AFD_POLL_READ; - if (fds[i].events & WS_POLLRDBAND) + if (fds[i].events & POLLRDBAND) flags |= AFD_POLL_OOB; - if (fds[i].events & WS_POLLWRNORM) + if (fds[i].events & POLLWRNORM) flags |= AFD_POLL_WRITE; params->sockets[params->count].flags = flags; ++params->count; @@ -2593,19 +2576,19 @@ int WINAPI WSAPoll( WSAPOLLFD *fds, ULONG count, int timeout ) unsigned int revents = 0;
if (params->sockets[j].flags & (AFD_POLL_ACCEPT | AFD_POLL_READ)) - revents |= WS_POLLRDNORM; + revents |= POLLRDNORM; if (params->sockets[j].flags & AFD_POLL_OOB) - revents |= WS_POLLRDBAND; + revents |= POLLRDBAND; if (params->sockets[j].flags & AFD_POLL_WRITE) - revents |= WS_POLLWRNORM; + revents |= POLLWRNORM; if (params->sockets[j].flags & AFD_POLL_HUP) - revents |= WS_POLLHUP; + revents |= POLLHUP; if (params->sockets[j].flags & (AFD_POLL_RESET | AFD_POLL_CONNECT_ERR)) - revents |= WS_POLLERR; + revents |= POLLERR; if (params->sockets[j].flags & AFD_POLL_CLOSE) - revents |= WS_POLLNVAL; + revents |= POLLNVAL;
- fds[i].revents = revents & (fds[i].events | WS_POLLHUP | WS_POLLERR | WS_POLLNVAL); + fds[i].revents = revents & (fds[i].events | POLLHUP | POLLERR | POLLNVAL);
if (fds[i].revents) ++ret_count; @@ -2625,7 +2608,7 @@ int WINAPI WSAPoll( WSAPOLLFD *fds, ULONG count, int timeout ) /*********************************************************************** * send (WS2_32.19) */ -int WINAPI WS_send(SOCKET s, const char *buf, int len, int flags) +int WINAPI send( SOCKET s, const char *buf, int len, int flags ) { DWORD n; WSABUF wsabuf; @@ -2656,7 +2639,7 @@ INT WINAPI WSASend( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, */ INT WINAPI WSASendDisconnect( SOCKET s, LPWSABUF lpBuffers ) { - return WS_shutdown( s, SD_SEND ); + return shutdown( s, SD_SEND ); }
@@ -2665,7 +2648,7 @@ INT WINAPI WSASendDisconnect( SOCKET s, LPWSABUF lpBuffers ) */ INT WINAPI WSASendTo( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, - const struct WS_sockaddr *to, int tolen, + const struct sockaddr *to, int tolen, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine ) { @@ -2679,8 +2662,7 @@ INT WINAPI WSASendTo( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, /*********************************************************************** * sendto (WS2_32.20) */ -int WINAPI WS_sendto(SOCKET s, const char *buf, int len, int flags, - const struct WS_sockaddr *to, int tolen) +int WINAPI sendto( SOCKET s, const char *buf, int len, int flags, const struct sockaddr *to, int tolen ) { DWORD n; WSABUF wsabuf; @@ -2709,8 +2691,7 @@ static int server_setsockopt( SOCKET s, ULONG code, const char *optval, int optl /*********************************************************************** * setsockopt (WS2_32.21) */ -int WINAPI WS_setsockopt(SOCKET s, int level, int optname, - const char *optval, int optlen) +int WINAPI setsockopt( SOCKET s, int level, int optname, const char *optval, int optlen ) { TRACE("(socket %04lx, %s, optval %s, optlen %d)\n", s, debugstr_sockopt(level, optname), debugstr_optval(optval, optlen), @@ -2725,15 +2706,15 @@ int WINAPI WS_setsockopt(SOCKET s, int level, int optname,
switch(level) { - case WS_SOL_SOCKET: + case SOL_SOCKET: switch(optname) { - case WS_SO_BROADCAST: + case SO_BROADCAST: return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_BROADCAST, optval, optlen );
- case WS_SO_DONTLINGER: + case SO_DONTLINGER: { - struct WS_linger linger; + struct linger linger;
if (!optval) { @@ -2743,69 +2724,69 @@ int WINAPI WS_setsockopt(SOCKET s, int level, int optname,
linger.l_onoff = !*(const BOOL *)optval; linger.l_linger = 0; - return WS_setsockopt( s, WS_SOL_SOCKET, WS_SO_LINGER, (char *)&linger, sizeof(linger) ); + return setsockopt( s, SOL_SOCKET, SO_LINGER, (char *)&linger, sizeof(linger) ); }
- case WS_SO_ERROR: + case SO_ERROR: FIXME( "SO_ERROR, stub!\n" ); SetLastError( WSAENOPROTOOPT ); return -1;
- case WS_SO_KEEPALIVE: + case SO_KEEPALIVE: return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_KEEPALIVE, optval, optlen );
- case WS_SO_LINGER: + case SO_LINGER: return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_LINGER, optval, optlen );
- case WS_SO_OOBINLINE: + case SO_OOBINLINE: return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_OOBINLINE, optval, optlen );
- case WS_SO_RCVBUF: + case SO_RCVBUF: return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_RCVBUF, optval, optlen );
- case WS_SO_RCVTIMEO: + case SO_RCVTIMEO: return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_RCVTIMEO, optval, optlen );
- case WS_SO_REUSEADDR: + case SO_REUSEADDR: return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_REUSEADDR, optval, optlen );
- case WS_SO_SNDBUF: + case SO_SNDBUF: return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_SNDBUF, optval, optlen );
- case WS_SO_SNDTIMEO: + case SO_SNDTIMEO: return server_setsockopt( s, IOCTL_AFD_WINE_SET_SO_SNDTIMEO, optval, optlen );
/* SO_DEBUG is a privileged operation, ignore it. */ - case WS_SO_DEBUG: + case SO_DEBUG: TRACE("Ignoring SO_DEBUG\n"); return 0;
/* For some reason the game GrandPrixLegends does set SO_DONTROUTE on its * socket. According to MSDN, this option is silently ignored.*/ - case WS_SO_DONTROUTE: + case SO_DONTROUTE: TRACE("Ignoring SO_DONTROUTE\n"); return 0;
/* Stops two sockets from being bound to the same port. Always happens * on unix systems, so just drop it. */ - case WS_SO_EXCLUSIVEADDRUSE: + case SO_EXCLUSIVEADDRUSE: TRACE("Ignoring SO_EXCLUSIVEADDRUSE, is always set.\n"); return 0;
/* After a ConnectEx call succeeds, the socket can't be used with half of the * normal winsock functions on windows. We don't have that problem. */ - case WS_SO_UPDATE_CONNECT_CONTEXT: + case SO_UPDATE_CONNECT_CONTEXT: TRACE("Ignoring SO_UPDATE_CONNECT_CONTEXT, since our sockets are normal\n"); return 0;
/* After a AcceptEx call succeeds, the socket can't be used with half of the * normal winsock functions on windows. We don't have that problem. */ - case WS_SO_UPDATE_ACCEPT_CONTEXT: + case SO_UPDATE_ACCEPT_CONTEXT: TRACE("Ignoring SO_UPDATE_ACCEPT_CONTEXT, since our sockets are normal\n"); return 0;
/* SO_OPENTYPE does not require a valid socket handle. */ - case WS_SO_OPENTYPE: + case SO_OPENTYPE: if (!optlen || optlen < sizeof(int) || !optval) { SetLastError(WSAEFAULT); @@ -2815,40 +2796,40 @@ int WINAPI WS_setsockopt(SOCKET s, int level, int optname, TRACE("setting global SO_OPENTYPE = 0x%x\n", *((const int*)optval) ); return 0;
- case WS_SO_RANDOMIZE_PORT: - FIXME("Ignoring WS_SO_RANDOMIZE_PORT\n"); + case SO_RANDOMIZE_PORT: + FIXME("Ignoring SO_RANDOMIZE_PORT\n"); return 0;
- case WS_SO_PORT_SCALABILITY: - FIXME("Ignoring WS_SO_PORT_SCALABILITY\n"); + case SO_PORT_SCALABILITY: + FIXME("Ignoring SO_PORT_SCALABILITY\n"); return 0;
- case WS_SO_REUSE_UNICASTPORT: - FIXME("Ignoring WS_SO_REUSE_UNICASTPORT\n"); + case SO_REUSE_UNICASTPORT: + FIXME("Ignoring SO_REUSE_UNICASTPORT\n"); return 0;
- case WS_SO_REUSE_MULTICASTPORT: - FIXME("Ignoring WS_SO_REUSE_MULTICASTPORT\n"); + case SO_REUSE_MULTICASTPORT: + FIXME("Ignoring SO_REUSE_MULTICASTPORT\n"); return 0;
default: TRACE("Unknown SOL_SOCKET optname: 0x%08x\n", optname); /* fall through */
- case WS_SO_ACCEPTCONN: - case WS_SO_TYPE: + case SO_ACCEPTCONN: + case SO_TYPE: SetLastError(WSAENOPROTOOPT); return SOCKET_ERROR; } - break; /* case WS_SOL_SOCKET */ + break; /* case SOL_SOCKET */
- case WS_NSPROTO_IPX: + case NSPROTO_IPX: switch(optname) { - case WS_IPX_PTYPE: + case IPX_PTYPE: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPX_PTYPE, optval, optlen );
- case WS_IPX_FILTERPTYPE: + case IPX_FILTERPTYPE: /* Sets the receive filter packet type, at the moment we don't support it */ FIXME("IPX_FILTERPTYPE: %x\n", *optval); /* Returning 0 is better for now than returning a SOCKET_ERROR */ @@ -2858,12 +2839,12 @@ int WINAPI WS_setsockopt(SOCKET s, int level, int optname, FIXME("opt_name:%x\n", optname); return SOCKET_ERROR; } - break; /* case WS_NSPROTO_IPX */ + break; /* case NSPROTO_IPX */
- case WS_IPPROTO_TCP: + case IPPROTO_TCP: switch(optname) { - case WS_TCP_NODELAY: + case TCP_NODELAY: return server_setsockopt( s, IOCTL_AFD_WINE_SET_TCP_NODELAY, optval, optlen );
default: @@ -2872,55 +2853,55 @@ int WINAPI WS_setsockopt(SOCKET s, int level, int optname, } break;
- case WS_IPPROTO_IP: + case IPPROTO_IP: switch(optname) { - case WS_IP_ADD_MEMBERSHIP: + case IP_ADD_MEMBERSHIP: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_ADD_MEMBERSHIP, optval, optlen );
- case WS_IP_ADD_SOURCE_MEMBERSHIP: + case IP_ADD_SOURCE_MEMBERSHIP: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_ADD_SOURCE_MEMBERSHIP, optval, optlen );
- case WS_IP_BLOCK_SOURCE: + case IP_BLOCK_SOURCE: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_BLOCK_SOURCE, optval, optlen );
- case WS_IP_DONTFRAGMENT: + case IP_DONTFRAGMENT: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_DONTFRAGMENT, optval, optlen );
- case WS_IP_DROP_MEMBERSHIP: + case IP_DROP_MEMBERSHIP: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_DROP_MEMBERSHIP, optval, optlen );
- case WS_IP_DROP_SOURCE_MEMBERSHIP: + case IP_DROP_SOURCE_MEMBERSHIP: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_DROP_SOURCE_MEMBERSHIP, optval, optlen );
- case WS_IP_HDRINCL: + case IP_HDRINCL: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_HDRINCL, optval, optlen );
- case WS_IP_MULTICAST_IF: + case IP_MULTICAST_IF: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_MULTICAST_IF, optval, optlen );
- case WS_IP_MULTICAST_LOOP: + case IP_MULTICAST_LOOP: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_MULTICAST_LOOP, optval, optlen );
- case WS_IP_MULTICAST_TTL: + case IP_MULTICAST_TTL: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_MULTICAST_TTL, optval, optlen );
- case WS_IP_OPTIONS: + case IP_OPTIONS: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_OPTIONS, optval, optlen );
- case WS_IP_PKTINFO: + case IP_PKTINFO: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_PKTINFO, optval, optlen );
- case WS_IP_TOS: + case IP_TOS: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_TOS, optval, optlen );
- case WS_IP_TTL: + case IP_TTL: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_TTL, optval, optlen );
- case WS_IP_UNBLOCK_SOURCE: + case IP_UNBLOCK_SOURCE: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_UNBLOCK_SOURCE, optval, optlen );
- case WS_IP_UNICAST_IF: + case IP_UNICAST_IF: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IP_UNICAST_IF, optval, optlen );
default: @@ -2929,44 +2910,44 @@ int WINAPI WS_setsockopt(SOCKET s, int level, int optname, } break;
- case WS_IPPROTO_IPV6: + case IPPROTO_IPV6: switch(optname) { - case WS_IPV6_ADD_MEMBERSHIP: + case IPV6_ADD_MEMBERSHIP: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_ADD_MEMBERSHIP, optval, optlen );
- case WS_IPV6_DONTFRAG: + case IPV6_DONTFRAG: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_DONTFRAG, optval, optlen );
- case WS_IPV6_DROP_MEMBERSHIP: + case IPV6_DROP_MEMBERSHIP: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_DROP_MEMBERSHIP, optval, optlen );
- case WS_IPV6_HOPLIMIT: + case IPV6_HOPLIMIT: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_RECVHOPLIMIT, optval, optlen );
- case WS_IPV6_MULTICAST_HOPS: + case IPV6_MULTICAST_HOPS: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_MULTICAST_HOPS, optval, optlen );
- case WS_IPV6_MULTICAST_IF: + case IPV6_MULTICAST_IF: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_MULTICAST_IF, optval, optlen );
- case WS_IPV6_MULTICAST_LOOP: + case IPV6_MULTICAST_LOOP: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_MULTICAST_LOOP, optval, optlen );
- case WS_IPV6_PKTINFO: + case IPV6_PKTINFO: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_RECVPKTINFO, optval, optlen );
- case WS_IPV6_PROTECTION_LEVEL: + case IPV6_PROTECTION_LEVEL: FIXME("IPV6_PROTECTION_LEVEL is ignored!\n"); return 0;
- case WS_IPV6_UNICAST_HOPS: + case IPV6_UNICAST_HOPS: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_UNICAST_HOPS, optval, optlen );
- case WS_IPV6_UNICAST_IF: + case IPV6_UNICAST_IF: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_UNICAST_IF, optval, optlen );
- case WS_IPV6_V6ONLY: + case IPV6_V6ONLY: return server_setsockopt( s, IOCTL_AFD_WINE_SET_IPV6_V6ONLY, optval, optlen );
default: @@ -2986,7 +2967,7 @@ int WINAPI WS_setsockopt(SOCKET s, int level, int optname, /*********************************************************************** * shutdown (ws2_32.22) */ -int WINAPI WS_shutdown( SOCKET s, int how ) +int WINAPI shutdown( SOCKET s, int how ) { IO_STATUS_BLOCK io; NTSTATUS status; @@ -3003,7 +2984,7 @@ int WINAPI WS_shutdown( SOCKET s, int how ) /*********************************************************************** * socket (WS2_32.23) */ -SOCKET WINAPI WS_socket(int af, int type, int protocol) +SOCKET WINAPI socket( int af, int type, int protocol ) { TRACE("af=%d type=%d protocol=%d\n", af, type, protocol);
@@ -3329,7 +3310,7 @@ SOCKET WINAPI WSASocketW(int af, int type, int protocol, err = RtlNtStatusToDosError( status ); if (err == WSAEACCES) /* raw socket denied */ { - if (type == WS_SOCK_RAW) + if (type == SOCK_RAW) ERR_(winediag)("Failed to create a socket of type SOCK_RAW, this requires special permissions.\n"); else ERR_(winediag)("Failed to create socket, this requires special permissions.\n"); @@ -3359,15 +3340,8 @@ done: * WSAJoinLeaf (WS2_32.58) * */ -SOCKET WINAPI WSAJoinLeaf( - SOCKET s, - const struct WS_sockaddr *addr, - int addrlen, - LPWSABUF lpCallerData, - LPWSABUF lpCalleeData, - LPQOS lpSQOS, - LPQOS lpGQOS, - DWORD dwFlags) +SOCKET WINAPI WSAJoinLeaf( SOCKET s, const struct sockaddr *addr, int addrlen, WSABUF *caller_data, + WSABUF *callee_data, QOS *socket_qos, QOS *group_qos, DWORD flags) { FIXME("stub.\n"); return INVALID_SOCKET; @@ -3376,7 +3350,7 @@ SOCKET WINAPI WSAJoinLeaf( /*********************************************************************** * __WSAFDIsSet (WS2_32.151) */ -int WINAPI __WSAFDIsSet(SOCKET s, WS_fd_set *set) +int WINAPI __WSAFDIsSet( SOCKET s, fd_set *set ) { int i = set->fd_count, ret = 0;
@@ -3463,7 +3437,7 @@ int WINAPI WSARecv(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, * WSARecvFrom (WS2_32.69) */ INT WINAPI WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, - LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, struct WS_sockaddr *lpFrom, + DWORD *lpNumberOfBytesRecvd, DWORD *lpFlags, struct sockaddr *lpFrom, LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
@@ -3479,19 +3453,19 @@ INT WINAPI WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, /*********************************************************************** * WSAAccept (ws2_32.@) */ -SOCKET WINAPI WSAAccept( SOCKET s, struct WS_sockaddr *addr, int *addrlen, +SOCKET WINAPI WSAAccept( SOCKET s, struct sockaddr *addr, int *addrlen, LPCONDITIONPROC callback, DWORD_PTR context ) { int ret = 0, size; WSABUF caller_id, caller_data, callee_id, callee_data; - struct WS_sockaddr src_addr, dst_addr; + struct sockaddr src_addr, dst_addr; GROUP group; SOCKET cs;
TRACE( "socket %#lx, addr %p, addrlen %p, callback %p, context %#lx\n", s, addr, addrlen, callback, context );
- cs = WS_accept(s, addr, addrlen); + cs = accept( s, addr, addrlen ); if (cs == SOCKET_ERROR) return SOCKET_ERROR; if (!callback) return cs;
@@ -3503,7 +3477,7 @@ SOCKET WINAPI WSAAccept( SOCKET s, struct WS_sockaddr *addr, int *addrlen, else { size = sizeof(src_addr); - WS_getpeername( cs, &src_addr, &size ); + getpeername( cs, &src_addr, &size ); caller_id.buf = (char *)&src_addr; caller_id.len = size; } @@ -3511,7 +3485,7 @@ SOCKET WINAPI WSAAccept( SOCKET s, struct WS_sockaddr *addr, int *addrlen, caller_data.len = 0;
size = sizeof(dst_addr); - WS_getsockname( cs, &dst_addr, &size ); + getsockname( cs, &dst_addr, &size );
callee_id.buf = (char *)&dst_addr; callee_id.len = sizeof(dst_addr); @@ -3537,7 +3511,7 @@ SOCKET WINAPI WSAAccept( SOCKET s, struct WS_sockaddr *addr, int *addrlen, }
case CF_REJECT: - WS_closesocket( cs ); + closesocket( cs ); SetLastError( WSAECONNREFUSED ); return SOCKET_ERROR;
@@ -3583,7 +3557,7 @@ INT WINAPI WSARecvDisconnect( SOCKET s, LPWSABUF disconnectdata ) { TRACE( "(%04lx %p)\n", s, disconnectdata );
- return WS_shutdown( s, SD_RECEIVE ); + return shutdown( s, SD_RECEIVE ); }
diff --git a/dlls/ws2_32/unixlib.c b/dlls/ws2_32/unixlib.c index 240389aeeaa..19fe8697eb0 100644 --- a/dlls/ws2_32/unixlib.c +++ b/dlls/ws2_32/unixlib.c @@ -67,6 +67,7 @@ #include "windef.h" #include "winerror.h" #include "winternl.h" +#define USE_WS_PREFIX #include "winsock2.h" #include "ws2tcpip.h" #include "wsipx.h" diff --git a/dlls/ws2_32/ws2_32.spec b/dlls/ws2_32/ws2_32.spec index 29545165a48..1fbd8c55c75 100644 --- a/dlls/ws2_32/ws2_32.spec +++ b/dlls/ws2_32/ws2_32.spec @@ -1,33 +1,33 @@ -1 stdcall accept(long ptr ptr) WS_accept -2 stdcall bind(long ptr long) WS_bind -3 stdcall closesocket(long) WS_closesocket -4 stdcall connect(long ptr long) WS_connect -5 stdcall getpeername(long ptr ptr) WS_getpeername -6 stdcall getsockname(long ptr ptr) WS_getsockname -7 stdcall getsockopt(long long long ptr ptr) WS_getsockopt +1 stdcall accept(long ptr ptr) +2 stdcall bind(long ptr long) +3 stdcall closesocket(long) +4 stdcall connect(long ptr long) +5 stdcall getpeername(long ptr ptr) +6 stdcall getsockname(long ptr ptr) +7 stdcall getsockopt(long long long ptr ptr) 8 stdcall htonl(long) WS_htonl 9 stdcall htons(long) WS_htons -10 stdcall ioctlsocket(long long ptr) WS_ioctlsocket -11 stdcall inet_addr(str) WS_inet_addr -12 stdcall inet_ntoa(ptr) WS_inet_ntoa -13 stdcall listen(long long) WS_listen +10 stdcall ioctlsocket(long long ptr) +11 stdcall inet_addr(str) +12 stdcall inet_ntoa(ptr) +13 stdcall listen(long long) 14 stdcall ntohl(long) WS_ntohl 15 stdcall ntohs(long) WS_ntohs -16 stdcall recv(long ptr long long) WS_recv -17 stdcall recvfrom(long ptr long long ptr ptr) WS_recvfrom -18 stdcall select(long ptr ptr ptr ptr) WS_select -19 stdcall send(long ptr long long) WS_send -20 stdcall sendto(long ptr long long ptr long) WS_sendto -21 stdcall setsockopt(long long long ptr long) WS_setsockopt -22 stdcall shutdown(long long) WS_shutdown -23 stdcall socket(long long long) WS_socket -51 stdcall gethostbyaddr(ptr long long) WS_gethostbyaddr -52 stdcall gethostbyname(str) WS_gethostbyname -53 stdcall getprotobyname(str) WS_getprotobyname -54 stdcall getprotobynumber(long) WS_getprotobynumber -55 stdcall getservbyname(str str) WS_getservbyname -56 stdcall getservbyport(long str) WS_getservbyport -57 stdcall gethostname(ptr long) WS_gethostname +16 stdcall recv(long ptr long long) +17 stdcall recvfrom(long ptr long long ptr ptr) +18 stdcall select(long ptr ptr ptr ptr) +19 stdcall send(long ptr long long) +20 stdcall sendto(long ptr long long ptr long) +21 stdcall setsockopt(long long long ptr long) +22 stdcall shutdown(long long) +23 stdcall socket(long long long) +51 stdcall gethostbyaddr(ptr long long) +52 stdcall gethostbyname(str) +53 stdcall getprotobyname(str) +54 stdcall getprotobynumber(long) +55 stdcall getservbyname(str str) +56 stdcall getservbyport(long str) +57 stdcall gethostname(ptr long)
101 stdcall WSAAsyncSelect(long long long long) 102 stdcall WSAAsyncGetHostByAddr(long long ptr long long ptr long) @@ -128,8 +128,8 @@ @ stub WSCUpdateProvider @ stub WSCWriteNameSpaceOrder @ stdcall WSCWriteProviderOrder(ptr long) -@ stdcall freeaddrinfo(ptr) WS_freeaddrinfo -@ stdcall getaddrinfo(str str ptr ptr) WS_getaddrinfo -@ stdcall getnameinfo(ptr long ptr long ptr long long) WS_getnameinfo -@ stdcall inet_ntop(long ptr ptr long) WS_inet_ntop -@ stdcall inet_pton(long str ptr) WS_inet_pton +@ stdcall freeaddrinfo(ptr) +@ stdcall getaddrinfo(str str ptr ptr) +@ stdcall getnameinfo(ptr long ptr long ptr long long) +@ stdcall inet_ntop(long ptr ptr long) +@ stdcall inet_pton(long str ptr) diff --git a/dlls/ws2_32/ws2_32_private.h b/dlls/ws2_32/ws2_32_private.h index 57778c76461..6c04785b258 100644 --- a/dlls/ws2_32/ws2_32_private.h +++ b/dlls/ws2_32/ws2_32_private.h @@ -62,15 +62,15 @@
static const char magic_loopback_addr[] = {127, 12, 34, 56};
-const char *debugstr_sockaddr( const struct WS_sockaddr *addr ) DECLSPEC_HIDDEN; +const char *debugstr_sockaddr( const struct sockaddr *addr ) DECLSPEC_HIDDEN;
struct per_thread_data { HANDLE sync_event; /* event to wait on for synchronous ioctls */ int opentype; - struct WS_hostent *he_buffer; - struct WS_servent *se_buffer; - struct WS_protoent *pe_buffer; + struct hostent *he_buffer; + struct servent *se_buffer; + struct protoent *pe_buffer; int he_len; int se_len; int pe_len;
Hi,
While running your changed tests, I think I found new failures. Being a bot and all I'm not very good at pattern recognition, so I might be wrong, but could you please double-check?
Full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=95055
Your paranoid android.
=== debiant2 (32 bit report) ===
ws2_32: sock.c:1135: Test failed: wait failed, error 258