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

Make winsock.h and winsock2.h independent from the Unix headers. 

Make them compatible with both the Unix C headers and the MSVCRT
headers.
Ensure compatibility with the Unix headers via the USE_WS_PREFIX
macro.
Add WINE_NOWINSOCK: prevents winsock.h from being included from
windows.h when defined.
Add ws2tcpip.h, move definitions to the right header.
oldstable
Francois Gouget 2001-11-14 21:26:23 +00:00 committed by Alexandre Julliard
parent c3daf42268
commit 272023190e
16 changed files with 1421 additions and 683 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dlls/winsock/Makefile.in
View File

@ -1,3 +1,4 @@
EXTRADEFS = -DUSE_WS_PREFIX
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR = @srcdir@

18
dlls/winsock/async.c
View File

@ -167,10 +167,10 @@ static int WS_copy_he(char *p_to,char *p_base,int t_size,struct hostent* p_he, i
{
char* p_name,*p_aliases,*p_addr,*p;
struct ws_hostent16 *p_to16 = (struct ws_hostent16*)p_to;
struct ws_hostent32 *p_to32 = (struct ws_hostent32*)p_to;
struct WS_hostent *p_to32 = (struct WS_hostent*)p_to;
int size = hostent_size(p_he) +
(
(flag & AQ_WIN16) ? sizeof(struct ws_hostent16) : sizeof(struct ws_hostent32)
(flag & AQ_WIN16) ? sizeof(struct ws_hostent16) : sizeof(struct WS_hostent)
- sizeof(struct hostent)
);
@ -178,7 +178,7 @@ static int WS_copy_he(char *p_to,char *p_base,int t_size,struct hostent* p_he, i
return -size;
p = p_to;
p += (flag & AQ_WIN16) ?
sizeof(struct ws_hostent16) : sizeof(struct ws_hostent32);
sizeof(struct ws_hostent16) : sizeof(struct WS_hostent);
p_name = p;
strcpy(p, p_he->h_name); p += strlen(p) + 1;
p_aliases = p;
@ -225,10 +225,10 @@ static int WS_copy_pe(char *p_to,char *p_base,int t_size,struct protoent* p_pe,
{
char* p_name,*p_aliases,*p;
struct ws_protoent16 *p_to16 = (struct ws_protoent16*)p_to;
struct ws_protoent32 *p_to32 = (struct ws_protoent32*)p_to;
struct WS_protoent *p_to32 = (struct WS_protoent*)p_to;
int size = protoent_size(p_pe) +
(
(flag & AQ_WIN16) ? sizeof(struct ws_protoent16) : sizeof(struct ws_protoent32)
(flag & AQ_WIN16) ? sizeof(struct ws_protoent16) : sizeof(struct WS_protoent)
- sizeof(struct protoent)
);
@ -236,7 +236,7 @@ static int WS_copy_pe(char *p_to,char *p_base,int t_size,struct protoent* p_pe,
return -size;
p = p_to;
p += (flag & AQ_WIN16) ?
sizeof(struct ws_protoent16) : sizeof(struct ws_protoent32);
sizeof(struct ws_protoent16) : sizeof(struct WS_protoent);
p_name = p;
strcpy(p, p_pe->p_name); p += strlen(p) + 1;
p_aliases = p;
@ -279,10 +279,10 @@ static int WS_copy_se(char *p_to,char *p_base,int t_size,struct servent* p_se, i
{
char* p_name,*p_aliases,*p_proto,*p;
struct ws_servent16 *p_to16 = (struct ws_servent16*)p_to;
struct ws_servent32 *p_to32 = (struct ws_servent32*)p_to;
struct WS_servent *p_to32 = (struct WS_servent*)p_to;
int size = servent_size(p_se) +
(
(flag & AQ_WIN16) ? sizeof(struct ws_servent16) : sizeof(struct ws_servent32)
(flag & AQ_WIN16) ? sizeof(struct ws_servent16) : sizeof(struct WS_servent)
- sizeof(struct servent)
);
@ -290,7 +290,7 @@ static int WS_copy_se(char *p_to,char *p_base,int t_size,struct servent* p_se, i
return -size;
p = p_to;
p += (flag & AQ_WIN16) ?
sizeof(struct ws_servent16) : sizeof(struct ws_servent32);
sizeof(struct ws_servent16) : sizeof(struct WS_servent);
p_name = p;
strcpy(p, p_se->s_name); p += strlen(p) + 1;
p_proto = p;

259
dlls/winsock/socket.c
View File

@ -7,14 +7,8 @@
* NOTE: If you make any changes to fix a particular app, make sure
* they don't break something else like Netscape or telnet and ftp
* clients and servers (www.winsite.com got a lot of those).
*
* NOTE 2: Many winsock structs such as servent, hostent, protoent, ...
* are used with 1-byte alignment for Win16 programs and 4-byte alignment
* for Win32 programs in winsock.h. winsock2.h uses forced 4-byte alignment.
* So we have non-forced (just as MSDN) ws_XXXXent (winsock.h), 4-byte forced
* ws_XXXXent32 (winsock2.h) and 1-byte forced ws_XXXXent16 (winsock16.h).
*/
#include "config.h"
#include "wine/port.h"
@ -92,6 +86,7 @@
#include "wingdi.h"
#include "winuser.h"
#include "winsock2.h"
#include "ws2tcpip.h"
#include "wsipx.h"
#include "wine/winsock16.h"
#include "winnt.h"
@ -154,7 +149,6 @@ static FARPROC blocking_hook;
int WS_dup_he(struct hostent* p_he, int flag);
int WS_dup_pe(struct protoent* p_pe, int flag);
int WS_dup_se(struct servent* p_se, int flag);
int WINAPI WSOCK32_getpeername(SOCKET s, ws_sockaddr *name, int *namelen);
typedef void WIN_hostent;
typedef void WIN_protoent;
@ -317,9 +311,9 @@ static void WINSOCK_DeleteIData(void)
}
/***********************************************************************
* WSOCK32_LibMain (WS2_32.init)
* WS_LibMain (WS2_32.init)
*/
BOOL WINAPI WSOCK32_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
BOOL WINAPI WS_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
{
TRACE("0x%x 0x%lx %p\n", hInstDLL, fdwReason, fImpLoad);
switch (fdwReason) {
@ -391,7 +385,7 @@ static fd_set* fd_set_import( fd_set* fds, void* wsfds, int* highfd, int lfd[],
if( wsfds )
{
#define wsfds16 ((ws_fd_set16*)wsfds)
#define wsfds32 ((ws_fd_set32*)wsfds)
#define wsfds32 ((WS_fd_set*)wsfds)
int i, count;
FD_ZERO(fds);
@ -437,7 +431,7 @@ static int fd_set_export( fd_set* fds, fd_set* exceptfds, void* wsfds, int lfd[]
if( wsfds )
{
#define wsfds16 ((ws_fd_set16*)wsfds)
#define wsfds32 ((ws_fd_set32*)wsfds)
#define wsfds32 ((WS_fd_set*)wsfds)
int i, j, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
for( i = 0, j = 0; i < count; i++ )
@ -477,7 +471,7 @@ static void fd_set_unimport( void* wsfds, int lfd[], BOOL b32 )
if ( wsfds )
{
#define wsfds16 ((ws_fd_set16*)wsfds)
#define wsfds32 ((ws_fd_set32*)wsfds)
#define wsfds32 ((WS_fd_set*)wsfds)
int i, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
for( i = 0; i < count; i++ )
@ -765,17 +759,17 @@ static void ws2_async_accept(SOCKET s, SOCKET as)
* start with. Note that the returned pointer may be the original pointer
* if no conversion is necessary.
*/
const struct sockaddr* ws_sockaddr_ws2u(const ws_sockaddr* wsaddr, int wsaddrlen, int *uaddrlen)
const struct sockaddr* ws_sockaddr_ws2u(const struct WS_sockaddr* wsaddr, int wsaddrlen, int *uaddrlen)
{
switch (wsaddr->sa_family)
{
#ifdef HAVE_IPX
case WS_AF_IPX:
{
struct ws_sockaddr_ipx* wsipx=(struct ws_sockaddr_ipx*)wsaddr;
struct WS_sockaddr_ipx* wsipx=(struct WS_sockaddr_ipx*)wsaddr;
struct sockaddr_ipx* uipx;
if (wsaddrlen<sizeof(struct ws_sockaddr_ipx))
if (wsaddrlen<sizeof(struct WS_sockaddr_ipx))
return NULL;
*uaddrlen=sizeof(struct sockaddr_ipx);
@ -793,7 +787,7 @@ const struct sockaddr* ws_sockaddr_ws2u(const ws_sockaddr* wsaddr, int wsaddrlen
#endif
default:
if (wsaddrlen<sizeof(ws_sockaddr))
if (wsaddrlen<sizeof(struct WS_sockaddr))
return NULL;
/* No conversion needed, just return the original address */
@ -804,7 +798,7 @@ const struct sockaddr* ws_sockaddr_ws2u(const ws_sockaddr* wsaddr, int wsaddrlen
}
/* allocates a Unix sockaddr structure to receive the data */
inline struct sockaddr* ws_sockaddr_alloc(const ws_sockaddr* wsaddr, int* wsaddrlen, int* uaddrlen)
inline struct sockaddr* ws_sockaddr_alloc(const struct WS_sockaddr* wsaddr, int* wsaddrlen, int* uaddrlen)
{
if (*wsaddrlen==0)
*uaddrlen=0;
@ -817,7 +811,7 @@ inline struct sockaddr* ws_sockaddr_alloc(const ws_sockaddr* wsaddr, int* wsaddr
}
/* Returns 0 if successful, -1 if the buffer is too small */
int ws_sockaddr_u2ws(const struct sockaddr* uaddr, int uaddrlen, ws_sockaddr* wsaddr, int* wsaddrlen)
int ws_sockaddr_u2ws(const struct sockaddr* uaddr, int uaddrlen, struct WS_sockaddr* wsaddr, int* wsaddrlen)
{
int res;
@ -827,7 +821,7 @@ int ws_sockaddr_u2ws(const struct sockaddr* uaddr, int uaddrlen, ws_sockaddr* ws
case AF_IPX:
{
struct sockaddr_ipx* uipx=(struct sockaddr_ipx*)uaddr;
struct ws_sockaddr_ipx* wsipx=(struct ws_sockaddr_ipx*)wsaddr;
struct WS_sockaddr_ipx* wsipx=(struct WS_sockaddr_ipx*)wsaddr;
res=-1;
switch (*wsaddrlen) /* how much can we copy? */
@ -873,7 +867,7 @@ int ws_sockaddr_u2ws(const struct sockaddr* uaddr, int uaddrlen, ws_sockaddr* ws
/* to be called to free the memory allocated by ws_sockaddr_ws2u or
* ws_sockaddr_alloc
*/
inline void ws_sockaddr_free(const struct sockaddr* uaddr, const ws_sockaddr* wsaddr)
inline void ws_sockaddr_free(const struct sockaddr* uaddr, const struct WS_sockaddr* wsaddr)
{
if (uaddr!=NULL && uaddr!=(const struct sockaddr*)wsaddr)
free((void*)uaddr);
@ -882,7 +876,7 @@ inline void ws_sockaddr_free(const struct sockaddr* uaddr, const ws_sockaddr* ws
/***********************************************************************
* accept (WS2_32.1)
*/
SOCKET WINAPI WSOCK32_accept(SOCKET s, ws_sockaddr *addr,
SOCKET WINAPI WS_accept(SOCKET s, struct WS_sockaddr *addr,
int *addrlen32)
{
int fd = _get_sock_fd(s);
@ -913,7 +907,7 @@ SOCKET WINAPI WSOCK32_accept(SOCKET s, ws_sockaddr *addr,
if (as)
{
unsigned omask = _get_sock_mask( s );
WSOCK32_getpeername(fd, addr, addrlen32);
WS_getpeername(fd, addr, addrlen32);
if (omask & FD_WINE_SERVEVENT)
ws2_async_accept(s, as);
return as;
@ -929,11 +923,11 @@ SOCKET WINAPI WSOCK32_accept(SOCKET s, ws_sockaddr *addr,
/***********************************************************************
* accept (WINSOCK.1)
*/
SOCKET16 WINAPI WINSOCK_accept16(SOCKET16 s, ws_sockaddr* addr,
SOCKET16 WINAPI WINSOCK_accept16(SOCKET16 s, struct WS_sockaddr* addr,
INT16* addrlen16 )
{
INT addrlen32 = addrlen16 ? *addrlen16 : 0;
SOCKET retSocket = WSOCK32_accept( s, addr, &addrlen32 );
SOCKET retSocket = WS_accept( s, addr, &addrlen32 );
if( addrlen16 ) *addrlen16 = (INT16)addrlen32;
return (SOCKET16)retSocket;
}
@ -941,7 +935,7 @@ SOCKET16 WINAPI WINSOCK_accept16(SOCKET16 s, ws_sockaddr* addr,
/***********************************************************************
* bind (WS2_32.2)
*/
int WINAPI WSOCK32_bind(SOCKET s, const ws_sockaddr* name, int namelen)
int WINAPI WS_bind(SOCKET s, const struct WS_sockaddr* name, int namelen)
{
int fd = _get_sock_fd(s);
int res;
@ -1007,15 +1001,15 @@ int WINAPI WSOCK32_bind(SOCKET s, const ws_sockaddr* name, int namelen)
/***********************************************************************
* bind (WINSOCK.2)
*/
INT16 WINAPI WINSOCK_bind16(SOCKET16 s, ws_sockaddr *name, INT16 namelen)
INT16 WINAPI WINSOCK_bind16(SOCKET16 s, struct WS_sockaddr *name, INT16 namelen)
{
return (INT16)WSOCK32_bind( s, name, namelen );
return (INT16)WS_bind( s, name, namelen );
}
/***********************************************************************
* closesocket (WS2_32.3)
*/
INT WINAPI WSOCK32_closesocket(SOCKET s)
int WINAPI WS_closesocket(SOCKET s)
{
TRACE("socket %08x\n", s);
if (CloseHandle(s)) return 0;
@ -1027,13 +1021,13 @@ INT WINAPI WSOCK32_closesocket(SOCKET s)
*/
INT16 WINAPI WINSOCK_closesocket16(SOCKET16 s)
{
return (INT16)WSOCK32_closesocket(s);
return (INT16)WS_closesocket(s);
}
/***********************************************************************
* connect (WS2_32.4)
*/
int WINAPI WSOCK32_connect(SOCKET s, const ws_sockaddr* name, int namelen)
int WINAPI WS_connect(SOCKET s, const struct WS_sockaddr* name, int namelen)
{
int fd = _get_sock_fd(s);
@ -1111,15 +1105,15 @@ connect_success:
/***********************************************************************
* connect (WINSOCK.4)
*/
INT16 WINAPI WINSOCK_connect16(SOCKET16 s, ws_sockaddr *name, INT16 namelen)
INT16 WINAPI WINSOCK_connect16(SOCKET16 s, struct WS_sockaddr *name, INT16 namelen)
{
return (INT16)WSOCK32_connect( s, name, namelen );
return (INT16)WS_connect( s, name, namelen );
}
/***********************************************************************
* getpeername (WS2_32.5)
*/
int WINAPI WSOCK32_getpeername(SOCKET s, ws_sockaddr *name, int *namelen)
int WINAPI WS_getpeername(SOCKET s, struct WS_sockaddr *name, int *namelen)
{
int fd = _get_sock_fd(s);
int res;
@ -1159,11 +1153,11 @@ int WINAPI WSOCK32_getpeername(SOCKET s, ws_sockaddr *name, int *namelen)
/***********************************************************************
* getpeername (WINSOCK.5)
*/
INT16 WINAPI WINSOCK_getpeername16(SOCKET16 s, ws_sockaddr *name,
INT16 WINAPI WINSOCK_getpeername16(SOCKET16 s, struct WS_sockaddr *name,
INT16 *namelen16)
{
INT namelen32 = *namelen16;
INT retVal = WSOCK32_getpeername( s, name, &namelen32 );
INT retVal = WS_getpeername( s, name, &namelen32 );
#if DEBUG_SOCKADDR
dump_sockaddr(name);
@ -1176,7 +1170,7 @@ INT16 WINAPI WINSOCK_getpeername16(SOCKET16 s, ws_sockaddr *name,
/***********************************************************************
* getsockname (WS2_32.6)
*/
int WINAPI WSOCK32_getsockname(SOCKET s, ws_sockaddr *name, int *namelen)
int WINAPI WS_getsockname(SOCKET s, struct WS_sockaddr *name, int *namelen)
{
int fd = _get_sock_fd(s);
int res;
@ -1215,7 +1209,7 @@ int WINAPI WSOCK32_getsockname(SOCKET s, ws_sockaddr *name, int *namelen)
/***********************************************************************
* getsockname (WINSOCK.6)
*/
INT16 WINAPI WINSOCK_getsockname16(SOCKET16 s, ws_sockaddr *name,
INT16 WINAPI WINSOCK_getsockname16(SOCKET16 s, struct WS_sockaddr *name,
INT16 *namelen16)
{
INT retVal;
@ -1223,7 +1217,7 @@ INT16 WINAPI WINSOCK_getsockname16(SOCKET16 s, ws_sockaddr *name,
if( namelen16 )
{
INT namelen32 = *namelen16;
retVal = WSOCK32_getsockname( s, name, &namelen32 );
retVal = WS_getsockname( s, name, &namelen32 );
*namelen16 = namelen32;
#if DEBUG_SOCKADDR
@ -1239,7 +1233,7 @@ INT16 WINAPI WINSOCK_getsockname16(SOCKET16 s, ws_sockaddr *name,
/***********************************************************************
* getsockopt (WS2_32.7)
*/
INT WINAPI WSOCK32_getsockopt(SOCKET s, INT level,
INT WINAPI WS_getsockopt(SOCKET s, INT level,
INT optname, char *optval, INT *optlen)
{
int fd = _get_sock_fd(s);
@ -1262,6 +1256,7 @@ INT WINAPI WSOCK32_getsockopt(SOCKET s, INT level,
return SOCKET_ERROR;
}
/***********************************************************************
* getsockopt (WINSOCK.7)
*/
@ -1272,47 +1267,72 @@ INT16 WINAPI WINSOCK_getsockopt16(SOCKET16 s, INT16 level,
INT *p = &optlen32;
INT retVal;
if( optlen ) optlen32 = *optlen; else p = NULL;
retVal = WSOCK32_getsockopt( s, (UINT16)level, optname, optval, p );
retVal = WS_getsockopt( s, (UINT16)level, optname, optval, p );
if( optlen ) *optlen = optlen32;
return (INT16)retVal;
}
/***********************************************************************
* htonl (WINSOCK.8)
* htonl (WS2_32.8)
*/
u_long WINAPI WINSOCK_htonl(u_long hostlong) { return( htonl(hostlong) ); }
u_long WINAPI WS_htonl(u_long hostlong)
{
return htonl(hostlong);
}
/***********************************************************************
* htons (WINSOCK.9)
* htons (WS2_32.9)
*/
u_short WINAPI WINSOCK_htons(u_short hostshort) { return( htons(hostshort) ); }
u_short WINAPI WS_htons(u_short hostshort)
{
return htons(hostshort);
}
/***********************************************************************
* inet_addr (WINSOCK.10)
* inet_addr (WS2_32.11)
*/
u_long WINAPI WINSOCK_inet_addr(char *cp) { return( inet_addr(cp) ); }
u_long WINAPI WS_inet_addr(const char *cp)
{
return inet_addr(cp);
}
/***********************************************************************
* ntohl (WINSOCK.14)
* ntohl (WS2_32.14)
*/
u_long WINAPI WINSOCK_ntohl(u_long netlong) { return( ntohl(netlong) ); }
u_long WINAPI WS_ntohl(u_long netlong)
{
return ntohl(netlong);
}
/***********************************************************************
* ntohs (WINSOCK.15)
* ntohs (WS2_32.15)
*/
u_short WINAPI WINSOCK_ntohs(u_short netshort) { return( ntohs(netshort) ); }
u_short WINAPI WS_ntohs(u_short netshort)
{
return ntohs(netshort);
}
/***********************************************************************
* inet_ntoa (WS2_32.12)
*/
char* WINAPI WSOCK32_inet_ntoa(struct in_addr in)
char* WINAPI WS_inet_ntoa(struct WS_in_addr in)
{
/* use "buffer for dummies" here because some applications have
* propensity to decode addresses in ws_hostent structure without
* saving them first...
*/
char* s = inet_ntoa(in);
char* s = inet_ntoa(*((struct in_addr*)&in));
if( s )
{
if( dbuffer == NULL ) {
@ -1335,7 +1355,7 @@ char* WINAPI WSOCK32_inet_ntoa(struct in_addr in)
*/
SEGPTR WINAPI WINSOCK_inet_ntoa16(struct in_addr in)
{
char* retVal = WSOCK32_inet_ntoa(in);
char* retVal = WS_inet_ntoa(*((struct WS_in_addr*)&in));
return SEGPTR_GET(retVal);
}
@ -1404,11 +1424,11 @@ INT WINAPI WSAIoctl (SOCKET s,
}
else
{
struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_addr;
struct WS_sockaddr_in *ipTemp = (struct WS_sockaddr_in *)&ifInfo.ifr_addr;
intArray->iiAddress.AddressIn.sin_family = AF_INET;
intArray->iiAddress.AddressIn.sin_port = ipTemp->sin_port;
intArray->iiAddress.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
intArray->iiAddress.AddressIn.sin_addr.WS_s_addr = ipTemp->sin_addr.S_un.S_addr;
}
/* Broadcast Address */
@ -1422,11 +1442,11 @@ INT WINAPI WSAIoctl (SOCKET s,
}
else
{
struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_broadaddr;
struct WS_sockaddr_in *ipTemp = (struct WS_sockaddr_in *)&ifInfo.ifr_broadaddr;
intArray->iiBroadcastAddress.AddressIn.sin_family = AF_INET;
intArray->iiBroadcastAddress.AddressIn.sin_port = ipTemp->sin_port;
intArray->iiBroadcastAddress.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
intArray->iiBroadcastAddress.AddressIn.sin_addr.WS_s_addr = ipTemp->sin_addr.S_un.S_addr;
}
/* Subnet Mask */
@ -1446,21 +1466,21 @@ INT WINAPI WSAIoctl (SOCKET s,
#ifndef ifr_addr
intArray->iiNetmask.AddressIn.sin_family = AF_INET;
intArray->iiNetmask.AddressIn.sin_port = 0;
intArray->iiNetmask.AddressIn.sin_addr.ws_addr = 0;
intArray->iiNetmask.AddressIn.sin_addr.WS_s_addr = 0;
ERR ("Unable to determine Netmask on your platform!\n");
#else
struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_addr;
struct WS_sockaddr_in *ipTemp = (struct WS_sockaddr_in *)&ifInfo.ifr_addr;
intArray->iiNetmask.AddressIn.sin_family = AF_INET;
intArray->iiNetmask.AddressIn.sin_port = ipTemp->sin_port;
intArray->iiNetmask.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
intArray->iiNetmask.AddressIn.sin_addr.WS_s_addr = ipTemp->sin_addr.S_un.S_addr;
#endif
#else
struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_netmask;
struct WS_sockaddr_in *ipTemp = (struct WS_sockaddr_in *)&ifInfo.ifr_netmask;
intArray->iiNetmask.AddressIn.sin_family = AF_INET;
intArray->iiNetmask.AddressIn.sin_port = ipTemp->sin_port;
intArray->iiNetmask.AddressIn.sin_addr.ws_addr = ipTemp->sin_addr.S_un.S_addr;
intArray->iiNetmask.AddressIn.sin_addr.WS_s_addr = ipTemp->sin_addr.S_un.S_addr;
#endif
}
@ -1631,7 +1651,7 @@ int WSAIOCTL_GetInterfaceName(int intNumber, char *intName)
/***********************************************************************
* ioctlsocket (WS2_32.10)
*/
INT WINAPI WSOCK32_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
int WINAPI WS_ioctlsocket(SOCKET s, long cmd, u_long *argp)
{
int fd = _get_sock_fd(s);
@ -1670,7 +1690,7 @@ INT WINAPI WSOCK32_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
newcmd=SIOCATMARK;
break;
case WS_IOW('f',125,u_long):
case WS__IOW('f',125,u_long):
WARN("Warning: WS1.1 shouldn't be using async I/O\n");
SetLastError(WSAEINVAL);
return SOCKET_ERROR;
@ -1703,14 +1723,14 @@ INT WINAPI WSOCK32_ioctlsocket(SOCKET s, LONG cmd, ULONG *argp)
*/
INT16 WINAPI WINSOCK_ioctlsocket16(SOCKET16 s, LONG cmd, ULONG *argp)
{
return (INT16)WSOCK32_ioctlsocket( s, cmd, argp );
return (INT16)WS_ioctlsocket( s, cmd, argp );
}
/***********************************************************************
* listen (WS2_32.13)
*/
INT WINAPI WSOCK32_listen(SOCKET s, INT backlog)
int WINAPI WS_listen(SOCKET s, int backlog)
{
int fd = _get_sock_fd(s);
@ -1736,14 +1756,14 @@ INT WINAPI WSOCK32_listen(SOCKET s, INT backlog)
*/
INT16 WINAPI WINSOCK_listen16(SOCKET16 s, INT16 backlog)
{
return (INT16)WSOCK32_listen( s, backlog );
return (INT16)WS_listen( s, backlog );
}
/***********************************************************************
* recv (WS2_32.16)
*/
INT WINAPI WSOCK32_recv(SOCKET s, char *buf, INT len, INT flags)
int WINAPI WS_recv(SOCKET s, char *buf, int len, int flags)
{
int fd = _get_sock_fd(s);
@ -1780,15 +1800,15 @@ INT WINAPI WSOCK32_recv(SOCKET s, char *buf, INT len, INT flags)
*/
INT16 WINAPI WINSOCK_recv16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
{
return (INT16)WSOCK32_recv( s, buf, len, flags );
return (INT16)WS_recv( s, buf, len, flags );
}
/***********************************************************************
* recvfrom (WS2_32.17)
*/
int WINAPI WSOCK32_recvfrom(SOCKET s, char *buf, INT len, int flags,
ws_sockaddr *from, int *fromlen)
int WINAPI WS_recvfrom(SOCKET s, char *buf, INT len, int flags,
struct WS_sockaddr *from, int *fromlen)
{
int fd = _get_sock_fd(s);
int res;
@ -1850,14 +1870,14 @@ int WINAPI WSOCK32_recvfrom(SOCKET s, char *buf, INT len, int flags,
* recvfrom (WINSOCK.17)
*/
INT16 WINAPI WINSOCK_recvfrom16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
ws_sockaddr *from, INT16 *fromlen16)
struct WS_sockaddr *from, INT16 *fromlen16)
{
INT fromlen32;
INT *p = &fromlen32;
INT retVal;
if( fromlen16 ) fromlen32 = *fromlen16; else p = NULL;
retVal = WSOCK32_recvfrom( s, buf, len, flags, from, p );
retVal = WS_recvfrom( s, buf, len, flags, from, p );
if( fromlen16 ) *fromlen16 = fromlen32;
return (INT16)retVal;
}
@ -1865,9 +1885,9 @@ INT16 WINAPI WINSOCK_recvfrom16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
/***********************************************************************
* __ws_select
*/
static INT __ws_select(BOOL b32,
static int __ws_select(BOOL b32,
void *ws_readfds, void *ws_writefds, void *ws_exceptfds,
const struct timeval* ws_timeout)
const struct WS_timeval *ws_timeout)
{
int highfd = 0;
fd_set readfds, writefds, exceptfds;
@ -1875,8 +1895,8 @@ static INT __ws_select(BOOL b32,
int readfd[FD_SETSIZE], writefd[FD_SETSIZE], exceptfd[FD_SETSIZE];
struct timeval timeout, *timeoutaddr = NULL;
TRACE("read %p, write %p, excp %p timeout %p\n",
ws_readfds, ws_writefds, ws_exceptfds, ws_timeout);
TRACE("read %p, write %p, excp %p timeout %p\n",
ws_readfds, ws_writefds, ws_exceptfds, ws_timeout);
p_read = fd_set_import(&readfds, ws_readfds, &highfd, readfd, b32);
p_write = fd_set_import(&writefds, ws_writefds, &highfd, writefd, b32);
@ -1896,7 +1916,7 @@ static INT __ws_select(BOOL b32,
if (p_except && ws_exceptfds)
{
#define wsfds16 ((ws_fd_set16*)ws_exceptfds)
#define wsfds32 ((ws_fd_set32*)ws_exceptfds)
#define wsfds32 ((WS_fd_set*)ws_exceptfds)
int i, j, count = (b32) ? wsfds32->fd_count : wsfds16->fd_count;
for (i = j = 0; i < count; i++)
@ -1924,9 +1944,9 @@ static INT __ws_select(BOOL b32,
fd_set_unimport(ws_readfds, readfd, b32);
fd_set_unimport(ws_writefds, writefd, b32);
fd_set_unimport(ws_exceptfds, exceptfd, b32);
if( ws_readfds ) ((ws_fd_set32*)ws_readfds)->fd_count = 0;
if( ws_writefds ) ((ws_fd_set32*)ws_writefds)->fd_count = 0;
if( ws_exceptfds ) ((ws_fd_set32*)ws_exceptfds)->fd_count = 0;
if( ws_readfds ) ((WS_fd_set*)ws_readfds)->fd_count = 0;
if( ws_writefds ) ((WS_fd_set*)ws_writefds)->fd_count = 0;
if( ws_exceptfds ) ((WS_fd_set*)ws_exceptfds)->fd_count = 0;
if( highfd == 0 ) return 0;
SetLastError(wsaErrno());
@ -1938,7 +1958,7 @@ static INT __ws_select(BOOL b32,
*/
INT16 WINAPI WINSOCK_select16(INT16 nfds, ws_fd_set16 *ws_readfds,
ws_fd_set16 *ws_writefds, ws_fd_set16 *ws_exceptfds,
struct timeval *timeout)
struct WS_timeval* timeout)
{
return (INT16)__ws_select( FALSE, ws_readfds, ws_writefds, ws_exceptfds, timeout );
}
@ -1946,9 +1966,9 @@ INT16 WINAPI WINSOCK_select16(INT16 nfds, ws_fd_set16 *ws_readfds,
/***********************************************************************
* select (WS2_32.18)
*/
INT WINAPI WSOCK32_select(INT nfds, ws_fd_set32 *ws_readfds,
ws_fd_set32 *ws_writefds, ws_fd_set32 *ws_exceptfds,
const struct timeval *timeout)
int WINAPI WS_select(int nfds, WS_fd_set *ws_readfds,
WS_fd_set *ws_writefds, WS_fd_set *ws_exceptfds,
const struct WS_timeval* timeout)
{
/* struct timeval is the same for both 32- and 16-bit code */
return (INT)__ws_select( TRUE, ws_readfds, ws_writefds, ws_exceptfds, timeout );
@ -1958,7 +1978,7 @@ INT WINAPI WSOCK32_select(INT nfds, ws_fd_set32 *ws_readfds,
/***********************************************************************
* send (WS2_32.19)
*/
INT WINAPI WSOCK32_send(SOCKET s, char *buf, INT len, INT flags)
int WINAPI WS_send(SOCKET s, const char *buf, int len, int flags)
{
int fd = _get_sock_fd(s);
@ -2024,7 +2044,7 @@ INT WINAPI WSASend( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
/* Send all buffers with the same flags */
for(dwCount = 0; dwCount < dwBufferCount; dwCount++ )
{
if( ( rc = WSOCK32_send( s, lpBuffers[ dwCount ].buf,
if( ( rc = WS_send( s, lpBuffers[ dwCount ].buf,
lpBuffers[ dwCount ].len, iFlags ) ) != 0 )
{
break;
@ -2042,14 +2062,14 @@ INT WINAPI WSASend( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
*/
INT16 WINAPI WINSOCK_send16(SOCKET16 s, char *buf, INT16 len, INT16 flags)
{
return WSOCK32_send( s, buf, len, flags );
return WS_send( s, buf, len, flags );
}
/***********************************************************************
* sendto (WS2_32.20)
*/
int WINAPI WSOCK32_sendto(SOCKET s, const char *buf, int len, int flags,
const ws_sockaddr *to, int tolen)
int WINAPI WS_sendto(SOCKET s, const char *buf, int len, int flags,
const struct WS_sockaddr *to, int tolen)
{
int fd = _get_sock_fd(s);
int res;
@ -2097,16 +2117,16 @@ int WINAPI WSOCK32_sendto(SOCKET s, const char *buf, int len, int flags,
* sendto (WINSOCK.20)
*/
INT16 WINAPI WINSOCK_sendto16(SOCKET16 s, char *buf, INT16 len, INT16 flags,
ws_sockaddr *to, INT16 tolen)
struct WS_sockaddr *to, INT16 tolen)
{
return (INT16)WSOCK32_sendto( s, buf, len, flags, to, tolen );
return (INT16)WS_sendto( s, buf, len, flags, to, tolen );
}
/***********************************************************************
* setsockopt (WS2_32.21)
*/
INT WINAPI WSOCK32_setsockopt(SOCKET16 s, INT level, INT optname,
char *optval, INT optlen)
int WINAPI WS_setsockopt(SOCKET s, int level, int optname,
const char *optval, int optlen)
{
int fd = _get_sock_fd(s);
@ -2144,7 +2164,7 @@ INT WINAPI WSOCK32_setsockopt(SOCKET16 s, INT level, INT optname,
/* FIXME: what is documented behavior if SO_LINGER optval
is null?? */
optval = (char*)&linger;
optlen = sizeof(struct linger);
optlen = sizeof(struct WS_linger);
} else if (optlen < sizeof(int)){
woptval= *((INT16 *) optval);
optval= (char*) &woptval;
@ -2176,14 +2196,14 @@ INT16 WINAPI WINSOCK_setsockopt16(SOCKET16 s, INT16 level, INT16 optname,
char *optval, INT16 optlen)
{
if( !optval ) return SOCKET_ERROR;
return (INT16)WSOCK32_setsockopt( s, (UINT16)level, optname, optval, optlen );
return (INT16)WS_setsockopt( s, (UINT16)level, optname, optval, optlen );
}
/***********************************************************************
* shutdown (WS2_32.22)
*/
INT WINAPI WSOCK32_shutdown(SOCKET s, INT how)
int WINAPI WS_shutdown(SOCKET s, int how)
{
int fd = _get_sock_fd(s);
@ -2236,14 +2256,14 @@ INT WINAPI WSOCK32_shutdown(SOCKET s, INT how)
*/
INT16 WINAPI WINSOCK_shutdown16(SOCKET16 s, INT16 how)
{
return (INT16)WSOCK32_shutdown( s, how );
return (INT16)WS_shutdown( s, how );
}
/***********************************************************************
* socket (WS2_32.23)
*/
SOCKET WINAPI WSOCK32_socket(INT af, INT type, INT protocol)
SOCKET WINAPI WS_socket(int af, int type, int protocol)
{
SOCKET ret;
@ -2326,7 +2346,7 @@ SOCKET WINAPI WSOCK32_socket(INT af, INT type, INT protocol)
*/
SOCKET16 WINAPI WINSOCK_socket16(INT16 af, INT16 type, INT16 protocol)
{
return (SOCKET16)WSOCK32_socket( af, type, protocol );
return (SOCKET16)WS_socket( af, type, protocol );
}
@ -2398,8 +2418,8 @@ SEGPTR WINAPI WINSOCK_gethostbyaddr16(const char *addr, INT16 len, INT16 type)
/***********************************************************************
* gethostbyaddr (WS2_32.51)
*/
WIN_hostent* WINAPI WSOCK32_gethostbyaddr(const char *addr, INT len,
INT type)
struct WS_hostent* WINAPI WS_gethostbyaddr(const char *addr, int len,
int type)
{
TRACE("ptr %08x, len %d, type %d\n",
(unsigned) addr, len, type);
@ -2460,7 +2480,7 @@ SEGPTR WINAPI WINSOCK_gethostbyname16(const char *name)
/***********************************************************************
* gethostbyname (WS2_32.52)
*/
WIN_hostent* WINAPI WSOCK32_gethostbyname(const char* name)
struct WS_hostent* WINAPI WS_gethostbyname(const char* name)
{
TRACE("%s\n", (name)?name:NULL_STRING);
return __ws_gethostbyname( name, WS_DUP_LINEAR );
@ -2505,7 +2525,7 @@ SEGPTR WINAPI WINSOCK_getprotobyname16(const char *name)
/***********************************************************************
* getprotobyname (WS2_32.53)
*/
WIN_protoent* WINAPI WSOCK32_getprotobyname(const char* name)
struct WS_protoent* WINAPI WS_getprotobyname(const char* name)
{
TRACE("%s\n", (name)?name:NULL_STRING);
return __ws_getprotobyname(name, WS_DUP_LINEAR);
@ -2549,7 +2569,7 @@ SEGPTR WINAPI WINSOCK_getprotobynumber16(INT16 number)
/***********************************************************************
* getprotobynumber (WS2_32.54)
*/
WIN_protoent* WINAPI WSOCK32_getprotobynumber(INT number)
struct WS_protoent* WINAPI WS_getprotobynumber(int number)
{
TRACE("%i\n", number);
return __ws_getprotobynumber(number, WS_DUP_LINEAR);
@ -2602,7 +2622,7 @@ SEGPTR WINAPI WINSOCK_getservbyname16(const char *name, const char *proto)
/***********************************************************************
* getservbyname (WS2_32.55)
*/
WIN_servent* WINAPI WSOCK32_getservbyname(const char *name, const char *proto)
struct WS_servent* WINAPI WS_getservbyname(const char *name, const char *proto)
{
TRACE("'%s', '%s'\n",
(name)?name:NULL_STRING, (proto)?proto:NULL_STRING);
@ -2651,7 +2671,7 @@ SEGPTR WINAPI WINSOCK_getservbyport16(INT16 port, const char *proto)
/***********************************************************************
* getservbyport (WS2_32.56)
*/
WIN_servent* WINAPI WSOCK32_getservbyport(INT port, const char *proto)
struct WS_servent* WINAPI WS_getservbyport(int port, const char *proto)
{
TRACE("%d (i.e. port %d), '%s'\n",
(int)port, (int)ntohl(port), (proto)?proto:NULL_STRING);
@ -2662,7 +2682,7 @@ WIN_servent* WINAPI WSOCK32_getservbyport(INT port, const char *proto)
/***********************************************************************
* gethostname (WS2_32.57)
*/
INT WINAPI WSOCK32_gethostname(char *name, INT namelen)
int WINAPI WS_gethostname(char *name, int namelen)
{
TRACE("name %p, len %d\n", name, namelen);
@ -2681,7 +2701,7 @@ INT WINAPI WSOCK32_gethostname(char *name, INT namelen)
*/
INT16 WINAPI WINSOCK_gethostname16(char *name, INT16 namelen)
{
return (INT16)WSOCK32_gethostname(name, namelen);
return (INT16)WS_gethostname(name, namelen);
}
@ -2861,7 +2881,8 @@ INT16 WINAPI WSAAsyncSelect16(SOCKET16 s, HWND16 hWnd, UINT16 wMsg, LONG lEvent)
*
* See description for WSARecvEx()
*/
INT16 WINAPI WSARecvEx16(SOCKET16 s, char *buf, INT16 len, INT16 *flags) {
INT16 WINAPI WSARecvEx16(SOCKET16 s, char *buf, INT16 len, INT16 *flags)
{
FIXME("(WSARecvEx16) partial packet return value not set \n");
return WINSOCK_recv16(s, buf, len, *flags);
@ -2907,7 +2928,7 @@ SOCKET WINAPI WSASocketA(int af, int type, int protocol,
TRACE("af=%d type=%d protocol=%d protocol_info=%p group=%d flags=0x%lx\n",
af, type, protocol, lpProtocolInfo, g, dwFlags );
return ( WSOCK32_socket (af, type, protocol) );
return ( WS_socket (af, type, protocol) );
}
@ -2928,7 +2949,7 @@ INT16 WINAPI __WSAFDIsSet16(SOCKET16 s, ws_fd_set16 *set)
/***********************************************************************
* __WSAFDIsSet (WS2_32.151)
*/
INT WINAPI __WSAFDIsSet(SOCKET s, ws_fd_set32 *set)
int WINAPI __WSAFDIsSet(SOCKET s, WS_fd_set *set)
{
int i = set->fd_count;
@ -3080,7 +3101,7 @@ int WS_dup_he(struct hostent* p_he, int flag)
char *p_name,*p_aliases,*p_addr,*p_base,*p;
char *p_to;
struct ws_hostent16 *p_to16;
struct ws_hostent32 *p_to32;
struct WS_hostent *p_to32;
check_buffer_he(size);
p_to = he_buffer;
@ -3091,7 +3112,7 @@ int WS_dup_he(struct hostent* p_he, int flag)
p_base = (flag & WS_DUP_OFFSET) ? NULL
: ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
p += (flag & WS_DUP_SEGPTR) ?
sizeof(struct ws_hostent16) : sizeof(struct ws_hostent32);
sizeof(struct ws_hostent16) : sizeof(struct WS_hostent);
p_name = p;
strcpy(p, p_he->h_name); p += strlen(p) + 1;
p_aliases = p;
@ -3115,7 +3136,7 @@ int WS_dup_he(struct hostent* p_he, int flag)
p_to32->h_name = (p_base + (p_name - p_to));
p_to32->h_aliases = (char **)(p_base + (p_aliases - p_to));
p_to32->h_addr_list = (char **)(p_base + (p_addr - p_to));
size += (sizeof(struct ws_hostent32) - sizeof(struct hostent));
size += (sizeof(struct WS_hostent) - sizeof(struct hostent));
}
}
return size;
@ -3140,7 +3161,7 @@ int WS_dup_pe(struct protoent* p_pe, int flag)
{
char *p_to;
struct ws_protoent16 *p_to16;
struct ws_protoent32 *p_to32;
struct WS_protoent *p_to32;
char *p_name,*p_aliases,*p_base,*p;
check_buffer_pe(size);
@ -3151,7 +3172,7 @@ int WS_dup_pe(struct protoent* p_pe, int flag)
p_base = (flag & WS_DUP_OFFSET) ? NULL
: ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
p += (flag & WS_DUP_SEGPTR) ?
sizeof(struct ws_protoent16) : sizeof(struct ws_protoent32);
sizeof(struct ws_protoent16) : sizeof(struct WS_protoent);
p_name = p;
strcpy(p, p_pe->p_name); p += strlen(p) + 1;
p_aliases = p;
@ -3169,7 +3190,7 @@ int WS_dup_pe(struct protoent* p_pe, int flag)
p_to32->p_proto = p_pe->p_proto;
p_to32->p_name = (p_base) + (p_name - p_to);
p_to32->p_aliases = (char **)((p_base) + (p_aliases - p_to));
size += (sizeof(struct ws_protoent32) - sizeof(struct protoent));
size += (sizeof(struct WS_protoent) - sizeof(struct protoent));
}
}
return size;
@ -3195,7 +3216,7 @@ int WS_dup_se(struct servent* p_se, int flag)
char *p_name,*p_aliases,*p_proto,*p_base,*p;
char *p_to;
struct ws_servent16 *p_to16;
struct ws_servent32 *p_to32;
struct WS_servent *p_to32;
check_buffer_se(size);
p_to = se_buffer;
@ -3205,7 +3226,7 @@ int WS_dup_se(struct servent* p_se, int flag)
p_base = (flag & WS_DUP_OFFSET) ? NULL
: ((flag & WS_DUP_SEGPTR) ? (char*)SEGPTR_GET(p) : p);
p += (flag & WS_DUP_SEGPTR) ?
sizeof(struct ws_servent16) : sizeof(struct ws_servent32);
sizeof(struct ws_servent16) : sizeof(struct WS_servent);
p_name = p;
strcpy(p, p_se->s_name); p += strlen(p) + 1;
p_proto = p;
@ -3227,7 +3248,7 @@ int WS_dup_se(struct servent* p_se, int flag)
p_to32->s_name = (p_base + (p_name - p_to));
p_to32->s_proto = (p_base + (p_proto - p_to));
p_to32->s_aliases = (char **)(p_base + (p_aliases - p_to));
size += (sizeof(struct ws_servent32) - sizeof(struct servent));
size += (sizeof(struct WS_servent) - sizeof(struct servent));
}
}
return size;
@ -3331,7 +3352,7 @@ UINT16 wsaHerrno(int loc_errno)
* WSARecvFrom (WS2_32.69)
*/
INT WINAPI WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, struct sockaddr *lpFrom,
LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, struct WS_sockaddr *lpFrom,
LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped,
LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine )
{
@ -3345,7 +3366,7 @@ INT WINAPI WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,
for( dwCount = 0, rc = 0; dwCount < dwBufferCount; dwCount++ )
{
if( ( rc = WSOCK32_recvfrom(s, lpBuffers[ dwCount ].buf, (INT)lpBuffers[ dwCount ].len,
if( ( rc = WS_recvfrom(s, lpBuffers[ dwCount ].buf, (INT)lpBuffers[ dwCount ].len,
(INT)*lpFlags, lpFrom, lpFromlen ) ) != 0 )
{
break;

10
dlls/winsock/winsock.spec
View File

@ -14,14 +14,14 @@ owner ws2_32
5 pascal16 getpeername(word ptr ptr) WINSOCK_getpeername16
6 pascal16 getsockname(word ptr ptr) WINSOCK_getsockname16
7 pascal16 getsockopt(word word word ptr ptr) WINSOCK_getsockopt16
8 pascal htonl(long) WINSOCK_htonl
9 pascal16 htons(word) WINSOCK_htons
10 pascal inet_addr(ptr) WINSOCK_inet_addr
8 pascal htonl(long) WS_htonl
9 pascal16 htons(word) WS_htons
10 pascal inet_addr(ptr) WS_inet_addr
11 pascal inet_ntoa(long) WINSOCK_inet_ntoa16
12 pascal16 ioctlsocket(word long ptr) WINSOCK_ioctlsocket16
13 pascal16 listen(word word) WINSOCK_listen16
14 pascal ntohl(long) WINSOCK_ntohl
15 pascal16 ntohs(word) WINSOCK_ntohs
14 pascal ntohl(long) WS_ntohl
15 pascal16 ntohs(word) WS_ntohs
16 pascal16 recv(word ptr word word) WINSOCK_recv16
17 pascal16 recvfrom(word ptr word word ptr ptr) WINSOCK_recvfrom16
18 pascal16 select(word ptr ptr ptr ptr) WINSOCK_select16

62
dlls/winsock/ws2_32.spec
View File

@ -4,7 +4,7 @@
name ws2_32
type win32
init WSOCK32_LibMain
init WS_LibMain
import user32.dll
import kernel32.dll
@ -13,29 +13,29 @@ import ntdll.dll
debug_channels (winsock)
# EXPORTS ***********
1 stdcall accept(long ptr ptr) WSOCK32_accept
2 stdcall bind(long ptr long) WSOCK32_bind
3 stdcall closesocket(long) WSOCK32_closesocket
4 stdcall connect(long ptr long) WSOCK32_connect
5 stdcall getpeername(long ptr ptr) WSOCK32_getpeername
6 stdcall getsockname(long ptr ptr) WSOCK32_getsockname
7 stdcall getsockopt(long long long ptr ptr) WSOCK32_getsockopt
8 stdcall htonl(long) WINSOCK_htonl
9 stdcall htons(long) WINSOCK_htons
10 stdcall ioctlsocket(long long ptr) WSOCK32_ioctlsocket
11 stdcall inet_addr(str) WINSOCK_inet_addr
12 stdcall inet_ntoa(ptr) WSOCK32_inet_ntoa
13 stdcall listen(long long) WSOCK32_listen
14 stdcall ntohl(long) WINSOCK_ntohl
15 stdcall ntohs(long) WINSOCK_ntohs
16 stdcall recv(long ptr long long) WSOCK32_recv
17 stdcall recvfrom(long ptr long long ptr ptr) WSOCK32_recvfrom
18 stdcall select(long ptr ptr ptr ptr) WSOCK32_select
19 stdcall send(long ptr long long) WSOCK32_send
20 stdcall sendto(long ptr long long ptr long) WSOCK32_sendto
21 stdcall setsockopt(long long long ptr long) WSOCK32_setsockopt
22 stdcall shutdown(long long) WSOCK32_shutdown
23 stdcall socket(long long long) WSOCK32_socket
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
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
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
24 stdcall WSApSetPostRoutine(ptr) WSApSetPostRoutine
25 stub WPUCompleteOverlappedRequest
26 stub WSAAccept
@ -63,13 +63,13 @@ debug_channels (winsock)
48 stub WSAInstallServiceClassA
49 stub WSAInstallServiceClassW
50 stdcall WSAIoctl(long long ptr long ptr long ptr ptr ptr) WSAIoctl
51 stdcall gethostbyaddr(ptr long long) WSOCK32_gethostbyaddr
52 stdcall gethostbyname(str) WSOCK32_gethostbyname
53 stdcall getprotobyname(str) WSOCK32_getprotobyname
54 stdcall getprotobynumber(long) WSOCK32_getprotobynumber
55 stdcall getservbyname(str str) WSOCK32_getservbyname
56 stdcall getservbyport(long str) WSOCK32_getservbyport
57 stdcall gethostname(ptr long) WSOCK32_gethostname
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
58 stub WSAJoinLeaf
59 stub WSALookupServiceBeginA
60 stub WSALookupServiceBeginW

24
dlls/wsock32/protocol.c
View File

@ -4,10 +4,20 @@
* Copyright (C) 2001 Stefan Leichter
*/
/* All we need are a couple constants for EnumProtocols. Once it is
* moved to ws2_32 we may no longer need it
*/
#define USE_WS_PREFIX
#include "config.h"
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include "winbase.h"
#include "winnls.h"
#include "wine/unicode.h"
@ -52,12 +62,12 @@ static INT WSOCK32_EnterSingleProtocol( INT iProtocol,
*lpSize = sizeof( PROTOCOL_INFOA);
switch (iProtocol) {
case IPPROTO_TCP :
case WS_IPPROTO_TCP :
dwLength = (unicode) ? sizeof(WCHAR) * (strlenW(NameTcp)+1) :
WideCharToMultiByte( CP_ACP, 0, NameTcp, -1,
NULL, 0, NULL, NULL);
break;
case IPPROTO_UDP :
case WS_IPPROTO_UDP :
dwLength = (unicode) ? sizeof(WCHAR) * (strlenW(NameUdp)+1) :
WideCharToMultiByte( CP_ACP, 0, NameUdp, -1,
NULL, 0, NULL, NULL);
@ -97,7 +107,7 @@ static INT WSOCK32_EnterSingleProtocol( INT iProtocol,
lpBuffer->iProtocol = iProtocol;
switch (iProtocol) {
case IPPROTO_TCP :
case WS_IPPROTO_TCP :
lpBuffer->dwServiceFlags = XP_FRAGMENTATION | XP_EXPEDITED_DATA |
XP_GRACEFUL_CLOSE | XP_GUARANTEED_ORDER |
XP_GUARANTEED_DELIVERY;
@ -108,7 +118,7 @@ static INT WSOCK32_EnterSingleProtocol( INT iProtocol,
lpBuffer->dwMessageSize = 0;
lpProtName = NameTcp;
break;
case IPPROTO_UDP :
case WS_IPPROTO_UDP :
lpBuffer->dwServiceFlags = XP_FRAGMENTATION | XP_SUPPORTS_BROADCAST |
XP_SUPPORTS_MULTICAST | XP_MESSAGE_ORIENTED |
XP_CONNECTIONLESS;
@ -162,6 +172,10 @@ static INT WSOCK32_EnterSingleProtocol( INT iProtocol,
return iAnz;
}
/* FIXME: EnumProtocols should be moved to winsock2, and this should be
* implemented by calling out to WSAEnumProtocols. See:
* http://support.microsoft.com/support/kb/articles/Q129/3/15.asp
*/
/*****************************************************************************
* WSOCK32_EnumProtocol [internal]
*
@ -194,7 +208,7 @@ static INT WSOCK32_EnumProtocol( LPINT lpiProtocols, PROTOCOL_INFOA* lpBuffer,
LPDWORD lpdwLength, BOOL unicode)
{ DWORD dwCurSize, dwOldSize = *lpdwLength, dwTemp;
INT anz = 0, i;
INT iLocal[] = { IPPROTO_TCP, IPPROTO_UDP, NSPROTO_IPX, NSPROTO_SPXII, 0};
INT iLocal[] = { WS_IPPROTO_TCP, WS_IPPROTO_UDP, NSPROTO_IPX, NSPROTO_SPXII, 0};
if (!lpiProtocols) lpiProtocols = iLocal;

57
dlls/wsock32/socket.c
View File

@ -5,17 +5,23 @@
*/
/*
FIXME: This hack is fixing a problem in WsControl. When we call socket(),
it is supposed to call into ws2_32's WSOCK32_socket.
The problem is that socket() is predefined in a linux system header that
we are including, which is different from the WINE definition.
(cdecl vs. stdapi) The result is stack corruption.
/* FIXME: This hack is fixing a problem in WsControl. When we call socket(),
* it will call into ws2_32's WSOCK32_socket (because of the redirection in
* our own .spec file).
* The problem is that socket() is predefined in a linux system header that
* we are including, which is different from the WINE definition.
* (cdecl vs. stdapi). The result is stack corruption.
* Furthermore WsControl uses Unix macros and types. This forces us to include
* the Unix headers which then conflict with the winsock headers. This forces
* us to use USE_WS_PREFIX but then ioctlsocket is called WS_ioctlsocket,
* which causes link problems. The correct solution is to implement
* WsControl using calls to WSAIoctl. Then we should no longer need to use the
* Unix headers. This would also have the advantage of reducing code
* duplication.
* Until that happens we need this ugly hack.
*/
#define USE_WS_PREFIX
The correct answer to this problem is to make winsock.h not dependent
on system headers, that way all of our functions are defined consistently.
Until that happens we need this hack.
*/
#define socket linux_socket
#define recv linux_recv
/* */
@ -31,6 +37,7 @@
#include "winnt.h"
#include "wscontrol.h"
#include <ctype.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <stdlib.h>
@ -48,11 +55,15 @@
#endif
/* FIXME: The rest of the socket() cdecl<->stdapi stack corruption problem
discussed above. */
* discussed above.
*/
#undef socket
#undef recv
extern SOCKET WINAPI socket(INT af, INT type, INT protocol);
extern SOCKET WINAPI recv(SOCKET,char*,int,int);
/* Plus some missing prototypes, due to the WS_ prefixing */
extern int WINAPI closesocket(SOCKET);
extern int WINAPI ioctlsocket(SOCKET,long,u_long*);
/* */
@ -199,7 +210,7 @@ DWORD WINAPI WsControl(DWORD protocoll,
}
/* Get a socket so that we can use ioctl */
if ( (sock = socket (AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET)
if ( (sock = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET)
{
ERR ("Error creating socket!\n");
return (-1);
@ -365,7 +376,7 @@ DWORD WINAPI WsControl(DWORD protocoll,
/* Get a socket so we can use ioctl */
if ( (sock = socket (AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET)
if ( (sock = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET)
{
ERR ("Error creating socket!\n");
return (-1);
@ -380,13 +391,13 @@ DWORD WINAPI WsControl(DWORD protocoll,
/* IP Address */
strcpy (ifInfo.ifr_name, ifName);
ifInfo.ifr_addr.sa_family = AF_INET;
if (ioctlsocket(sock, SIOCGIFADDR, (ULONG*)&ifInfo) < 0)
if (ioctlsocket(sock, SIOCGIFADDR, (ULONG*)&ifInfo) < 0)
{
baseIPInfo->iae_addr = 0x0;
}
else
{
struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_addr;
struct WS_sockaddr_in* ipTemp = (struct WS_sockaddr_in*)&ifInfo.ifr_addr;
baseIPInfo->iae_addr = ipTemp->sin_addr.S_un.S_addr;
}
@ -398,8 +409,8 @@ DWORD WINAPI WsControl(DWORD protocoll,
}
else
{
struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_broadaddr;
baseIPInfo->iae_bcastaddr = ipTemp->sin_addr.S_un.S_addr;
struct WS_sockaddr_in* ipTemp = (struct WS_sockaddr_in*)&ifInfo.ifr_broadaddr;
baseIPInfo->iae_bcastaddr = ipTemp->sin_addr.S_un.S_addr;
}
/* Subnet Mask */
@ -417,12 +428,12 @@ DWORD WINAPI WsControl(DWORD protocoll,
baseIPInfo->iae_mask = 0;
ERR ("Unable to determine Netmask on your platform!\n");
#else
struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_addr;
baseIPInfo->iae_mask = ipTemp->sin_addr.S_un.S_addr;
struct WS_sockaddr_in* ipTemp = (struct WS_sockaddr_in*)&ifInfo.ifr_addr;
baseIPInfo->iae_mask = ipTemp->sin_addr.S_un.S_addr;
#endif
#else
struct ws_sockaddr_in *ipTemp = (struct ws_sockaddr_in *)&ifInfo.ifr_netmask;
baseIPInfo->iae_mask = ipTemp->sin_addr.S_un.S_addr;
#else
struct WS_sockaddr_in* ipTemp = (struct WS_sockaddr_in*)&ifInfo.ifr_netmask;
baseIPInfo->iae_mask = ipTemp->sin_addr.S_un.S_addr;
#endif
}
@ -959,7 +970,7 @@ INT WINAPI WSARecvEx(SOCKET s, char *buf, INT len, INT *flags)
/***********************************************************************
* s_perror (WSOCK32.1108)
*/
void WINAPI WS_s_perror(LPCSTR message)
void WINAPI s_perror(LPCSTR message)
{
FIXME("(%s): stub\n",message);
return;

2
dlls/wsock32/wsock32.spec
View File

@ -68,7 +68,7 @@ debug_channels (winsock)
#1105 stub sethostname
#1106 stub dn_expand
1107 stdcall WSARecvEx(long ptr long ptr) WSARecvEx
1108 stdcall s_perror(str) WS_s_perror
1108 stdcall s_perror(str) s_perror
1109 stub GetAddressByNameA
1110 stub GetAddressByNameW
1111 stdcall EnumProtocolsA(ptr ptr ptr) EnumProtocolsA

1
include/Makefile.in
View File

@ -188,6 +188,7 @@ INSTALLED_INCLUDES = \
wnaspi32.h \
wownt32.h \
ws2spi.h \
ws2tcpip.h \
wshisotp.h \
wsipx.h \
wtypes.h \

2
include/windows.h
View File

@ -35,8 +35,10 @@
#include "shellapi.h"
/* #include "winperf.h" */
#ifndef WINE_NOWINSOCK
#include "winsock2.h"
/* #include "mswsock.h" */
#endif /* WINE_NOWINSOCK */
#ifndef NOCRYPT
#include "wincrypt.h"

2
include/wine/winsock16.h
View File

@ -60,7 +60,7 @@ typedef struct WSAData16
#include "poppack.h"
#define WS_FD_CLR16(fd, set) __WS_FD_CLR((fd),(set), ws_fd_set16)
#define WS_FD_SET16(fd, set) __WS_FD_SET((fd),(set), ws_fd_set16)
#define WS_FD_SET16(fd, set) __WS_FD_SET1((fd),(set), ws_fd_set16)
#define WS_FD_ZERO16(set) (((ws_fd_set16*)(set))->fd_count=0)
#define WS_FD_ISSET16(fd, set) __WSAFDIsSet16((SOCKET16)(fd), (ws_fd_set16*)(set))

1062
include/winsock.h
View File

File diff suppressed because it is too large Load Diff

516
include/winsock2.h
View File

@ -3,166 +3,143 @@
*
* FIXME: Still missing required Winsock 2 definitions.
*/
#ifndef __WINSOCK2API__
#define __WINSOCK2API__
#ifndef _WINSOCK2API_
#define _WINSOCK2API_
/*
* Setup phase
*/
/* Everything common between winsock.h and winsock2.h */
#ifndef INCL_WINSOCK_API_PROTOTYPES
#define INCL_WINSOCK_API_PROTOTYPES 1
#define WS_API_PROTOTYPES 1
#else
#define WS_API_PROTOTYPES INCL_WINSOCK_API_PROTOTYPES
#endif
#ifndef INCL_WINSOCK_API_TYPEDEFS
#define INCL_WINSOCK_API_TYPEDEFS 0
#define WS_API_TYPEDEFS 0
#else
#define WS_API_TYPEDEFS INCL_WINSOCK_API_TYPEDEFS
#endif
#define __WINE_WINSOCK2__
#include "winsock.h"
#undef __WINE_WINSOCK2__
#ifdef __cplusplus
extern "C" {
#endif /* defined(__cplusplus) */
/* proper 4-byte packing */
#include "pshpack4.h"
#define WS_SO_GROUP_ID 0x2001
#define WS_SO_GROUP_PRIORITY 0x2002
#define WS_SO_MAX_MSG_SIZE 0x2003
#define WS_SO_PROTOCOL_INFOA 0x2004
#define WS_SO_PROTOCOL_INFOW 0x2005
#define WS_SO_PROTOCOL_INFO WINELIB_NAME_AW(WS_SO_PROTOCOL_INFO)
#define PVD_CONFIG 0x3001
#define SO_CONDITIONAL_ACCEPT 0x3002
#ifndef USE_WS_PREFIX
#define SO_GROUP_ID 0x2001
#define SO_GROUP_PRIORITY 0x2002
#define SO_MAX_MSG_SIZE 0x2003
#define SO_PROTOCOL_INFOA 0x2004
#define SO_PROTOCOL_INFOW 0x2005
#define SO_PROTOCOL_INFO WINELIB_NAME_AW(WS_SO_PROTOCOL_INFO)
#define PVD_CONFIG 0x3001
#define SO_CONDITIONAL_ACCEPT 0x3002
#else
#define WS_SO_GROUP_ID 0x2001
#define WS_SO_GROUP_PRIORITY 0x2002
#define WS_SO_MAX_MSG_SIZE 0x2003
#define WS_SO_PROTOCOL_INFOA 0x2004
#define WS_SO_PROTOCOL_INFOW 0x2005
#define WS_SO_PROTOCOL_INFO WINELIB_NAME_AW(WS_SO_PROTOCOL_INFO)
#define WS_PVD_CONFIG 0x3001
#define WS_SO_CONDITIONAL_ACCEPT 0x3002
#endif
/* option flags per socket */
#define FD_MAX_EVENTS 10
#define FD_READ_BIT 0
#define FD_WRITE_BIT 1
#define FD_OOB_BIT 2
#define FD_ACCEPT_BIT 3
#define FD_CONNECT_BIT 4
#define FD_CLOSE_BIT 5
#define FD_MAX_EVENTS 10
#define FD_READ_BIT 0
#define FD_WRITE_BIT 1
#define FD_OOB_BIT 2
#define FD_ACCEPT_BIT 3
#define FD_CONNECT_BIT 4
#define FD_CLOSE_BIT 5
/*
* Constants for WSAIoctl()
*/
#define IOC_UNIX 0x00000000
#define IOC_WS2 0x08000000
#define IOC_PROTOCOL 0x10000000
#define IOC_VENDOR 0x18000000
#define _WSAIO(x,y) (IOC_VOID|(x)|(y))
#define _WSAIOR(x,y) (IOC_OUT|(x)|(y))
#define _WSAIOW(x,y) (IOC_IN|(x)|(y))
#define _WSAIORW(x,y) (IOC_INOUT|(x)|(y))
#define SIO_ASSOCIATE_HANDLE _WSAIOW(IOC_WS2,1)
#define SIO_ENABLE_CIRCULAR_QUEUEING _WSAIO(IOC_WS2,2)
#define SIO_FIND_ROUTE _WSAIOR(IOC_WS2,3)
#define SIO_FLUSH _WSAIO(IOC_WS2,4)
#define SIO_GET_BROADCAST_ADDRESS _WSAIOR(IOC_WS2,5)
/* Constants for LPCONDITIONPROC */
#define CF_ACCEPT 0x0000
#define CF_REJECT 0x0001
#define CF_DEFER 0x0002
/* Constants for shutdown() */
#define SD_RECEIVE 0x00
#define SD_SEND 0x01
#define SD_BOTH 0x02
/* Constants for WSAIoctl() */
#define IOC_UNIX 0x00000000
#define IOC_WS2 0x08000000
#define IOC_PROTOCOL 0x10000000
#define IOC_VENDOR 0x18000000
#define _WSAIO(x,y) (IOC_VOID|(x)|(y))
#define _WSAIOR(x,y) (IOC_OUT|(x)|(y))
#define _WSAIOW(x,y) (IOC_IN|(x)|(y))
#define _WSAIORW(x,y) (IOC_INOUT|(x)|(y))
#define SIO_ASSOCIATE_HANDLE _WSAIOW(IOC_WS2,1)
#define SIO_ENABLE_CIRCULAR_QUEUEING _WSAIO(IOC_WS2,2)
#define SIO_FIND_ROUTE _WSAIOR(IOC_WS2,3)
#define SIO_FLUSH _WSAIO(IOC_WS2,4)
#define SIO_GET_BROADCAST_ADDRESS _WSAIOR(IOC_WS2,5)
#define SIO_GET_EXTENSION_FUNCTION_POINTER _WSAIORW(IOC_WS2,6)
#define SIO_GET_QOS _WSAIORW(IOC_WS2,7)
#define SIO_GET_GROUP_QOS _WSAIORW(IOC_WS2,8)
#define SIO_MULTIPOINT_LOOPBACK _WSAIOW(IOC_WS2,9)
#define SIO_MULTICAST_SCOPE _WSAIOW(IOC_WS2,10)
#define SIO_SET_QOS _WSAIOW(IOC_WS2,11)
#define SIO_SET_GROUP_QOS _WSAIOW(IOC_WS2,12)
#define SIO_TRANSLATE_HANDLE _WSAIORW(IOC_WS2,13)
#define SIO_ROUTING_INTERFACE_QUERY _WSAIORW(IOC_WS2,20)
#define SIO_ROUTING_INTERFACE_CHANGE _WSAIOW(IOC_WS2,21)
#define SIO_ADDRESS_LIST_QUERY _WSAIOR(IOC_WS2,22)
#define SIO_ADDRESS_LIST_CHANGE _WSAIO(IOC_WS2,23)
#define SIO_QUERY_TARGET_PNP_HANDLE _WSAIOR(IOC_W32,24)
#define SIO_GET_INTERFACE_LIST WS_IOR ('t', 127, u_long)
/* Unfortunately the sockaddr_in6 structure doesn't
seem to be defined in a standard place, even across
different Linux distributions. Until IPv6 support settles
down, let's do our own here so the sockaddr_gen
union is the correct size.*/
#ifdef s6_addr
#undef s6_addr
#define SIO_GET_QOS _WSAIORW(IOC_WS2,7)
#define SIO_GET_GROUP_QOS _WSAIORW(IOC_WS2,8)
#define SIO_MULTIPOINT_LOOPBACK _WSAIOW(IOC_WS2,9)
#define SIO_MULTICAST_SCOPE _WSAIOW(IOC_WS2,10)
#define SIO_SET_QOS _WSAIOW(IOC_WS2,11)
#define SIO_SET_GROUP_QOS _WSAIOW(IOC_WS2,12)
#define SIO_TRANSLATE_HANDLE _WSAIORW(IOC_WS2,13)
#define SIO_ROUTING_INTERFACE_QUERY _WSAIORW(IOC_WS2,20)
#define SIO_ROUTING_INTERFACE_CHANGE _WSAIOW(IOC_WS2,21)
#define SIO_ADDRESS_LIST_QUERY _WSAIOR(IOC_WS2,22)
#define SIO_ADDRESS_LIST_CHANGE _WSAIO(IOC_WS2,23)
#define SIO_QUERY_TARGET_PNP_HANDLE _WSAIOR(IOC_W32,24)
#ifndef USE_WS_PREFIX
#define SIO_GET_INTERFACE_LIST _IOR ('t', 127, u_long)
#else
#define SIO_GET_INTERFACE_LIST WS__IOR ('t', 127, u_long)
#endif
struct ws_in_addr6
{
unsigned char s6_addr[16]; /* IPv6 address */
};
struct ws_sockaddr_in6
{
short sin6_family; /* AF_INET6 */
u_short sin6_port; /* Transport level port number */
u_long sin6_flowinfo; /* IPv6 flow information */
struct ws_in_addr6 sin6_addr; /* IPv6 address */
};
/* Constants for WSAIoctl() */
#define WSA_FLAG_OVERLAPPED 0x01
#define WSA_FLAG_MULTIPOINT_C_ROOT 0x02
#define WSA_FLAG_MULTIPOINT_C_LEAF 0x04
#define WSA_FLAG_MULTIPOINT_D_ROOT 0x08
#define WSA_FLAG_MULTIPOINT_D_LEAF 0x10
typedef union sockaddr_gen
{
struct sockaddr Address;
struct ws_sockaddr_in AddressIn;
struct ws_sockaddr_in6 AddressIn6;
} sockaddr_gen;
/* ws_hostent, ws_protoent, ws_servent, ws_netent are 4-byte aligned here ! */
typedef struct ws_hostent32
{
char *h_name; /* official name of host */
char **h_aliases; /* alias list */
short h_addrtype; /* host address type */
short h_length; /* length of address */
char **h_addr_list; /* list of addresses from name server */
} _ws_hostent32;
typedef struct ws_protoent32
{
char *p_name; /* official protocol name */
char **p_aliases; /* alias list */
short p_proto; /* protocol # */
} _ws_protoent32;
typedef struct ws_servent32
{
char *s_name; /* official service name */
char **s_aliases; /* alias list */
short s_port; /* port # */
char *s_proto; /* protocol to use */
} _ws_servent32;
typedef struct ws_netent32
{
char *n_name; /* official name of net */
char **n_aliases; /* alias list */
short n_addrtype; /* net address type */
u_long n_net; /* network # */
} _ws_netent32;
/* Structure to keep interface specific information */
typedef struct _INTERFACE_INFO
{
u_long iiFlags; /* Interface flags */
sockaddr_gen iiAddress; /* Interface address */
sockaddr_gen iiBroadcastAddress; /* Broadcast address */
sockaddr_gen iiNetmask; /* Network mask */
} INTERFACE_INFO, * LPINTERFACE_INFO;
/* Possible flags for the iiFlags - bitmask */
#ifndef HAVE_NET_IF_H
# define IFF_UP 0x00000001 /* Interface is up */
# define IFF_BROADCAST 0x00000002 /* Broadcast is supported */
# define IFF_LOOPBACK 0x00000004 /* this is loopback interface */
# define IFF_POINTTOPOINT 0x00000008 /* this is point-to-point interface */
# define IFF_MULTICAST 0x00000010 /* multicast is supported */
#endif
#ifndef GUID_DEFINED
#include "guiddef.h"
#endif
#define MAX_PROTOCOL_CHAIN 7
#define BASE_PROTOCOL 1
#define LAYERED_PROTOCOL 0
#define MAX_PROTOCOL_CHAIN 7
#define BASE_PROTOCOL 1
#define LAYERED_PROTOCOL 0
typedef struct _WSAPROTOCOLCHAIN
typedef struct _WSAPROTOCOLCHAIN
{
int ChainLen; /* the length of the chain, */
/* length = 0 means layered protocol, */
/* length = 1 means base protocol, */
/* length > 1 means protocol chain */
DWORD ChainEntries[MAX_PROTOCOL_CHAIN]; /* a list of dwCatalogEntryIds */
int ChainLen; /* the length of the chain, */
/* length = 0 means layered protocol, */
/* length = 1 means base protocol, */
/* length > 1 means protocol chain */
DWORD ChainEntries[MAX_PROTOCOL_CHAIN]; /* a list of dwCatalogEntryIds */
} WSAPROTOCOLCHAIN, * LPWSAPROTOCOLCHAIN;
#define WSAPROTOCOL_LEN 255
typedef struct _WSAPROTOCOL_INFOA
#define WSAPROTOCOL_LEN 255
typedef struct _WSAPROTOCOL_INFOA
{
DWORD dwServiceFlags1;
DWORD dwServiceFlags2;
@ -183,7 +160,7 @@ typedef struct _WSAPROTOCOL_INFOA
int iSecurityScheme;
DWORD dwMessageSize;
DWORD dwProviderReserved;
CHAR szProtocol[WSAPROTOCOL_LEN+1];
CHAR szProtocol[WSAPROTOCOL_LEN+1];
} WSAPROTOCOL_INFOA, * LPWSAPROTOCOL_INFOA;
typedef struct _WSAPROTOCOL_INFOW
@ -207,51 +184,270 @@ typedef struct _WSAPROTOCOL_INFOW
int iSecurityScheme;
DWORD dwMessageSize;
DWORD dwProviderReserved;
WCHAR szProtocol[WSAPROTOCOL_LEN+1];
} WSAPROTOCOL_INFOW, * LPWSAPROTOCOL_INFOW;
WCHAR szProtocol[WSAPROTOCOL_LEN+1];
} WSAPROTOCOL_INFOW, *LPWSAPROTOCOL_INFOW;
DECL_WINELIB_TYPE_AW(WSAPROTOCOL_INFO)
DECL_WINELIB_TYPE_AW(LPWSAPROTOCOL_INFO)
typedef struct _WSANETWORKEVENTS
typedef struct _WSANETWORKEVENTS
{
long lNetworkEvents;
int iErrorCode[FD_MAX_EVENTS];
long lNetworkEvents;
int iErrorCode[FD_MAX_EVENTS];
} WSANETWORKEVENTS, *LPWSANETWORKEVENTS;
typedef struct _WSABUF
typedef struct _WSABUF
{
ULONG len;
CHAR* buf;
} WSABUF, *LPWSABUF;
typedef struct _OVERLAPPED * LPWSAOVERLAPPED;
typedef HANDLE WSAEVENT;
#define WSAEVENT HANDLE
#define LPWSAEVENT LPHANDLE
#define WSAOVERLAPPED OVERLAPPED
typedef struct _OVERLAPPED* LPWSAOVERLAPPED;
#define WSA_IO_PENDING (ERROR_IO_PENDING)
#define WSA_IO_INCOMPLETE (ERROR_IO_INCOMPLETE)
#define WSA_INVALID_HANDLE (ERROR_INVALID_HANDLE)
#define WSA_INVALID_PARAMETER (ERROR_INVALID_PARAMETER)
#define WSA_NOT_ENOUGH_MEMORY (ERROR_NOT_ENOUGH_MEMORY)
#define WSA_OPERATION_ABORTED (ERROR_OPERATION_ABORTED)
#define WSA_INVALID_EVENT ((WSAEVENT)NULL)
#define WSA_MAXIMUM_WAIT_EVENTS (MAXIMUM_WAIT_OBJECTS)
#define WSA_WAIT_FAILED ((DWORD)-1L)
#define WSA_WAIT_EVENT_0 (WAIT_OBJECT_0)
#define WSA_WAIT_IO_COMPLETION (WAIT_IO_COMPLETION)
#define WSA_WAIT_TIMEOUT (WAIT_TIMEOUT)
#define WSA_INFINITE (INFINITE)
typedef unsigned int GROUP;
#define SG_UNCONSTRAINED_GROUP 0x01
#define SG_CONSTRAINED_GROUP 0x02
/* FIXME: We don't yet have qos.h */
typedef DWORD QOS, *LPQOS;
typedef int CALLBACK (*LPCONDITIONPROC)
(
LPWSABUF lpCallerId,
LPWSABUF lpCallerData,
LPQOS lpSQOS,
LPQOS lpGQOS,
LPWSABUF lpCalleeId,
LPWSABUF lpCalleeData,
GROUP *g,
DWORD dwCallbackData
);
typedef void CALLBACK (*LPWSAOVERLAPPED_COMPLETION_ROUTINE)
(
DWORD dwError,
DWORD cbTransferred,
LPWSAOVERLAPPED lpOverlapped,
DWORD dwFlags
DWORD dwError,
DWORD cbTransferred,
LPWSAOVERLAPPED lpOverlapped,
DWORD dwFlags
);
/* Function declarations */
int WINAPI WSAEnumNetworkEvents(SOCKET s, WSAEVENT hEventObject, LPWSANETWORKEVENTS lpNetworkEvents);
int WINAPI WSAEventSelect(SOCKET s, WSAEVENT hEventObject, long lNetworkEvents);
/*
* Winsock Function Typedefs
*
* Remember to keep this section in sync with the
* "Prototypes" section in winsock.h.
*/
#if WS_API_TYPEDEFS
typedef HANDLE (WINAPI *LPFN_WSAASYNCGETHOSTBYADDR)(HWND,u_int,const char*,int,int,char*,int));
typedef HANDLE (WINAPI *LPFN_WSAASYNCGETHOSTBYNAME)(HWND,u_int,const char*,char*,int));
typedef HANDLE (WINAPI *LPFN_WSAASYNCGETPROTOBYNAME)(HWND,u_int,const char*,char*,int));
typedef HANDLE (WINAPI *LPFN_WSAASYNCGETPROTOBYNUMBER)(HWND,u_int,int,char*,int));
typedef HANDLE (WINAPI *LPFN_WSAASYNCGETSERVBYNAME)(HWND,u_int,const char*,const char*,char*,int));
typedef HANDLE (WINAPI *LPFN_WSAASYNCGETSERVBYPORT)(HWND,u_int,int,const char*,char*,int));
typedef int (WINAPI *LPFN_WSAASYNCSELECT)(SOCKET,HWND,u_int,long));
typedef int (WINAPI *LPFN_WSACANCELASYNCREQUEST)(HANDLE));
typedef int (WINAPI *LPFN_WSACANCELBLOCKINGCALL)(void));
typedef int (WINAPI *LPFN_WSACLEANUP)(void));
typedef int (WINAPI *LPFN_WSAGETLASTERROR)(void));
typedef BOOL (WINAPI *LPFN_WSAISBLOCKING)(void));
typedef FARPROC (WINAPI *LPFN_WSASETBLOCKINGHOOK)(FARPROC));
typedef void (WINAPI *LPFN_WSASETLASTERROR)(int));
typedef int (WINAPI *LPFN_WSASTARTUP)(WORD,LPWSADATA));
typedef int (WINAPI *LPFN_WSAUNHOOKBLOCKINGHOOK)(void));
typedef SOCKET (WINAPI *LPFN_ACCEPT)(SOCKET,struct WS(sockaddr)*,int*));
typedef int (WINAPI *LPFN_BIND)(SOCKET,const struct WS(sockaddr)*,int));
typedef int (WINAPI *LPFN_CLOSESOCKET)(SOCKET));
typedef int (WINAPI *LPFN_CONNECT)(SOCKET,const struct WS(sockaddr)*,int));
typedef struct WS(hostent)* (WINAPI *LPFN_GETHOSTBYADDR)(const char*,int,int));
typedef struct WS(hostent)* (WINAPI *LPFN_GETHOSTBYNAME)(const char*));
typedef int (WINAPI *LPFN_GETHOSTNAME)(char*,int));
typedef int (WINAPI *LPFN_GETPEERNAME)(SOCKET,struct WS(sockaddr)*,int*));
typedef struct WS(protoent)* (WINAPI *LPFN_GETPROTOBYNAME)(const char*));
typedef struct WS(protoent)* (WINAPI *LPFN_GETPROTOBYNUMBER)(int));
#ifdef WS_DEFINE_SELECT
typedef int (WINAPI* LPFN_SELECT)(int,WS(fd_set)*,WS(fd_set)*,WS(fd_set)*,const struct WS(timeval)*);
#endif
typedef struct WS(servent)* (WINAPI *LPFN_GETSERVBYNAME)(const char*,const char*));
typedef struct WS(servent)* (WINAPI *LPFN_GETSERVBYPORT)(int,const char*));
typedef int (WINAPI *LPFN_GETSOCKNAME)(SOCKET,struct WS(sockaddr)*,int*));
typedef int (WINAPI *LPFN_GETSOCKOPT)(SOCKET,int,int,char*,int*));
typedef u_long (WINAPI *LPFN_HTONL)(u_long));
typedef u_short (WINAPI *LPFN_HTONS)(u_short));
typedef unsigned long (WINAPI *LPFN_INET_ADDR)(const char*);
typedef char* (WINAPI *LPFN_INET_NTOA)(struct WS(in_addr));
typedef int (WINAPI *LPFN_IOCTLSOCKET)(SOCKET,long,u_long*));
typedef int (WINAPI *LPFN_LISTEN)(SOCKET,int));
typedef u_long (WINAPI *LPFN_NTOHL)(u_long));
typedef u_short (WINAPI *LPFN_NTOHS)(u_short));
typedef int (WINAPI *LPFN_RECV)(SOCKET,char*,int,int));
typedef int (WINAPI *LPFN_RECVFROM)(SOCKET,char*,int,int,struct WS(sockaddr)*,int*));
typedef int (WINAPI *LPFN_SEND)(SOCKET,const char*,int,int));
typedef int (WINAPI *LPFN_SENDTO)(SOCKET,const char*,int,int,const struct WS(sockaddr)*,int));
typedef int (WINAPI *LPFN_SETSOCKOPT)(SOCKET,int,int,const char*,int));
typedef int (WINAPI *LPFN_SHUTDOWN)(SOCKET,int));
typedef SOCKET (WINAPI *LPFN_SOCKET)(int,int,int));
#endif /* WS_API_TYPEDEFS */
/*
* Winsock2 Prototypes
*
* Remember to keep this section in sync with the
* "Winsock2 Function Typedefs" section below.
*/
#if WS_API_PROTOTYPES
SOCKET WINAPI WSAAccept(SOCKET,struct WS(sockaddr)*,LPINT,LPCONDITIONPROC,DWORD);
INT WINAPI WSAAddressToStringA(LPSOCKADDR,DWORD,LPWSAPROTOCOL_INFOA,LPSTR,LPDWORD);
INT WINAPI WSAAddressToStringW(LPSOCKADDR,DWORD,LPWSAPROTOCOL_INFOW,LPWSTR,LPDWORD);
#define WSAAddressToString WINELIB_NAME_AW(WSAAddressToString)
BOOL WINAPI WSACloseEvent(WSAEVENT);
int WINAPI WSAConnect(SOCKET,const struct WS(sockaddr)*,int,LPWSABUF,LPWSABUF,LPQOS,LPQOS);
WSAEVENT WINAPI WSACreateEvent(void);
BOOL WINAPI WSACloseEvent(WSAEVENT event);
INT WINAPI WSARecvFrom(SOCKET,LPWSABUF,DWORD,LPDWORD,LPDWORD,struct sockaddr*,LPINT,
LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
INT WINAPI WSASend(SOCKET,LPWSABUF,DWORD,LPDWORD,DWORD,LPWSAOVERLAPPED,
LPWSAOVERLAPPED_COMPLETION_ROUTINE);
SOCKET WINAPI WSASocketA(int af, int type, int protocol,
LPWSAPROTOCOL_INFOA lpProtocolInfo,
GROUP g, DWORD dwFlags);
INT WINAPI ioctlsocket(SOCKET s, LONG cmd, ULONG *argp);
/* WSADuplicateSocketA */
/* WSADuplicateSocketW */
/* WSAEnumNameSpaceProvidersA */
/* WSAEnumNameSpaceProvidersW */
int WINAPI WSAEnumNetworkEvents(SOCKET,WSAEVENT,LPWSANETWORKEVENTS);
int WINAPI WSAEnumProtocolsA(LPINT,LPWSAPROTOCOL_INFOA,LPDWORD);
int WINAPI WSAEnumProtocolsW(LPINT,LPWSAPROTOCOL_INFOW,LPDWORD);
#define WSAEnumProtocols WINELIB_NAME_AW(WSAEnumProtocols)
int WINAPI WSAEventSelect(SOCKET,WSAEVENT,long);
BOOL WINAPI WSAGetOverlappedResult(SOCKET,LPWSAOVERLAPPED,LPDWORD,BOOL,LPDWORD);
/* WSAGetQOSByName */
/* WSAGetServiceClassInfoA */
/* WSAGetServiceClassInfoW */
/* WSAGetServiceClassNameByClassIdA */
/* WSAGetServiceClassNameByClassIdW */
int WINAPI WSAHtonl(SOCKET,u_long,u_long*);
int WINAPI WSAHtons(SOCKET,u_short,u_short*);
/* WSAInstallServiceClassA */
/* WSAInstallServiceClassW */
int WINAPI WSAIoctl(SOCKET,DWORD,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
/* WSAJoinLeaf */
/* WSALookupServiceBeginA */
/* WSALookupServiceBeginW */
/* WSALookupServiceEnd */
/* WSALookupServiceNextA */
/* WSALookupServiceNextW */
int WINAPI WSANtohl(SOCKET,u_long,u_long*);
int WINAPI WSANtohs(SOCKET,u_short,u_short*);
/* WSAProviderConfigChange */
int WINAPI WSARecv(SOCKET,LPWSABUF,DWORD,LPDWORD,LPDWORD,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
int WINAPI WSARecvDisconnect(SOCKET,LPWSABUF);
int WINAPI WSARecvFrom(SOCKET,LPWSABUF,DWORD,LPDWORD,LPDWORD,struct WS(sockaddr)*,LPINT,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
/* WSARemoveServiceClass */
BOOL WINAPI WSAResetEvent(WSAEVENT);
int WINAPI WSASend(SOCKET,LPWSABUF,DWORD,LPDWORD,DWORD,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
int WINAPI WSASendDisconnect(SOCKET,LPWSABUF);
int WINAPI WSASendTo(SOCKET,LPWSABUF,DWORD,LPDWORD,DWORD,const struct WS(sockaddr)*,int,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
BOOL WINAPI WSASetEvent(WSAEVENT);
/* WSASetServiceA */
/* WSASetServiceW */
SOCKET WINAPI WSASocketA(int,int,int,LPWSAPROTOCOL_INFOA,GROUP,DWORD);
SOCKET WINAPI WSASocketW(int,int,int,LPWSAPROTOCOL_INFOW,GROUP,DWORD);
INT WINAPI WSAStringToAddressA(LPSTR,INT,LPWSAPROTOCOL_INFOA,LPSOCKADDR,LPINT);
INT WINAPI WSAStringToAddressW(LPSTR,INT,LPWSAPROTOCOL_INFOA,LPSOCKADDR,LPINT);
#define WSASocket WINELIB_NAME_AW(WSASocket)
#define WSAStringToAddress WINELIB_NAME_AW(WSAStringToAddress)
DWORD WINAPI WSAWaitForMultipleEvents(DWORD,const WSAEVENT*,BOOL,DWORD,BOOL);
#endif /* WS_API_PROTOTYPES */
/*
* Winsock2 Function Typedefs
*
* Remember to keep this section in sync with the
* "Winsock2 Prototypes" section above.
*/
#if WS_API_TYPEDEFS
typedef SOCKET (WINAPI *LPFN_WSAACCEPT)(SOCKET,WS(sockaddr)*,LPINT,LPCONDITIONPROC,DWORD);
typedef INT (WINAPI *LPFN_WSAADRESSTOSTRINGA)(LPSOCKADDR,DWORD,LPWSAPROTOCOL_INFOA,LPSTR,LPDWORD);
typedef INT (WINAPI *LPFN_WSAADRESSTOSTRINGW)(LPSOCKADDR,DWORD,LPWSAPROTOCOL_INFOW,LPWSTR,LPDWORD);
#define LPFN_WSAADDRESSTOSTRING WINELIB_NAME_AW(LPFN_WSAADDRESSTOSTRING)
typedef BOOL (WINAPI *LPFN_WSACLOSEEVENT)(WSAEVENT);
typedef int (WINAPI *LPFN_WSACONNECT)(SOCKET,const struct WS(sockaddr)*,int,LPWSABUF,LPWSABUF,LPQOS,LPQOS);
typedef WSAEVENT (WINAPI *LPFN_WSACREATEEVENT)(void);
/* WSADuplicateSocketA */
/* WSADuplicateSocketW */
/* WSAEnumNameSpaceProvidersA */
/* WSAEnumNameSpaceProvidersW */
typedef int (WINAPI *LPFN_WSAENUMNETWORKEVENT)(SOCKET,WSAEVENT,LPWSANETWORKEVENTS);
typedef int (WINAPI *LPFN_WSAENUMPROTOCOLSA)(LPINT,LPWSAPROTOCOL_INFOA,LPDWORD);
typedef int (WINAPI *LPFN_WSAENUMPROTOCOLSW)(LPINT,LPWSAPROTOCOL_INFOW,LPDWORD);
#define LPFN_WSAENUMPROTOCOLS WINELIB_NAME_AW(LPFN_WSAENUMPROTOCOLS)
typedef int (WINAPI *LPFN_WSAEVENTSELECT)(SOCKET,WSAEVENT,long);
typedef BOOL (WINAPI *LPFN_WSAGETOVERLAPPEDRESULT)(SOCKET,LPWSAOVERLAPPED,LPDWORD,BOOL,LPDWORD);
/* WSAGetQOSByName */
/* WSAGetServiceClassInfoA */
/* WSAGetServiceClassInfoW */
/* WSAGetServiceClassNameByClassIdA */
/* WSAGetServiceClassNameByClassIdW */
typedef int (WINAPI *LPFN_WSAHTONL)(SOCKET,u_long,u_long*);
typedef int (WINAPI *LPFN_WSAHTONS)(SOCKET,u_short,u_short*);
/* WSAInstallServiceClassA */
/* WSAInstallServiceClassW */
typedef int (WINAPI *LPFN_WSAIOCTL)(SOCKET,DWORD,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
/* WSAJoinLeaf */
/* WSALookupServiceBeginA */
/* WSALookupServiceBeginW */
/* WSALookupServiceEnd */
/* WSALookupServiceNextA */
/* WSALookupServiceNextW */
typedef int (WINAPI *LPFN_WSANTOHL)(SOCKET,u_long,u_long*);
typedef int (WINAPI *LPFN_WSANTOHS)(SOCKET,u_short,u_short*);
/* WSAProviderConfigChange */
typedef int (WINAPI *LPFN_WSARECV)(SOCKET,LPWSABUF,DWORD,LPDWORD,LPDWORD,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
typedef int (WINAPI *LPFN_WSARECVDISCONNECT)(SOCKET,LPWSABUF);
typedef int (WINAPI *LPFN_WSARECVFROM)(SOCKET,LPWSABUF,DWORD,LPDWORD,LPDWORD,struct WS(sockaddr)*,LPINT,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
/* WSARemoveServiceClass */
typedef BOOL (WINAPI *LPFN_WSARESETEVENT)(WSAEVENT);
typedef int (WINAPI *LPFN_WSASEND)(SOCKET,LPWSABUF,DWORD,LPDWORD,DWORD,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
typedef int (WINAPI *LPFN_WSASENDDISCONNECT)(SOCKET,LPWSABUF);
typedef int (WINAPI *LPFN_WSASENDTO)(SOCKET,LPWSABUF,DWORD,LPDWORD,DWORD,const struct WS(sockaddr)*,int,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE);
typedef BOOL (WINAPI *LPFN_WSASETEVENT)(WSAEVENT);
/* WSASetServiceA */
/* WSASetServiceW */
typedef SOCKET (WINAPI *LPFN_WSASOCKETA)(int,int,int,LPWSAPROTOCOL_INFOA,GROUP,DWORD);
typedef SOCKET (WINAPI *LPFN_WSASOCKETW)(int,int,int,LPWSAPROTOCOL_INFOW,GROUP,DWORD);
typedef INT (WINAPI *LPFN_WSASTRINGTOADDRESSA)(LPSTR,INT,LPWSAPROTOCOL_INFOA,LPSOCKADDR,LPINT);
typedef INT (WINAPI *LPFN_WSASTRINGTOADDRESSW)(LPSTR,INT,LPWSAPROTOCOL_INFOA,LPSOCKADDR,LPINT);
#define LPFN_WSASOCKET WINELIB_NAME_AW(LPFN_WSASOCKET)
#define LPFN_WSASTRINGTOADDRESS WINELIB_NAME_AW(LPFN_WSASTRINGTOADDRESS)
typedef DWORD (WINAPI *LPFN_WSAWAITFORMULTIPLEEVENTS)(DWORD,const WSAEVENT*,BOOL,DWORD,BOOL);
#endif /* WS_API_TYPEDEFS */
#include "poppack.h"
#ifdef __cplusplus
}
#endif
#undef WS
#undef WS_API_PROTOTYPES
#undef WS_API_TYPEDEFS
#endif /* __WINSOCK2API__ */

57
include/ws2tcpip.h 100644
View File

@ -0,0 +1,57 @@
#ifndef __WS2TCPIP__
#define __WS2TCPIP__
#ifdef USE_WS_PREFIX
#define WS(x) WS_##x
#else
#define WS(x) x
#endif
/* FIXME: This gets defined by some Unix (Linux) header and messes things */
#undef s6_addr
typedef struct WS(in_addr6)
{
u_char s6_addr[16]; /* IPv6 address */
} IN6_ADDR, *PIN6_ADDR, *LPIN6_ADDR;
typedef struct WS(sockaddr_in6)
{
short sin6_family; /* AF_INET6 */
u_short sin6_port; /* Transport level port number */
u_long sin6_flowinfo; /* IPv6 flow information */
struct WS(in_addr6) sin6_addr; /* IPv6 address */
} SOCKADDR_IN6,*PSOCKADDR_IN6, *LPSOCKADDR_IN6;
typedef union sockaddr_gen
{
struct WS(sockaddr) Address;
struct WS(sockaddr_in) AddressIn;
struct WS(sockaddr_in6) AddressIn6;
} WS(sockaddr_gen);
/* Structure to keep interface specific information */
typedef struct _INTERFACE_INFO
{
u_long iiFlags; /* Interface flags */
WS(sockaddr_gen) iiAddress; /* Interface address */
WS(sockaddr_gen) iiBroadcastAddress; /* Broadcast address */
WS(sockaddr_gen) iiNetmask; /* Network mask */
} INTERFACE_INFO, * LPINTERFACE_INFO;
/* Possible flags for the iiFlags - bitmask */
#ifndef USE_WS_PREFIX
#define IFF_UP 0x00000001 /* Interface is up */
#define IFF_BROADCAST 0x00000002 /* Broadcast is supported */
#define IFF_LOOPBACK 0x00000004 /* this is loopback interface */
#define IFF_POINTTOPOINT 0x00000008 /* this is point-to-point interface */
#define IFF_MULTICAST 0x00000010 /* multicast is supported */
#else
#define WS_IFF_UP 0x00000001 /* Interface is up */
#define WS_IFF_BROADCAST 0x00000002 /* Broadcast is supported */
#define WS_IFF_LOOPBACK 0x00000004 /* this is loopback interface */
#define WS_IFF_POINTTOPOINT 0x00000008 /* this is point-to-point interface */
#define WS_IFF_MULTICAST 0x00000010 /* multicast is supported */
#endif /* USE_WS_PREFIX */
#endif /* __WS2TCPIP__ */

24
include/wsipx.h
View File

@ -1,14 +1,16 @@
/* WCIPX.H
/* WSIPX.H
*/
#ifndef _WINE_WSIPX_
#define _WINE_WSIPX_
#ifdef __cplusplus
extern "C" {
#endif /* defined(__cplusplus) */
#ifdef USE_WS_PREFIX
# define WS(x) WS_##x
#else
# define WS(x) x
#endif
typedef struct ws_sockaddr_ipx
typedef struct WS_sockaddr_ipx
{
short sa_family;
char sa_netnum[4];
@ -19,13 +21,9 @@ typedef struct ws_sockaddr_ipx
/*
* constants
*/
#define NSPROTO_IPX 1000
#define NSPROTO_SPX 1256
#define NSPROTO_SPXII 1257
#ifdef __cplusplus
} /* extern "C" */
#endif /* defined(__cplusplus) */
#define NSPROTO_IPX 1000
#define NSPROTO_SPX 1256
#define NSPROTO_SPXII 1257
#undef WS
#endif /* _WINE_WSIPX_ */

7
server/sock.c
View File

@ -32,12 +32,17 @@
#include "winerror.h"
#include "winbase.h"
#include "winsock2.h"
#include "process.h"
#include "handle.h"
#include "thread.h"
#include "request.h"
/* To avoid conflicts with the Unix socket headers. Plus we only need a few
* macros anyway.
*/
#define USE_WS_PREFIX
#include "winsock2.h"
struct sock
{
struct object obj; /* object header */