From 101cc8747f767344d38566bd229f1761ad96f744 Mon Sep 17 00:00:00 2001 From: seyko Date: Thu, 14 May 2015 01:27:46 +0300 Subject: [PATCH] win32/include/winapi changes from https://github.com/run4flat/tinycc.git just for testing. Is it needed? I'm not a MSYS citizen. run4flat is a tcc fork by David Mertens that knows how to work with multiple symbol tables. Excelent work. A good descriptions of the tcc internals inside a code comments. --- win32/include/math.h | 34 - win32/include/winapi/_bsd_types.h | 21 + win32/include/winapi/_mingw_unicode.h | 33 + win32/include/winapi/_timeval.h | 23 + win32/include/winapi/in6addr.h | 28 + win32/include/winapi/inaddr.h | 27 + win32/include/winapi/mstcpip.h | 195 +++ win32/include/winapi/psdk_inc/_fd_types.h | 26 + win32/include/winapi/psdk_inc/_ip_mreq1.h | 18 + win32/include/winapi/psdk_inc/_ip_types.h | 104 ++ win32/include/winapi/psdk_inc/_socket_types.h | 20 + win32/include/winapi/psdk_inc/_ws1_undef.h | 248 ++++ win32/include/winapi/psdk_inc/_wsa_errnos.h | 225 +++ win32/include/winapi/psdk_inc/_wsadata.h | 32 + win32/include/winapi/qos.h | 72 + win32/include/winapi/winsock2.h | 1253 +++++++++++++++++ win32/include/winapi/ws2def.h | 39 + win32/include/winapi/ws2ipdef.h | 94 ++ win32/include/winapi/ws2tcpip.h | 437 ++++++ 19 files changed, 2895 insertions(+), 34 deletions(-) create mode 100644 win32/include/winapi/_bsd_types.h create mode 100644 win32/include/winapi/_mingw_unicode.h create mode 100644 win32/include/winapi/_timeval.h create mode 100644 win32/include/winapi/in6addr.h create mode 100644 win32/include/winapi/inaddr.h create mode 100644 win32/include/winapi/mstcpip.h create mode 100644 win32/include/winapi/psdk_inc/_fd_types.h create mode 100644 win32/include/winapi/psdk_inc/_ip_mreq1.h create mode 100644 win32/include/winapi/psdk_inc/_ip_types.h create mode 100644 win32/include/winapi/psdk_inc/_socket_types.h create mode 100644 win32/include/winapi/psdk_inc/_ws1_undef.h create mode 100644 win32/include/winapi/psdk_inc/_wsa_errnos.h create mode 100644 win32/include/winapi/psdk_inc/_wsadata.h create mode 100644 win32/include/winapi/qos.h create mode 100644 win32/include/winapi/winsock2.h create mode 100644 win32/include/winapi/ws2def.h create mode 100644 win32/include/winapi/ws2ipdef.h create mode 100644 win32/include/winapi/ws2tcpip.h diff --git a/win32/include/math.h b/win32/include/math.h index 5048ef99..251d3f7c 100644 --- a/win32/include/math.h +++ b/win32/include/math.h @@ -777,39 +777,5 @@ extern "C++" { * which always returns true: yes, (NaN != NaN) is true). */ -#if __GNUC__ >= 3 - -#define isgreater(x, y) __builtin_isgreater(x, y) -#define isgreaterequal(x, y) __builtin_isgreaterequal(x, y) -#define isless(x, y) __builtin_isless(x, y) -#define islessequal(x, y) __builtin_islessequal(x, y) -#define islessgreater(x, y) __builtin_islessgreater(x, y) -#define isunordered(x, y) __builtin_isunordered(x, y) - -#else -/* helper */ -__CRT_INLINE int __cdecl -__fp_unordered_compare (long double x, long double y){ - unsigned short retval; - __asm__ ("fucom %%st(1);" - "fnstsw;": "=a" (retval) : "t" (x), "u" (y)); - return retval; -} - -#define isgreater(x, y) ((__fp_unordered_compare(x, y) \ - & 0x4500) == 0) -#define isless(x, y) ((__fp_unordered_compare (y, x) \ - & 0x4500) == 0) -#define isgreaterequal(x, y) ((__fp_unordered_compare (x, y) \ - & FP_INFINITE) == 0) -#define islessequal(x, y) ((__fp_unordered_compare(y, x) \ - & FP_INFINITE) == 0) -#define islessgreater(x, y) ((__fp_unordered_compare(x, y) \ - & FP_SUBNORMAL) == 0) -#define isunordered(x, y) ((__fp_unordered_compare(x, y) \ - & 0x4500) == 0x4500) - -#endif - #endif /* End _MATH_H_ */ diff --git a/win32/include/winapi/_bsd_types.h b/win32/include/winapi/_bsd_types.h new file mode 100644 index 00000000..c1196666 --- /dev/null +++ b/win32/include/winapi/_bsd_types.h @@ -0,0 +1,21 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef _BSDTYPES_DEFINED +#define _BSDTYPES_DEFINED + +typedef unsigned char u_char; +typedef unsigned short u_short; +typedef unsigned int u_int; +typedef unsigned long u_long; +#if defined(__GNUC__) || \ + defined(__GNUG__) +__extension__ +#endif /* gcc / g++ */ +typedef unsigned long long u_int64; + +#endif /* _BSDTYPES_DEFINED */ + diff --git a/win32/include/winapi/_mingw_unicode.h b/win32/include/winapi/_mingw_unicode.h new file mode 100644 index 00000000..38334bc7 --- /dev/null +++ b/win32/include/winapi/_mingw_unicode.h @@ -0,0 +1,33 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#if !defined(_INC_CRT_UNICODE_MACROS) +/* _INC_CRT_UNICODE_MACROS defined based on UNICODE flag */ + +#if defined(UNICODE) +# define _INC_CRT_UNICODE_MACROS 1 +# define __MINGW_NAME_AW(func) func##W +# define __MINGW_NAME_AW_EXT(func,ext) func##W##ext +# define __MINGW_NAME_UAW(func) func##_W +# define __MINGW_NAME_UAW_EXT(func,ext) func##_W_##ext +# define __MINGW_STRING_AW(str) L##str /* same as TEXT() from winnt.h */ +# define __MINGW_PROCNAMEEXT_AW "W" +#else +# define _INC_CRT_UNICODE_MACROS 2 +# define __MINGW_NAME_AW(func) func##A +# define __MINGW_NAME_AW_EXT(func,ext) func##A##ext +# define __MINGW_NAME_UAW(func) func##_A +# define __MINGW_NAME_UAW_EXT(func,ext) func##_A_##ext +# define __MINGW_STRING_AW(str) str /* same as TEXT() from winnt.h */ +# define __MINGW_PROCNAMEEXT_AW "A" +#endif + +#define __MINGW_TYPEDEF_AW(type) \ + typedef __MINGW_NAME_AW(type) type; +#define __MINGW_TYPEDEF_UAW(type) \ + typedef __MINGW_NAME_UAW(type) type; + +#endif /* !defined(_INC_CRT_UNICODE_MACROS) */ diff --git a/win32/include/winapi/_timeval.h b/win32/include/winapi/_timeval.h new file mode 100644 index 00000000..407e7881 --- /dev/null +++ b/win32/include/winapi/_timeval.h @@ -0,0 +1,23 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef _TIMEVAL_DEFINED +#define _TIMEVAL_DEFINED + +struct timeval +{ + long tv_sec; + long tv_usec; +}; + +#define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec) +#define timercmp(tvp,uvp,cmp) \ + ((tvp)->tv_sec cmp (uvp)->tv_sec || \ + ((tvp)->tv_sec == (uvp)->tv_sec && (tvp)->tv_usec cmp (uvp)->tv_usec)) +#define timerclear(tvp) (tvp)->tv_sec = (tvp)->tv_usec = 0 + +#endif /* _TIMEVAL_DEFINED */ + diff --git a/win32/include/winapi/in6addr.h b/win32/include/winapi/in6addr.h new file mode 100644 index 00000000..9f20f62f --- /dev/null +++ b/win32/include/winapi/in6addr.h @@ -0,0 +1,28 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef s6_addr + +#include <_bsd_types.h> + +typedef struct in6_addr { + union { + u_char Byte[16]; + u_short Word[8]; + } u; +} IN6_ADDR, *PIN6_ADDR, *LPIN6_ADDR; + +#define in_addr6 in6_addr + +#define _S6_un u +#define _S6_u8 Byte +#define s6_addr _S6_un._S6_u8 + +#define s6_bytes u.Byte +#define s6_words u.Word + +#endif /* s6_addr */ + diff --git a/win32/include/winapi/inaddr.h b/win32/include/winapi/inaddr.h new file mode 100644 index 00000000..f7a5492c --- /dev/null +++ b/win32/include/winapi/inaddr.h @@ -0,0 +1,27 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef s_addr + +#include <_bsd_types.h> + +typedef struct in_addr { + union { + struct { u_char s_b1, s_b2, s_b3, s_b4; } S_un_b; + struct { u_short s_w1, s_w2; } S_un_w; + u_long S_addr; + } S_un; +} IN_ADDR, *PIN_ADDR, *LPIN_ADDR; + +#define s_addr S_un.S_addr +#define s_host S_un.S_un_b.s_b2 +#define s_net S_un.S_un_b.s_b1 +#define s_imp S_un.S_un_w.s_w2 +#define s_impno S_un.S_un_b.s_b4 +#define s_lh S_un.S_un_b.s_b3 + +#endif /* s_addr */ + diff --git a/win32/include/winapi/mstcpip.h b/win32/include/winapi/mstcpip.h new file mode 100644 index 00000000..71e3d9f1 --- /dev/null +++ b/win32/include/winapi/mstcpip.h @@ -0,0 +1,195 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ +#ifndef _MSTCPIP_ +#define _MSTCPIP_ + +#include <_mingw_unicode.h> + +struct tcp_keepalive { + u_long onoff; + u_long keepalivetime; + u_long keepaliveinterval; +}; + +#define SIO_RCVALL _WSAIOW(IOC_VENDOR,1) +#define SIO_RCVALL_MCAST _WSAIOW(IOC_VENDOR,2) +#define SIO_RCVALL_IGMPMCAST _WSAIOW(IOC_VENDOR,3) +#define SIO_KEEPALIVE_VALS _WSAIOW(IOC_VENDOR,4) +#define SIO_ABSORB_RTRALERT _WSAIOW(IOC_VENDOR,5) +#define SIO_UCAST_IF _WSAIOW(IOC_VENDOR,6) +#define SIO_LIMIT_BROADCASTS _WSAIOW(IOC_VENDOR,7) +#define SIO_INDEX_BIND _WSAIOW(IOC_VENDOR,8) +#define SIO_INDEX_MCASTIF _WSAIOW(IOC_VENDOR,9) +#define SIO_INDEX_ADD_MCAST _WSAIOW(IOC_VENDOR,10) +#define SIO_INDEX_DEL_MCAST _WSAIOW(IOC_VENDOR,11) + +#define RCVALL_OFF 0 +#define RCVALL_ON 1 +#define RCVALL_SOCKETLEVELONLY 2 + +#if (_WIN32_WINNT >= 0x0502) +#define SOCKET_SETTINGS_GUARANTEE_ENCRYPTION 0x00000001 +#define SOCKET_SETTINGS_ALLOW_INSECURE 0x00000002 + +typedef enum _SOCKET_SECURITY_PROTOCOL { + SOCKET_SECURITY_PROTOCOL_DEFAULT, + SOCKET_SECURITY_PROTOCOL_IPSEC, + SOCKET_SECURITY_PROTOCOL_INVALID +} SOCKET_SECURITY_PROTOCOL; + +typedef enum _SOCKET_USAGE_TYPE { + SYSTEM_CRITICAL_SOCKET = 1 +} SOCKET_USAGE_TYPE; + +typedef struct _SOCKET_PEER_TARGET_NAME { + SOCKET_SECURITY_PROTOCOL SecurityProtocol; + SOCKADDR_STORAGE PeerAddress; + ULONG PeerTargetNameStringLen; + wchar_t AllStrings[]; +} SOCKET_PEER_TARGET_NAME; + +#define SOCKET_INFO_CONNECTION_SECURED 0x00000001 +#define SOCKET_INFO_CONNECTION_ENCRYPTED 0x00000002 +#define SOCKET_INFO_CONNECTION_IMPERSONATED 0x00000004 + +typedef struct _SOCKET_SECURITY_QUERY_INFO { + SOCKET_SECURITY_PROTOCOL SecurityProtocol; + ULONG Flags; + UINT64 PeerApplicationAccessTokenHandle; + UINT64 PeerMachineAccessTokenHandle; +} SOCKET_SECURITY_QUERY_INFO; + +typedef struct _SOCKET_SECURITY_QUERY_TEMPLATE { + SOCKET_SECURITY_PROTOCOL SecurityProtocol; + SOCKADDR_STORAGE PeerAddress; + ULONG PeerTokenAccessMask; +} SOCKET_SECURITY_QUERY_TEMPLATE; + +typedef struct _SOCKET_SECURITY_SETTINGS { + SOCKET_SECURITY_PROTOCOL SecurityProtocol; + ULONG SecurityFlags; +} SOCKET_SECURITY_SETTINGS; + +#define SOCKET_SETTINGS_IPSEC_SKIP_FILTER_INSTANTIATION 0x00000001 + +typedef struct _SOCKET_SECURITY_SETTINGS_IPSEC { + SOCKET_SECURITY_PROTOCOL SecurityProtocol; + ULONG SecurityFlags; + ULONG IpsecFlags; + GUID AuthipMMPolicyKey; + GUID AuthipQMPolicyKey; + GUID Reserved; + UINT64 Reserved2; + ULONG UserNameStringLen; + ULONG DomainNameStringLen; + ULONG PasswordStringLen; + wchar_t AllStrings[]; +} SOCKET_SECURITY_SETTINGS_IPSEC; + +#define RtlIpv6AddressToString __MINGW_NAME_AW(RtlIpv6AddressToString) +#define RtlIpv6AddressToStringEx __MINGW_NAME_AW(RtlIpv6AddressToStringEx) + +LPWSTR NTAPI RtlIpv6AddressToStringA( + const IN6_ADDR *Addr, + LPSTR S +); + +LPSTR NTAPI RtlIpv6AddressToStringW( + const IN6_ADDR *Addr, + LPWSTR S +); + +LONG NTAPI RtlIpv6AddressToStringExA( + const IN6_ADDR *Address, + ULONG ScopeId, + USHORT Port, + LPSTR AddressString, + PULONG AddressStringLength +); + +LONG NTAPI RtlIpv6AddressToStringExW( + const IN6_ADDR *Address, + ULONG ScopeId, + USHORT Port, + LPWSTR AddressString, + PULONG AddressStringLength +); + +#define RtlIpv4AddressToString __MINGW_NAME_AW(RtlIpv4AddressToString) +LPTSTR NTAPI RtlIpv4AddressToStringA( + const IN_ADDR *Addr, + LPSTR S +); + +LPTSTR NTAPI RtlIpv4AddressToStringW( + const IN_ADDR *Addr, + LPWSTR S +); + +#define RtlIpv4AddressToStringEx __MINGW_NAME_AW(RtlIpv4AddressToStringEx) +LONG NTAPI RtlIpv4AddressToStringExA( + const IN_ADDR *Address, + USHORT Port, + LPSTR AddressString, + PULONG AddressStringLength +); + +LONG NTAPI RtlIpv4AddressToStringExW( + const IN_ADDR *Address, + USHORT Port, + LPWSTR AddressString, + PULONG AddressStringLength +); + +#define RtlIpv4StringToAddress __MINGW_NAME_AW(RtlIpv4StringToAddress) +LONG NTAPI RtlIpv4StringToAddressA( + PCSTR S, + BOOLEAN Strict, + LPSTR *Terminator, + IN_ADDR *Addr +); + +LONG NTAPI RtlIpv4StringToAddressW( + PCWSTR S, + BOOLEAN Strict, + LPWSTR *Terminator, + IN_ADDR *Addr +); + +#define RtlIpv4StringToAddressEx __MINGW_NAME_AW(RtlIpv4StringToAddressEx) +LONG NTAPI RtlIpv4StringToAddressExA( + PCSTR AddressString, + BOOLEAN Strict, + IN_ADDR *Address, + PUSHORT Port +); + +LONG NTAPI RtlIpv4StringToAddressExW( + PCWSTR AddressString, + BOOLEAN Strict, + IN_ADDR *Address, + PUSHORT Port +); + +#define RtlIpv6StringToAddressEx __MINGW_NAME_AW(RtlIpv6StringToAddressEx) +LONG NTAPI RtlIpv6StringToAddressExA( + PCSTR AddressString, + IN6_ADDR *Address, + PULONG ScopeId, + PUSHORT Port +); + +LONG NTAPI RtlIpv6StringToAddressExW( + PCSTR AddressString, + IN6_ADDR *Address, + PULONG ScopeId, + PUSHORT Port +); + +#endif /*(_WIN32_WINNT >= 0x0502)*/ + +#endif /* _MSTCPIP_ */ + diff --git a/win32/include/winapi/psdk_inc/_fd_types.h b/win32/include/winapi/psdk_inc/_fd_types.h new file mode 100644 index 00000000..7dd796bb --- /dev/null +++ b/win32/include/winapi/psdk_inc/_fd_types.h @@ -0,0 +1,26 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef ___WSA_FD_TYPES_H +#define ___WSA_FD_TYPES_H + +#include + +#ifndef FD_SETSIZE +#define FD_SETSIZE 64 +#endif +typedef struct fd_set +{ + u_int fd_count; + SOCKET fd_array[FD_SETSIZE]; +} fd_set; + +typedef struct fd_set FD_SET; +typedef struct fd_set *PFD_SET; +typedef struct fd_set *LPFD_SET; + +#endif /* ___WSA_FD_TYPES_H */ + diff --git a/win32/include/winapi/psdk_inc/_ip_mreq1.h b/win32/include/winapi/psdk_inc/_ip_mreq1.h new file mode 100644 index 00000000..ebdbf417 --- /dev/null +++ b/win32/include/winapi/psdk_inc/_ip_mreq1.h @@ -0,0 +1,18 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef _MINGW_IP_MREQ1_H +#define _MINGW_IP_MREQ1_H + +#include + +struct ip_mreq { + struct in_addr imr_multiaddr; + struct in_addr imr_interface; +}; + +#endif /* _MINGW_IP_MREQ1_H */ + diff --git a/win32/include/winapi/psdk_inc/_ip_types.h b/win32/include/winapi/psdk_inc/_ip_types.h new file mode 100644 index 00000000..0defa74b --- /dev/null +++ b/win32/include/winapi/psdk_inc/_ip_types.h @@ -0,0 +1,104 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef _MINGW_IP_TYPES_H +#define _MINGW_IP_TYPES_H + +#include <_bsd_types.h> + +#define h_addr h_addr_list[0] + +struct hostent { + char *h_name; + char **h_aliases; + short h_addrtype; + short h_length; + char **h_addr_list; +}; + +struct netent { + char *n_name; + char **n_aliases; + short n_addrtype; + u_long n_net; +}; + +struct servent { + char *s_name; + char **s_aliases; +#ifdef _WIN64 + char *s_proto; + short s_port; +#else + short s_port; + char *s_proto; +#endif +}; + +struct protoent { + char *p_name; + char **p_aliases; + short p_proto; +}; + +typedef struct hostent HOSTENT; +typedef struct hostent *PHOSTENT; +typedef struct hostent *LPHOSTENT; + +typedef struct servent SERVENT; +typedef struct servent *PSERVENT; +typedef struct servent *LPSERVENT; + +typedef struct protoent PROTOENT; +typedef struct protoent *PPROTOENT; +typedef struct protoent *LPPROTOENT; + + +#include + +struct sockaddr_in { + short sin_family; + u_short sin_port; + struct in_addr sin_addr; + char sin_zero[8]; +}; + +struct sockaddr { + u_short sa_family; + char sa_data[14]; +}; + +struct sockproto { + u_short sp_family; + u_short sp_protocol; +}; + +struct linger { + u_short l_onoff; + u_short l_linger; +}; + +typedef struct sockaddr SOCKADDR; +typedef struct sockaddr *PSOCKADDR; +typedef struct sockaddr *LPSOCKADDR; + +typedef struct sockaddr_in SOCKADDR_IN; +typedef struct sockaddr_in *PSOCKADDR_IN; +typedef struct sockaddr_in *LPSOCKADDR_IN; + +typedef struct linger LINGER; +typedef struct linger *PLINGER; +typedef struct linger *LPLINGER; + + +#include <_timeval.h> + +typedef struct timeval TIMEVAL; +typedef struct timeval *PTIMEVAL; +typedef struct timeval *LPTIMEVAL; + +#endif /* _MINGW_IP_TYPES_H */ + diff --git a/win32/include/winapi/psdk_inc/_socket_types.h b/win32/include/winapi/psdk_inc/_socket_types.h new file mode 100644 index 00000000..429d84ec --- /dev/null +++ b/win32/include/winapi/psdk_inc/_socket_types.h @@ -0,0 +1,20 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef ___WSA_SOCKET_TYPES_H +#define ___WSA_SOCKET_TYPES_H + +#if 1 +typedef UINT_PTR SOCKET; +#else +typedef INT_PTR SOCKET; +#endif + +#define INVALID_SOCKET (SOCKET)(~0) +#define SOCKET_ERROR (-1) + +#endif /* ___WSA_SOCKET_TYPES_H */ + diff --git a/win32/include/winapi/psdk_inc/_ws1_undef.h b/win32/include/winapi/psdk_inc/_ws1_undef.h new file mode 100644 index 00000000..047ba886 --- /dev/null +++ b/win32/include/winapi/psdk_inc/_ws1_undef.h @@ -0,0 +1,248 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#undef FD_CLR +#undef FD_ZERO +#undef FD_ISSET +#undef FD_SET + +#undef IOCPARM_MASK +#undef IOC_VOID +#undef IOC_OUT +#undef IOC_IN +#undef IOC_INOUT + +#undef _IO +#undef _IOR +#undef _IOW + +#undef FIONREAD +#undef FIONBIO +#undef FIOASYNC + +#undef SIOCSHIWAT +#undef SIOCGHIWAT +#undef SIOCSLOWAT +#undef SIOCGLOWAT +#undef SIOCATMARK + +#undef IPPROTO_IP +#undef IPPROTO_ICMP +#undef IPPROTO_IGMP +#undef IPPROTO_GGP +#undef IPPROTO_TCP +#undef IPPROTO_PUP +#undef IPPROTO_UDP +#undef IPPROTO_IDP +#undef IPPROTO_ND + +#undef IPPROTO_RAW +#undef IPPROTO_MAX + +#undef IPPORT_ECHO +#undef IPPORT_DISCARD +#undef IPPORT_SYSTAT +#undef IPPORT_DAYTIME +#undef IPPORT_NETSTAT +#undef IPPORT_FTP +#undef IPPORT_TELNET +#undef IPPORT_SMTP +#undef IPPORT_TIMESERVER +#undef IPPORT_NAMESERVER +#undef IPPORT_WHOIS +#undef IPPORT_MTP + +#undef IPPORT_TFTP +#undef IPPORT_RJE +#undef IPPORT_FINGER +#undef IPPORT_TTYLINK +#undef IPPORT_SUPDUP + +#undef IPPORT_EXECSERVER +#undef IPPORT_LOGINSERVER +#undef IPPORT_CMDSERVER +#undef IPPORT_EFSSERVER + +#undef IPPORT_BIFFUDP +#undef IPPORT_WHOSERVER +#undef IPPORT_ROUTESERVER + +#undef IPPORT_RESERVED + +#undef IMPLINK_IP +#undef IMPLINK_LOWEXPER +#undef IMPLINK_HIGHEXPER + +#undef IN_CLASSA +#undef IN_CLASSA_NET +#undef IN_CLASSA_NSHIFT +#undef IN_CLASSA_HOST +#undef IN_CLASSA_MAX + +#undef IN_CLASSB +#undef IN_CLASSB_NET +#undef IN_CLASSB_NSHIFT +#undef IN_CLASSB_HOST +#undef IN_CLASSB_MAX + +#undef IN_CLASSC +#undef IN_CLASSC_NET +#undef IN_CLASSC_NSHIFT +#undef IN_CLASSC_HOST + +#undef INADDR_ANY +#undef INADDR_LOOPBACK +#undef INADDR_BROADCAST +#undef INADDR_NONE + +#undef IP_OPTIONS +#undef IP_MULTICAST_IF +#undef IP_MULTICAST_TTL +#undef IP_MULTICAST_LOOP +#undef IP_ADD_MEMBERSHIP +#undef IP_DROP_MEMBERSHIP +#undef IP_TTL +#undef IP_TOS +#undef IP_DONTFRAGMENT + +#undef IP_DEFAULT_MULTICAST_TTL +#undef IP_DEFAULT_MULTICAST_LOOP +#undef IP_MAX_MEMBERSHIPS + +#undef SOCK_STREAM +#undef SOCK_DGRAM +#undef SOCK_RAW +#undef SOCK_RDM +#undef SOCK_SEQPACKET + +#undef SO_DEBUG +#undef SO_ACCEPTCONN +#undef SO_REUSEADDR +#undef SO_KEEPALIVE +#undef SO_DONTROUTE +#undef SO_BROADCAST +#undef SO_USELOOPBACK +#undef SO_LINGER +#undef SO_OOBINLINE + +#undef SO_DONTLINGER + +#undef SO_SNDBUF +#undef SO_RCVBUF +#undef SO_SNDLOWAT +#undef SO_RCVLOWAT +#undef SO_SNDTIMEO +#undef SO_RCVTIMEO +#undef SO_ERROR +#undef SO_TYPE + +#undef SO_CONNDATA +#undef SO_CONNOPT +#undef SO_DISCDATA +#undef SO_DISCOPT +#undef SO_CONNDATALEN +#undef SO_CONNOPTLEN +#undef SO_DISCDATALEN +#undef SO_DISCOPTLEN + +#undef SO_OPENTYPE + +#undef SO_SYNCHRONOUS_ALERT +#undef SO_SYNCHRONOUS_NONALERT + +#undef SO_MAXDG +#undef SO_MAXPATHDG +#undef SO_UPDATE_ACCEPT_CONTEXT +#undef SO_CONNECT_TIME + +#undef TCP_NODELAY +#undef TCP_BSDURGENT + +#undef AF_UNSPEC +#undef AF_UNIX +#undef AF_INET +#undef AF_IMPLINK +#undef AF_PUP +#undef AF_CHAOS +#undef AF_IPX +#undef AF_NS +#undef AF_ISO +#undef AF_OSI +#undef AF_ECMA +#undef AF_DATAKIT +#undef AF_CCITT +#undef AF_SNA +#undef AF_DECnet +#undef AF_DLI +#undef AF_LAT +#undef AF_HYLINK +#undef AF_APPLETALK +#undef AF_NETBIOS +#undef AF_VOICEVIEW +#undef AF_FIREFOX +#undef AF_UNKNOWN1 +#undef AF_BAN + +#undef AF_MAX + +#undef PF_UNSPEC +#undef PF_UNIX +#undef PF_INET +#undef PF_IMPLINK +#undef PF_PUP +#undef PF_CHAOS +#undef PF_NS +#undef PF_IPX +#undef PF_ISO +#undef PF_OSI +#undef PF_ECMA +#undef PF_DATAKIT +#undef PF_CCITT +#undef PF_SNA +#undef PF_DECnet +#undef PF_DLI +#undef PF_LAT +#undef PF_HYLINK +#undef PF_APPLETALK +#undef PF_VOICEVIEW +#undef PF_FIREFOX +#undef PF_UNKNOWN1 +#undef PF_BAN + +#undef PF_MAX + +#undef SOL_SOCKET + +#undef SOMAXCONN + +#undef MSG_OOB +#undef MSG_PEEK +#undef MSG_DONTROUTE + +#undef MSG_MAXIOVLEN + +#undef MSG_PARTIAL + +#undef MAXGETHOSTSTRUCT + +#undef FD_READ +#undef FD_WRITE +#undef FD_OOB +#undef FD_ACCEPT +#undef FD_CONNECT +#undef FD_CLOSE + +#undef TF_DISCONNECT +#undef TF_REUSE_SOCKET +#undef TF_WRITE_BEHIND + +#undef WSAMAKEASYNCREPLY +#undef WSAMAKESELECTREPLY +#undef WSAGETASYNCBUFLEN +#undef WSAGETASYNCERROR +#undef WSAGETSELECTEVENT +#undef WSAGETSELECTERROR + diff --git a/win32/include/winapi/psdk_inc/_wsa_errnos.h b/win32/include/winapi/psdk_inc/_wsa_errnos.h new file mode 100644 index 00000000..26f24787 --- /dev/null +++ b/win32/include/winapi/psdk_inc/_wsa_errnos.h @@ -0,0 +1,225 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef WSABASEERR + +#define WSABASEERR 10000 + +#define WSAEINTR (WSABASEERR + 4 ) +#define WSAEBADF (WSABASEERR + 9 ) +#define WSAEACCES (WSABASEERR + 13 ) +#define WSAEFAULT (WSABASEERR + 14 ) +#define WSAEINVAL (WSABASEERR + 22 ) +#define WSAEMFILE (WSABASEERR + 24 ) + +#define WSAEWOULDBLOCK (WSABASEERR + 35 ) +#define WSAEINPROGRESS (WSABASEERR + 36 ) +#define WSAEALREADY (WSABASEERR + 37 ) +#define WSAENOTSOCK (WSABASEERR + 38 ) +#define WSAEDESTADDRREQ (WSABASEERR + 39 ) +#define WSAEMSGSIZE (WSABASEERR + 40 ) +#define WSAEPROTOTYPE (WSABASEERR + 41 ) +#define WSAENOPROTOOPT (WSABASEERR + 42 ) +#define WSAEPROTONOSUPPORT (WSABASEERR + 43 ) +#define WSAESOCKTNOSUPPORT (WSABASEERR + 44 ) +#define WSAEOPNOTSUPP (WSABASEERR + 45 ) +#define WSAEPFNOSUPPORT (WSABASEERR + 46 ) +#define WSAEAFNOSUPPORT (WSABASEERR + 47 ) +#define WSAEADDRINUSE (WSABASEERR + 48 ) +#define WSAEADDRNOTAVAIL (WSABASEERR + 49 ) +#define WSAENETDOWN (WSABASEERR + 50 ) +#define WSAENETUNREACH (WSABASEERR + 51 ) +#define WSAENETRESET (WSABASEERR + 52 ) +#define WSAECONNABORTED (WSABASEERR + 53 ) +#define WSAECONNRESET (WSABASEERR + 54 ) +#define WSAENOBUFS (WSABASEERR + 55 ) +#define WSAEISCONN (WSABASEERR + 56 ) +#define WSAENOTCONN (WSABASEERR + 57 ) +#define WSAESHUTDOWN (WSABASEERR + 58 ) +#define WSAETOOMANYREFS (WSABASEERR + 59 ) +#define WSAETIMEDOUT (WSABASEERR + 60 ) +#define WSAECONNREFUSED (WSABASEERR + 61 ) +#define WSAELOOP (WSABASEERR + 62 ) +#define WSAENAMETOOLONG (WSABASEERR + 63 ) +#define WSAEHOSTDOWN (WSABASEERR + 64 ) +#define WSAEHOSTUNREACH (WSABASEERR + 65 ) +#define WSAENOTEMPTY (WSABASEERR + 66 ) +#define WSAEPROCLIM (WSABASEERR + 67 ) +#define WSAEUSERS (WSABASEERR + 68 ) +#define WSAEDQUOT (WSABASEERR + 69 ) +#define WSAESTALE (WSABASEERR + 70 ) +#define WSAEREMOTE (WSABASEERR + 71 ) + +#define WSASYSNOTREADY (WSABASEERR + 91 ) +#define WSAVERNOTSUPPORTED (WSABASEERR + 92 ) +#define WSANOTINITIALISED (WSABASEERR + 93 ) + +#define WSAEDISCON (WSABASEERR + 101 ) + +#ifndef WSAHOST_NOT_FOUND +#define WSAHOST_NOT_FOUND (WSABASEERR + 1001) +#endif +#ifndef WSATRY_AGAIN +#define WSATRY_AGAIN (WSABASEERR + 1002) +#endif +#ifndef WSANO_RECOVERY +#define WSANO_RECOVERY (WSABASEERR + 1003) +#endif +#ifndef WSANO_DATA +#define WSANO_DATA (WSABASEERR + 1004) +#endif + +#endif /* WSABASEERR */ + +#ifdef _WINSOCK2API_ + +#ifndef WSAENOMORE +#define WSAENOMORE (WSABASEERR + 102) +#endif +#ifndef WSAECANCELLED +#define WSAECANCELLED (WSABASEERR + 103) +#endif +#ifndef WSAEINVALIDPROCTABLE +#define WSAEINVALIDPROCTABLE (WSABASEERR + 104) +#endif +#ifndef WSAEINVALIDPROVIDER +#define WSAEINVALIDPROVIDER (WSABASEERR + 105) +#endif +#ifndef WSAEPROVIDERFAILEDINIT +#define WSAEPROVIDERFAILEDINIT (WSABASEERR + 106) +#endif +#ifndef WSASYSCALLFAILURE +#define WSASYSCALLFAILURE (WSABASEERR + 107) +#endif +#ifndef WSASERVICE_NOT_FOUND +#define WSASERVICE_NOT_FOUND (WSABASEERR + 108) +#endif +#ifndef WSATYPE_NOT_FOUND +#define WSATYPE_NOT_FOUND (WSABASEERR + 109) +#endif +#ifndef WSA_E_NO_MORE +#define WSA_E_NO_MORE (WSABASEERR + 110) +#endif +#ifndef WSA_E_CANCELLED +#define WSA_E_CANCELLED (WSABASEERR + 111) +#endif +#ifndef WSAEREFUSED +#define WSAEREFUSED (WSABASEERR + 112) +#endif +#ifndef WSA_QOS_RECEIVERS +#define WSA_QOS_RECEIVERS (WSABASEERR + 1005) +#endif +#ifndef WSA_QOS_SENDERS +#define WSA_QOS_SENDERS (WSABASEERR + 1006) +#endif +#ifndef WSA_QOS_NO_SENDERS +#define WSA_QOS_NO_SENDERS (WSABASEERR + 1007) +#define WSA_QOS_NO_RECEIVERS (WSABASEERR + 1008) +#define WSA_QOS_REQUEST_CONFIRMED (WSABASEERR + 1009) +#define WSA_QOS_ADMISSION_FAILURE (WSABASEERR + 1010) +#define WSA_QOS_POLICY_FAILURE (WSABASEERR + 1011) +#define WSA_QOS_BAD_STYLE (WSABASEERR + 1012) +#define WSA_QOS_BAD_OBJECT (WSABASEERR + 1013) +#define WSA_QOS_TRAFFIC_CTRL_ERROR (WSABASEERR + 1014) +#define WSA_QOS_GENERIC_ERROR (WSABASEERR + 1015) +#define WSA_QOS_ESERVICETYPE (WSABASEERR + 1016) +#define WSA_QOS_EFLOWSPEC (WSABASEERR + 1017) +#define WSA_QOS_EPROVSPECBUF (WSABASEERR + 1018) +#endif +#ifndef WSA_QOS_EFILTERSTYLE +#define WSA_QOS_EFILTERSTYLE (WSABASEERR + 1019) +#endif +#ifndef WSA_QOS_EFILTERTYPE +#define WSA_QOS_EFILTERTYPE (WSABASEERR + 1020) +#endif +#ifndef WSA_QOS_EFILTERCOUNT +#define WSA_QOS_EFILTERCOUNT (WSABASEERR + 1021) +#endif +#ifndef WSA_QOS_EOBJLENGTH +#define WSA_QOS_EOBJLENGTH (WSABASEERR + 1022) +#endif +#ifndef WSA_QOS_EFLOWCOUNT +#define WSA_QOS_EFLOWCOUNT (WSABASEERR + 1023) +#endif +#ifndef WSA_QOS_EUNKNOWNPSOBJ +#define WSA_QOS_EUNKNOWNPSOBJ (WSABASEERR + 1024) +#endif +#ifndef WSA_QOS_EPOLICYOBJ +#define WSA_QOS_EPOLICYOBJ (WSABASEERR + 1025) +#endif +#ifndef WSA_QOS_EFLOWDESC +#define WSA_QOS_EFLOWDESC (WSABASEERR + 1026) +#endif +#ifndef WSA_QOS_EPSFLOWSPEC +#define WSA_QOS_EPSFLOWSPEC (WSABASEERR + 1027) +#endif +#ifndef WSA_QOS_EPSFILTERSPEC +#define WSA_QOS_EPSFILTERSPEC (WSABASEERR + 1028) +#endif +#ifndef WSA_QOS_ESDMODEOBJ +#define WSA_QOS_ESDMODEOBJ (WSABASEERR + 1029) +#endif +#ifndef WSA_QOS_ESHAPERATEOBJ +#define WSA_QOS_ESHAPERATEOBJ (WSABASEERR + 1030) +#endif +#ifndef WSA_QOS_RESERVED_PETYPE +#define WSA_QOS_RESERVED_PETYPE (WSABASEERR + 1031) +#endif + +#endif /* _WINSOCK2API_ */ + +#ifndef __WSA_ERR_MACROS_DEFINED +#define __WSA_ERR_MACROS_DEFINED +#define h_errno WSAGetLastError() +#define HOST_NOT_FOUND WSAHOST_NOT_FOUND +#define TRY_AGAIN WSATRY_AGAIN +#define NO_RECOVERY WSANO_RECOVERY +#define NO_DATA WSANO_DATA + +#define WSANO_ADDRESS WSANO_DATA +#define NO_ADDRESS WSANO_ADDRESS +#endif /* __WSA_ERR_MACROS_DEFINED */ + +#if 0 +#define EWOULDBLOCK WSAEWOULDBLOCK +#define EINPROGRESS WSAEINPROGRESS +#define EALREADY WSAEALREADY +#define ENOTSOCK WSAENOTSOCK +#define EDESTADDRREQ WSAEDESTADDRREQ +#define EMSGSIZE WSAEMSGSIZE +#define EPROTOTYPE WSAEPROTOTYPE +#define ENOPROTOOPT WSAENOPROTOOPT +#define EPROTONOSUPPORT WSAEPROTONOSUPPORT +#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT +#define EOPNOTSUPP WSAEOPNOTSUPP +#define EPFNOSUPPORT WSAEPFNOSUPPORT +#define EAFNOSUPPORT WSAEAFNOSUPPORT +#define EADDRINUSE WSAEADDRINUSE +#define EADDRNOTAVAIL WSAEADDRNOTAVAIL +#define ENETDOWN WSAENETDOWN +#define ENETUNREACH WSAENETUNREACH +#define ENETRESET WSAENETRESET +#define ECONNABORTED WSAECONNABORTED +#define ECONNRESET WSAECONNRESET +#define ENOBUFS WSAENOBUFS +#define EISCONN WSAEISCONN +#define ENOTCONN WSAENOTCONN +#define ESHUTDOWN WSAESHUTDOWN +#define ETOOMANYREFS WSAETOOMANYREFS +#define ETIMEDOUT WSAETIMEDOUT +#define ECONNREFUSED WSAECONNREFUSED +#define ELOOP WSAELOOP +#define ENAMETOOLONG WSAENAMETOOLONG +#define EHOSTDOWN WSAEHOSTDOWN +#define EHOSTUNREACH WSAEHOSTUNREACH +#define ENOTEMPTY WSAENOTEMPTY +#define EPROCLIM WSAEPROCLIM +#define EUSERS WSAEUSERS +#define EDQUOT WSAEDQUOT +#define ESTALE WSAESTALE +#define EREMOTE WSAEREMOTE +#endif /* #if 0 */ + diff --git a/win32/include/winapi/psdk_inc/_wsadata.h b/win32/include/winapi/psdk_inc/_wsadata.h new file mode 100644 index 00000000..490698ab --- /dev/null +++ b/win32/include/winapi/psdk_inc/_wsadata.h @@ -0,0 +1,32 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef __MINGW_WSADATA_H +#define __MINGW_WSADATA_H + +#define WSADESCRIPTION_LEN 256 +#define WSASYS_STATUS_LEN 128 + +typedef struct WSAData { + WORD wVersion; + WORD wHighVersion; +#ifdef _WIN64 + unsigned short iMaxSockets; + unsigned short iMaxUdpDg; + char *lpVendorInfo; + char szDescription[WSADESCRIPTION_LEN+1]; + char szSystemStatus[WSASYS_STATUS_LEN+1]; +#else + char szDescription[WSADESCRIPTION_LEN+1]; + char szSystemStatus[WSASYS_STATUS_LEN+1]; + unsigned short iMaxSockets; + unsigned short iMaxUdpDg; + char *lpVendorInfo; +#endif +} WSADATA, *LPWSADATA; + +#endif /* __MINGW_WSADATA_H */ + diff --git a/win32/include/winapi/qos.h b/win32/include/winapi/qos.h new file mode 100644 index 00000000..85dd1619 --- /dev/null +++ b/win32/include/winapi/qos.h @@ -0,0 +1,72 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ +#ifndef __QOS_H_ +#define __QOS_H_ + +typedef ULONG SERVICETYPE; + +#define SERVICETYPE_NOTRAFFIC 0x00000000 +#define SERVICETYPE_BESTEFFORT 0x00000001 +#define SERVICETYPE_CONTROLLEDLOAD 0x00000002 +#define SERVICETYPE_GUARANTEED 0x00000003 + +#define SERVICETYPE_NETWORK_UNAVAILABLE 0x00000004 +#define SERVICETYPE_GENERAL_INFORMATION 0x00000005 +#define SERVICETYPE_NOCHANGE 0x00000006 +#define SERVICETYPE_NONCONFORMING 0x00000009 +#define SERVICETYPE_NETWORK_CONTROL 0x0000000A +#define SERVICETYPE_QUALITATIVE 0x0000000D + +#define SERVICE_BESTEFFORT 0x80010000 +#define SERVICE_CONTROLLEDLOAD 0x80020000 +#define SERVICE_GUARANTEED 0x80040000 +#define SERVICE_QUALITATIVE 0x80200000 + +#define SERVICE_NO_TRAFFIC_CONTROL 0x81000000 + +#define SERVICE_NO_QOS_SIGNALING 0x40000000 + + typedef struct _flowspec { + ULONG TokenRate; + ULONG TokenBucketSize; + ULONG PeakBandwidth; + ULONG Latency; + ULONG DelayVariation; + SERVICETYPE ServiceType; + ULONG MaxSduSize; + ULONG MinimumPolicedSize; + } FLOWSPEC,*PFLOWSPEC,*LPFLOWSPEC; + +#define QOS_NOT_SPECIFIED 0xFFFFFFFF +#define POSITIVE_INFINITY_RATE 0xFFFFFFFE + + typedef struct _QOS_OBJECT_HDR { + ULONG ObjectType; + ULONG ObjectLength; + } QOS_OBJECT_HDR, *LPQOS_OBJECT_HDR; + +#define QOS_GENERAL_ID_BASE 2000 +#define QOS_OBJECT_END_OF_LIST (0x00000001 + QOS_GENERAL_ID_BASE) +#define QOS_OBJECT_SD_MODE (0x00000002 + QOS_GENERAL_ID_BASE) +#define QOS_OBJECT_SHAPING_RATE (0x00000003 + QOS_GENERAL_ID_BASE) +#define QOS_OBJECT_DESTADDR (0x00000004 + QOS_GENERAL_ID_BASE) + + typedef struct _QOS_SD_MODE { + QOS_OBJECT_HDR ObjectHdr; + ULONG ShapeDiscardMode; + } QOS_SD_MODE, *LPQOS_SD_MODE; + +#define TC_NONCONF_BORROW 0 +#define TC_NONCONF_SHAPE 1 +#define TC_NONCONF_DISCARD 2 +#define TC_NONCONF_BORROW_PLUS 3 + + typedef struct _QOS_SHAPING_RATE { + QOS_OBJECT_HDR ObjectHdr; + ULONG ShapingRate; + } QOS_SHAPING_RATE, *LPQOS_SHAPING_RATE; + +#endif diff --git a/win32/include/winapi/winsock2.h b/win32/include/winapi/winsock2.h new file mode 100644 index 00000000..310b3a35 --- /dev/null +++ b/win32/include/winapi/winsock2.h @@ -0,0 +1,1253 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef _WINSOCK2API_ +#define _WINSOCK2API_ + +#include <_mingw_unicode.h> + +#ifndef _WINSOCKAPI_ +#define _WINSOCKAPI_ +#else +#warning Please include winsock2.h before windows.h +#endif + +#ifndef INCL_WINSOCK_API_TYPEDEFS +#define INCL_WINSOCK_API_TYPEDEFS 0 +#endif + +#ifndef _INC_WINDOWS +#include +#endif + +#ifndef MAKEWORD +#define MAKEWORD(low,high) ((WORD)(((BYTE)(low)) | ((WORD)((BYTE)(high))) << 8)) +#endif + +#ifndef WINSOCK_VERSION +#define WINSOCK_VERSION MAKEWORD(2,2) +#endif + +#ifndef WINSOCK_API_LINKAGE +#ifdef DECLSPEC_IMPORT +#define WINSOCK_API_LINKAGE DECLSPEC_IMPORT +#else +#define WINSOCK_API_LINKAGE +#endif +#endif /* WINSOCK_API_LINKAGE */ +#define WSAAPI WINAPI + +/* undefine macros from winsock.h */ +#include + +#include <_timeval.h> +#include <_bsd_types.h> +#include +#include +#include +#include +#include +#include /* FIXME: include order */ + +#ifdef __cplusplus +extern "C" { +#endif + +extern int WINAPI __WSAFDIsSet(SOCKET,fd_set *); + +#define FD_CLR(fd,set) \ + do { \ + u_int __i; \ + for(__i = 0; __i < ((fd_set *)(set))->fd_count; __i++) { \ + if (((fd_set *)(set))->fd_array[__i] == fd) { \ + while (__i < ((fd_set *)(set))->fd_count - 1) { \ + ((fd_set *)(set))->fd_array[__i] = \ + ((fd_set *)(set))->fd_array[__i + 1]; \ + __i++; \ + } \ + ((fd_set *)(set))->fd_count--; \ + break; \ + } \ + } \ +} while(0) + +#define FD_ZERO(set) (((fd_set *)(set))->fd_count = 0) + +#define FD_ISSET(fd,set) __WSAFDIsSet((SOCKET)(fd),(fd_set *)(set)) + +#define FD_SET(fd,set) \ + do { \ + u_int __i; \ + for(__i = 0; __i < ((fd_set *)(set))->fd_count; __i++) { \ + if (((fd_set *)(set))->fd_array[__i] == (fd)) { \ + break; \ + } \ + } \ + if (__i == ((fd_set *)(set))->fd_count) { \ + if (((fd_set *)(set))->fd_count < FD_SETSIZE) { \ + ((fd_set *)(set))->fd_array[__i] = (fd); \ + ((fd_set *)(set))->fd_count++; \ + } \ + } \ +} while(0) + +#define IOCPARM_MASK 0x7f +#define IOC_VOID 0x20000000 +#define IOC_OUT 0x40000000 +#define IOC_IN 0x80000000 +#define IOC_INOUT (IOC_IN|IOC_OUT) + +#define _IO(x,y) (IOC_VOID|((x)<<8)|(y)) +#define _IOR(x,y,t) (IOC_OUT|(((long)sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y)) +#define _IOW(x,y,t) (IOC_IN|(((long)sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y)) + +#define FIONREAD _IOR('f',127,u_long) +#define FIONBIO _IOW('f',126,u_long) +#define FIOASYNC _IOW('f',125,u_long) + +#define SIOCSHIWAT _IOW('s',0,u_long) +#define SIOCGHIWAT _IOR('s',1,u_long) +#define SIOCSLOWAT _IOW('s',2,u_long) +#define SIOCGLOWAT _IOR('s',3,u_long) +#define SIOCATMARK _IOR('s',7,u_long) + +#define IPPROTO_IP 0 +#define IPPROTO_HOPOPTS 0 +#define IPPROTO_ICMP 1 +#define IPPROTO_IGMP 2 +#define IPPROTO_GGP 3 +#define IPPROTO_IPV4 4 +#define IPPROTO_TCP 6 +#define IPPROTO_PUP 12 +#define IPPROTO_UDP 17 +#define IPPROTO_IDP 22 +#define IPPROTO_IPV6 41 +#define IPPROTO_ROUTING 43 +#define IPPROTO_FRAGMENT 44 +#define IPPROTO_ESP 50 +#define IPPROTO_AH 51 +#define IPPROTO_ICMPV6 58 +#define IPPROTO_NONE 59 +#define IPPROTO_DSTOPTS 60 +#define IPPROTO_ND 77 +#define IPPROTO_ICLFXBM 78 + +#define IPPROTO_RAW 255 +#define IPPROTO_MAX 256 + +#define IPPORT_ECHO 7 +#define IPPORT_DISCARD 9 +#define IPPORT_SYSTAT 11 +#define IPPORT_DAYTIME 13 +#define IPPORT_NETSTAT 15 +#define IPPORT_FTP 21 +#define IPPORT_TELNET 23 +#define IPPORT_SMTP 25 +#define IPPORT_TIMESERVER 37 +#define IPPORT_NAMESERVER 42 +#define IPPORT_WHOIS 43 +#define IPPORT_MTP 57 + +#define IPPORT_TFTP 69 +#define IPPORT_RJE 77 +#define IPPORT_FINGER 79 +#define IPPORT_TTYLINK 87 +#define IPPORT_SUPDUP 95 + +#define IPPORT_EXECSERVER 512 +#define IPPORT_LOGINSERVER 513 +#define IPPORT_CMDSERVER 514 +#define IPPORT_EFSSERVER 520 + +#define IPPORT_BIFFUDP 512 +#define IPPORT_WHOSERVER 513 +#define IPPORT_ROUTESERVER 520 + +#define IPPORT_RESERVED 1024 + +#define IMPLINK_IP 155 +#define IMPLINK_LOWEXPER 156 +#define IMPLINK_HIGHEXPER 158 + + +#define IN_CLASSA(i) (((long)(i) & 0x80000000)==0) +#define IN_CLASSA_NET 0xff000000 +#define IN_CLASSA_NSHIFT 24 +#define IN_CLASSA_HOST 0x00ffffff +#define IN_CLASSA_MAX 128 + +#define IN_CLASSB(i) (((long)(i) & 0xc0000000)==0x80000000) +#define IN_CLASSB_NET 0xffff0000 +#define IN_CLASSB_NSHIFT 16 +#define IN_CLASSB_HOST 0x0000ffff +#define IN_CLASSB_MAX 65536 + +#define IN_CLASSC(i) (((long)(i) & 0xe0000000)==0xc0000000) +#define IN_CLASSC_NET 0xffffff00 +#define IN_CLASSC_NSHIFT 8 +#define IN_CLASSC_HOST 0x000000ff + +#define IN_CLASSD(i) (((long)(i) & 0xf0000000)==0xe0000000) +#define IN_CLASSD_NET 0xf0000000 +#define IN_CLASSD_NSHIFT 28 +#define IN_CLASSD_HOST 0x0fffffff +#define IN_MULTICAST(i) IN_CLASSD(i) + +#define INADDR_ANY (u_long)0x00000000 +#define INADDR_LOOPBACK 0x7f000001 +#define INADDR_BROADCAST (u_long)0xffffffff +#define INADDR_NONE 0xffffffff + +#define ADDR_ANY INADDR_ANY + +#define FROM_PROTOCOL_INFO (-1) + +#define SOCK_STREAM 1 +#define SOCK_DGRAM 2 +#define SOCK_RAW 3 +#define SOCK_RDM 4 +#define SOCK_SEQPACKET 5 + +#define SO_DEBUG 0x0001 +#define SO_ACCEPTCONN 0x0002 +#define SO_REUSEADDR 0x0004 +#define SO_KEEPALIVE 0x0008 +#define SO_DONTROUTE 0x0010 +#define SO_BROADCAST 0x0020 +#define SO_USELOOPBACK 0x0040 +#define SO_LINGER 0x0080 +#define SO_OOBINLINE 0x0100 + +#define SO_DONTLINGER (int)(~SO_LINGER) +#define SO_EXCLUSIVEADDRUSE ((int)(~SO_REUSEADDR)) + +#define SO_SNDBUF 0x1001 +#define SO_RCVBUF 0x1002 +#define SO_SNDLOWAT 0x1003 +#define SO_RCVLOWAT 0x1004 +#define SO_SNDTIMEO 0x1005 +#define SO_RCVTIMEO 0x1006 +#define SO_ERROR 0x1007 +#define SO_TYPE 0x1008 + +#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 __MINGW_NAME_AW(SO_PROTOCOL_INFO) + +#define PVD_CONFIG 0x3001 +#define SO_CONDITIONAL_ACCEPT 0x3002 + +#define TCP_NODELAY 0x0001 + +#define AF_UNSPEC 0 + +#define AF_UNIX 1 +#define AF_INET 2 +#define AF_IMPLINK 3 +#define AF_PUP 4 +#define AF_CHAOS 5 +#define AF_NS 6 +#define AF_IPX AF_NS +#define AF_ISO 7 +#define AF_OSI AF_ISO +#define AF_ECMA 8 +#define AF_DATAKIT 9 +#define AF_CCITT 10 +#define AF_SNA 11 +#define AF_DECnet 12 +#define AF_DLI 13 +#define AF_LAT 14 +#define AF_HYLINK 15 +#define AF_APPLETALK 16 +#define AF_NETBIOS 17 +#define AF_VOICEVIEW 18 +#define AF_FIREFOX 19 +#define AF_UNKNOWN1 20 +#define AF_BAN 21 +#define AF_ATM 22 +#define AF_INET6 23 +#define AF_CLUSTER 24 +#define AF_12844 25 +#define AF_IRDA 26 +#define AF_NETDES 28 +#define AF_TCNPROCESS 29 +#define AF_TCNMESSAGE 30 +#define AF_ICLFXBM 31 +#define AF_BTH 32 +#define AF_MAX 33 + +#define _SS_MAXSIZE 128 +#define _SS_ALIGNSIZE (8) + +#define _SS_PAD1SIZE (_SS_ALIGNSIZE - sizeof (short)) +#define _SS_PAD2SIZE (_SS_MAXSIZE - (sizeof (short) + _SS_PAD1SIZE + _SS_ALIGNSIZE)) + + struct sockaddr_storage { + short ss_family; + char __ss_pad1[_SS_PAD1SIZE]; + + __MINGW_EXTENSION __int64 __ss_align; + char __ss_pad2[_SS_PAD2SIZE]; + }; + +#define PF_UNSPEC AF_UNSPEC +#define PF_UNIX AF_UNIX +#define PF_INET AF_INET +#define PF_IMPLINK AF_IMPLINK +#define PF_PUP AF_PUP +#define PF_CHAOS AF_CHAOS +#define PF_NS AF_NS +#define PF_IPX AF_IPX +#define PF_ISO AF_ISO +#define PF_OSI AF_OSI +#define PF_ECMA AF_ECMA +#define PF_DATAKIT AF_DATAKIT +#define PF_CCITT AF_CCITT +#define PF_SNA AF_SNA +#define PF_DECnet AF_DECnet +#define PF_DLI AF_DLI +#define PF_LAT AF_LAT +#define PF_HYLINK AF_HYLINK +#define PF_APPLETALK AF_APPLETALK +#define PF_VOICEVIEW AF_VOICEVIEW +#define PF_FIREFOX AF_FIREFOX +#define PF_UNKNOWN1 AF_UNKNOWN1 +#define PF_BAN AF_BAN +#define PF_ATM AF_ATM +#define PF_INET6 AF_INET6 +#define PF_BTH AF_BTH + +#define PF_MAX AF_MAX + +#define SOL_SOCKET 0xffff + +#define SOMAXCONN 0x7fffffff + +#define MSG_OOB 0x1 +#define MSG_PEEK 0x2 +#define MSG_DONTROUTE 0x4 +#define MSG_WAITALL 0x8 + +#define MSG_PARTIAL 0x8000 + +#define MSG_INTERRUPT 0x10 + +#define MSG_MAXIOVLEN 16 + +#define MAXGETHOSTSTRUCT 1024 + +#define FD_READ_BIT 0 +#define FD_READ (1 << FD_READ_BIT) + +#define FD_WRITE_BIT 1 +#define FD_WRITE (1 << FD_WRITE_BIT) + +#define FD_OOB_BIT 2 +#define FD_OOB (1 << FD_OOB_BIT) + +#define FD_ACCEPT_BIT 3 +#define FD_ACCEPT (1 << FD_ACCEPT_BIT) + +#define FD_CONNECT_BIT 4 +#define FD_CONNECT (1 << FD_CONNECT_BIT) + +#define FD_CLOSE_BIT 5 +#define FD_CLOSE (1 << FD_CLOSE_BIT) + +#define FD_QOS_BIT 6 +#define FD_QOS (1 << FD_QOS_BIT) + +#define FD_GROUP_QOS_BIT 7 +#define FD_GROUP_QOS (1 << FD_GROUP_QOS_BIT) + +#define FD_ROUTING_INTERFACE_CHANGE_BIT 8 +#define FD_ROUTING_INTERFACE_CHANGE (1 << FD_ROUTING_INTERFACE_CHANGE_BIT) + +#define FD_ADDRESS_LIST_CHANGE_BIT 9 +#define FD_ADDRESS_LIST_CHANGE (1 << FD_ADDRESS_LIST_CHANGE_BIT) + +#define FD_MAX_EVENTS 10 +#define FD_ALL_EVENTS ((1 << FD_MAX_EVENTS) - 1) + +#include + +#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 (WAIT_FAILED) +#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 struct _WSABUF { + u_long len; + char *buf; + } WSABUF,*LPWSABUF; + +#include + + typedef struct _QualityOfService { + FLOWSPEC SendingFlowspec; + FLOWSPEC ReceivingFlowspec; + WSABUF ProviderSpecific; + } QOS,*LPQOS; + +#define CF_ACCEPT 0x0000 +#define CF_REJECT 0x0001 +#define CF_DEFER 0x0002 + +#define SD_RECEIVE 0x00 +#define SD_SEND 0x01 +#define SD_BOTH 0x02 + +typedef unsigned int GROUP; + +#define SG_UNCONSTRAINED_GROUP 0x01 +#define SG_CONSTRAINED_GROUP 0x02 + + typedef struct _WSANETWORKEVENTS { + long lNetworkEvents; + int iErrorCode[FD_MAX_EVENTS]; + } WSANETWORKEVENTS,*LPWSANETWORKEVENTS; + +#ifndef GUID_DEFINED +#include +#endif + +#define MAX_PROTOCOL_CHAIN 7 + +#define BASE_PROTOCOL 1 +#define LAYERED_PROTOCOL 0 + + typedef struct _WSAPROTOCOLCHAIN { + int ChainLen; + + DWORD ChainEntries[MAX_PROTOCOL_CHAIN]; + } WSAPROTOCOLCHAIN,*LPWSAPROTOCOLCHAIN; + +#define WSAPROTOCOL_LEN 255 + + typedef struct _WSAPROTOCOL_INFOA { + DWORD dwServiceFlags1; + DWORD dwServiceFlags2; + DWORD dwServiceFlags3; + DWORD dwServiceFlags4; + DWORD dwProviderFlags; + GUID ProviderId; + DWORD dwCatalogEntryId; + WSAPROTOCOLCHAIN ProtocolChain; + int iVersion; + int iAddressFamily; + int iMaxSockAddr; + int iMinSockAddr; + int iSocketType; + int iProtocol; + int iProtocolMaxOffset; + int iNetworkByteOrder; + int iSecurityScheme; + DWORD dwMessageSize; + DWORD dwProviderReserved; + CHAR szProtocol[WSAPROTOCOL_LEN+1]; + } WSAPROTOCOL_INFOA,*LPWSAPROTOCOL_INFOA; + + typedef struct _WSAPROTOCOL_INFOW { + DWORD dwServiceFlags1; + DWORD dwServiceFlags2; + DWORD dwServiceFlags3; + DWORD dwServiceFlags4; + DWORD dwProviderFlags; + GUID ProviderId; + DWORD dwCatalogEntryId; + WSAPROTOCOLCHAIN ProtocolChain; + int iVersion; + int iAddressFamily; + int iMaxSockAddr; + int iMinSockAddr; + int iSocketType; + int iProtocol; + int iProtocolMaxOffset; + int iNetworkByteOrder; + int iSecurityScheme; + DWORD dwMessageSize; + DWORD dwProviderReserved; + WCHAR szProtocol[WSAPROTOCOL_LEN+1]; + } WSAPROTOCOL_INFOW,*LPWSAPROTOCOL_INFOW; + + __MINGW_TYPEDEF_AW(WSAPROTOCOL_INFO) + __MINGW_TYPEDEF_AW(LPWSAPROTOCOL_INFO) + +#define PFL_MULTIPLE_PROTO_ENTRIES 0x00000001 +#define PFL_RECOMMENDED_PROTO_ENTRY 0x00000002 +#define PFL_HIDDEN 0x00000004 +#define PFL_MATCHES_PROTOCOL_ZERO 0x00000008 + +#define XP1_CONNECTIONLESS 0x00000001 +#define XP1_GUARANTEED_DELIVERY 0x00000002 +#define XP1_GUARANTEED_ORDER 0x00000004 +#define XP1_MESSAGE_ORIENTED 0x00000008 +#define XP1_PSEUDO_STREAM 0x00000010 +#define XP1_GRACEFUL_CLOSE 0x00000020 +#define XP1_EXPEDITED_DATA 0x00000040 +#define XP1_CONNECT_DATA 0x00000080 +#define XP1_DISCONNECT_DATA 0x00000100 +#define XP1_SUPPORT_BROADCAST 0x00000200 +#define XP1_SUPPORT_MULTIPOINT 0x00000400 +#define XP1_MULTIPOINT_CONTROL_PLANE 0x00000800 +#define XP1_MULTIPOINT_DATA_PLANE 0x00001000 +#define XP1_QOS_SUPPORTED 0x00002000 +#define XP1_INTERRUPT 0x00004000 +#define XP1_UNI_SEND 0x00008000 +#define XP1_UNI_RECV 0x00010000 +#define XP1_IFS_HANDLES 0x00020000 +#define XP1_PARTIAL_MESSAGE 0x00040000 + +#define BIGENDIAN 0x0000 +#define LITTLEENDIAN 0x0001 + +#define SECURITY_PROTOCOL_NONE 0x0000 + +#define JL_SENDER_ONLY 0x01 +#define JL_RECEIVER_ONLY 0x02 +#define JL_BOTH 0x04 + +#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 + +#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_WS2,24) +#define SIO_ADDRESS_LIST_SORT _WSAIORW(IOC_WS2,25) +#if (_WIN32_WINNT >= 0x0600) +#define SIO_RESERVED_1 _WSAIOW(IOC_WS2,26) +#define SIO_RESERVED_2 _WSAIOW(IOC_WS2,33) +#endif /* _WIN32_WINNT >= 0x0600 */ + + typedef int (CALLBACK *LPCONDITIONPROC)(LPWSABUF lpCallerId,LPWSABUF lpCallerData,LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId,LPWSABUF lpCalleeData,GROUP *g,DWORD_PTR dwCallbackData); + typedef void (CALLBACK *LPWSAOVERLAPPED_COMPLETION_ROUTINE)(DWORD dwError,DWORD cbTransferred,LPWSAOVERLAPPED lpOverlapped,DWORD dwFlags); + +#define SIO_NSP_NOTIFY_CHANGE _WSAIOW(IOC_WS2,25) + + typedef enum _WSACOMPLETIONTYPE { + NSP_NOTIFY_IMMEDIATELY = 0, + NSP_NOTIFY_HWND, + NSP_NOTIFY_EVENT, + NSP_NOTIFY_PORT, + NSP_NOTIFY_APC + } WSACOMPLETIONTYPE,*PWSACOMPLETIONTYPE,*LPWSACOMPLETIONTYPE; + + typedef struct _WSACOMPLETION { + WSACOMPLETIONTYPE Type; + union { + struct { + HWND hWnd; + UINT uMsg; + WPARAM context; + } WindowMessage; + struct { + LPWSAOVERLAPPED lpOverlapped; + } Event; + struct { + LPWSAOVERLAPPED lpOverlapped; + LPWSAOVERLAPPED_COMPLETION_ROUTINE lpfnCompletionProc; + } Apc; + struct { + LPWSAOVERLAPPED lpOverlapped; + HANDLE hPort; + ULONG_PTR Key; + } Port; + } Parameters; + } WSACOMPLETION,*PWSACOMPLETION,*LPWSACOMPLETION; + +#define TH_NETDEV 0x00000001 +#define TH_TAPI 0x00000002 + + typedef struct sockaddr_storage SOCKADDR_STORAGE; + typedef struct sockaddr_storage *PSOCKADDR_STORAGE; + typedef struct sockaddr_storage *LPSOCKADDR_STORAGE; + typedef u_short ADDRESS_FAMILY; + +#ifndef _tagBLOB_DEFINED +#define _tagBLOB_DEFINED +#define _BLOB_DEFINED +#define _LPBLOB_DEFINED + typedef struct _BLOB { + ULONG cbSize; + BYTE *pBlobData; + } BLOB,*LPBLOB; +#endif /* _tagBLOB_DEFINED */ + +#define SERVICE_MULTIPLE (0x00000001) + +#define NS_ALL (0) + +#define NS_SAP (1) +#define NS_NDS (2) +#define NS_PEER_BROWSE (3) +#define NS_SLP (5) +#define NS_DHCP (6) + +#define NS_TCPIP_LOCAL (10) +#define NS_TCPIP_HOSTS (11) +#define NS_DNS (12) +#define NS_NETBT (13) +#define NS_WINS (14) +#define NS_NLA (15) + +#define NS_NBP (20) + +#define NS_MS (30) +#define NS_STDA (31) +#define NS_NTDS (32) + +#define NS_X500 (40) +#define NS_NIS (41) +#define NS_NISPLUS (42) + +#define NS_WRQ (50) + +#define NS_NETDES (60) + +#define RES_UNUSED_1 (0x00000001) +#define RES_FLUSH_CACHE (0x00000002) +#ifndef RES_SERVICE +#define RES_SERVICE (0x00000004) +#endif + +#define SERVICE_TYPE_VALUE_IPXPORTA "IpxSocket" +#define SERVICE_TYPE_VALUE_IPXPORTW L"IpxSocket" +#define SERVICE_TYPE_VALUE_SAPIDA "SapId" +#define SERVICE_TYPE_VALUE_SAPIDW L"SapId" + +#define SERVICE_TYPE_VALUE_TCPPORTA "TcpPort" +#define SERVICE_TYPE_VALUE_TCPPORTW L"TcpPort" + +#define SERVICE_TYPE_VALUE_UDPPORTA "UdpPort" +#define SERVICE_TYPE_VALUE_UDPPORTW L"UdpPort" + +#define SERVICE_TYPE_VALUE_OBJECTIDA "ObjectId" +#define SERVICE_TYPE_VALUE_OBJECTIDW L"ObjectId" + +#define SERVICE_TYPE_VALUE_SAPID __MINGW_NAME_AW(SERVICE_TYPE_VALUE_SAPID) +#define SERVICE_TYPE_VALUE_TCPPORT __MINGW_NAME_AW(SERVICE_TYPE_VALUE_TCPPORT) +#define SERVICE_TYPE_VALUE_UDPPORT __MINGW_NAME_AW(SERVICE_TYPE_VALUE_UDPPORT) +#define SERVICE_TYPE_VALUE_OBJECTID __MINGW_NAME_AW(SERVICE_TYPE_VALUE_OBJECTID) + +#ifndef __CSADDR_DEFINED__ +#define __CSADDR_DEFINED__ + + typedef struct _SOCKET_ADDRESS { + LPSOCKADDR lpSockaddr; + INT iSockaddrLength; + } SOCKET_ADDRESS,*PSOCKET_ADDRESS,*LPSOCKET_ADDRESS; + + typedef struct _CSADDR_INFO { + SOCKET_ADDRESS LocalAddr; + SOCKET_ADDRESS RemoteAddr; + INT iSocketType; + INT iProtocol; + } CSADDR_INFO,*PCSADDR_INFO,*LPCSADDR_INFO; +#endif /* __CSADDR_DEFINED__ */ + + typedef struct _SOCKET_ADDRESS_LIST { + INT iAddressCount; + SOCKET_ADDRESS Address[1]; + } SOCKET_ADDRESS_LIST,*PSOCKET_ADDRESS_LIST,*LPSOCKET_ADDRESS_LIST; + + typedef struct _AFPROTOCOLS { + INT iAddressFamily; + INT iProtocol; + } AFPROTOCOLS,*PAFPROTOCOLS,*LPAFPROTOCOLS; + + typedef enum _WSAEcomparator { + COMP_EQUAL = 0, + COMP_NOTLESS + } WSAECOMPARATOR,*PWSAECOMPARATOR,*LPWSAECOMPARATOR; + + typedef struct _WSAVersion { + DWORD dwVersion; + WSAECOMPARATOR ecHow; + } WSAVERSION,*PWSAVERSION,*LPWSAVERSION; + + typedef struct _WSAQuerySetA { + DWORD dwSize; + LPSTR lpszServiceInstanceName; + LPGUID lpServiceClassId; + LPWSAVERSION lpVersion; + LPSTR lpszComment; + DWORD dwNameSpace; + LPGUID lpNSProviderId; + LPSTR lpszContext; + DWORD dwNumberOfProtocols; + LPAFPROTOCOLS lpafpProtocols; + LPSTR lpszQueryString; + DWORD dwNumberOfCsAddrs; + LPCSADDR_INFO lpcsaBuffer; + DWORD dwOutputFlags; + LPBLOB lpBlob; + } WSAQUERYSETA,*PWSAQUERYSETA,*LPWSAQUERYSETA; + + typedef struct _WSAQuerySetW { + DWORD dwSize; + LPWSTR lpszServiceInstanceName; + LPGUID lpServiceClassId; + LPWSAVERSION lpVersion; + LPWSTR lpszComment; + DWORD dwNameSpace; + LPGUID lpNSProviderId; + LPWSTR lpszContext; + DWORD dwNumberOfProtocols; + LPAFPROTOCOLS lpafpProtocols; + LPWSTR lpszQueryString; + DWORD dwNumberOfCsAddrs; + LPCSADDR_INFO lpcsaBuffer; + DWORD dwOutputFlags; + LPBLOB lpBlob; + } WSAQUERYSETW,*PWSAQUERYSETW,*LPWSAQUERYSETW; + + __MINGW_TYPEDEF_AW(WSAQUERYSET) + __MINGW_TYPEDEF_AW(PWSAQUERYSET) + __MINGW_TYPEDEF_AW(LPWSAQUERYSET) + +#define LUP_DEEP 0x0001 +#define LUP_CONTAINERS 0x0002 +#define LUP_NOCONTAINERS 0x0004 +#define LUP_NEAREST 0x0008 +#define LUP_RETURN_NAME 0x0010 +#define LUP_RETURN_TYPE 0x0020 +#define LUP_RETURN_VERSION 0x0040 +#define LUP_RETURN_COMMENT 0x0080 +#define LUP_RETURN_ADDR 0x0100 +#define LUP_RETURN_BLOB 0x0200 +#define LUP_RETURN_ALIASES 0x0400 +#define LUP_RETURN_QUERY_STRING 0x0800 +#define LUP_RETURN_ALL 0x0FF0 +#define LUP_RES_SERVICE 0x8000 + +#define LUP_FLUSHCACHE 0x1000 +#define LUP_FLUSHPREVIOUS 0x2000 + +#define LUP_NON_AUTHORITATIVE 0x4000 +#define LUP_SECURE 0x8000 +#define LUP_RETURN_PREFERRED_NAMES 0x10000 + +#define LUP_ADDRCONFIG 0x100000 +#define LUP_DUAL_ADDR 0x200000 +#define LUP_FILESERVER 0x400000 + +#define LUP_RES_RESERVICE 0x8000 /* FIXME: not in PSDK anymore?? */ + +#define RESULT_IS_ALIAS 0x0001 +#define RESULT_IS_ADDED 0x0010 +#define RESULT_IS_CHANGED 0x0020 +#define RESULT_IS_DELETED 0x0040 + + typedef enum _WSAESETSERVICEOP { + RNRSERVICE_REGISTER = 0, + RNRSERVICE_DEREGISTER, + RNRSERVICE_DELETE + } WSAESETSERVICEOP,*PWSAESETSERVICEOP,*LPWSAESETSERVICEOP; + + typedef struct _WSANSClassInfoA { + LPSTR lpszName; + DWORD dwNameSpace; + DWORD dwValueType; + DWORD dwValueSize; + LPVOID lpValue; + } WSANSCLASSINFOA,*PWSANSCLASSINFOA,*LPWSANSCLASSINFOA; + + typedef struct _WSANSClassInfoW { + LPWSTR lpszName; + DWORD dwNameSpace; + DWORD dwValueType; + DWORD dwValueSize; + LPVOID lpValue; + } WSANSCLASSINFOW,*PWSANSCLASSINFOW,*LPWSANSCLASSINFOW; + + __MINGW_TYPEDEF_AW(WSANSCLASSINFO) + __MINGW_TYPEDEF_AW(PWSANSCLASSINFO) + __MINGW_TYPEDEF_AW(LPWSANSCLASSINFO) + + typedef struct _WSAServiceClassInfoA { + LPGUID lpServiceClassId; + LPSTR lpszServiceClassName; + DWORD dwCount; + LPWSANSCLASSINFOA lpClassInfos; + } WSASERVICECLASSINFOA,*PWSASERVICECLASSINFOA,*LPWSASERVICECLASSINFOA; + + typedef struct _WSAServiceClassInfoW { + LPGUID lpServiceClassId; + LPWSTR lpszServiceClassName; + DWORD dwCount; + LPWSANSCLASSINFOW lpClassInfos; + } WSASERVICECLASSINFOW,*PWSASERVICECLASSINFOW,*LPWSASERVICECLASSINFOW; + + __MINGW_TYPEDEF_AW(WSASERVICECLASSINFO) + __MINGW_TYPEDEF_AW(PWSASERVICECLASSINFO) + __MINGW_TYPEDEF_AW(LPWSASERVICECLASSINFO) + + typedef struct _WSANAMESPACE_INFOA { + GUID NSProviderId; + DWORD dwNameSpace; + WINBOOL fActive; + DWORD dwVersion; + LPSTR lpszIdentifier; + } WSANAMESPACE_INFOA,*PWSANAMESPACE_INFOA,*LPWSANAMESPACE_INFOA; + + typedef struct _WSANAMESPACE_INFOW { + GUID NSProviderId; + DWORD dwNameSpace; + WINBOOL fActive; + DWORD dwVersion; + LPWSTR lpszIdentifier; + } WSANAMESPACE_INFOW,*PWSANAMESPACE_INFOW,*LPWSANAMESPACE_INFOW; + + __MINGW_TYPEDEF_AW(WSANAMESPACE_INFO) + __MINGW_TYPEDEF_AW(PWSANAMESPACE_INFO) + __MINGW_TYPEDEF_AW(LPWSANAMESPACE_INFO) + +/* FIXME: WSAMSG originally lived in mswsock.h, + * newer SDKs moved it into a new ws2def.h. for + * now we keep it here. */ + typedef struct _WSAMSG { + LPSOCKADDR name; + INT namelen; + LPWSABUF lpBuffers; + DWORD dwBufferCount; + WSABUF Control; + DWORD dwFlags; + } WSAMSG,*PWSAMSG,*LPWSAMSG; + +#if INCL_WINSOCK_API_TYPEDEFS +#define LPFN_WSADUPLICATESOCKET __MINGW_NAME_AW(LPFN_WSADUPLICATESOCKET) +#define LPFN_WSAENUMPROTOCOLS __MINGW_NAME_AW(LPFN_WSAENUMPROTOCOLS) +#define LPFN_WSASOCKET __MINGW_NAME_AW(LPFN_WSASOCKET) +#define LPFN_WSAADDRESSTOSTRING __MINGW_NAME_AW(LPFN_WSAADDRESSTOSTRING) +#define LPFN_WSASTRINGTOADDRESS __MINGW_NAME_AW(LPFN_WSASTRINGTOADDRESS) +#define LPFN_WSALOOKUPSERVICEBEGIN __MINGW_NAME_AW(LPFN_WSALOOKUPSERVICEBEGIN) +#define LPFN_WSALOOKUPSERVICENEXT __MINGW_NAME_AW(LPFN_WSALOOKUPSERVICENEXT) +#define LPFN_WSAINSTALLSERVICECLASS __MINGW_NAME_AW(LPFN_WSAINSTALLSERVICECLASS) +#define LPFN_WSAGETSERVICECLASSINFO __MINGW_NAME_AW(LPFN_WSAGETSERVICECLASSINFO) +#define LPFN_WSAENUMNAMESPACEPROVIDERS __MINGW_NAME_AW(LPFN_WSAENUMNAMESPACEPROVIDERS) +#define LPFN_WSAGETSERVICECLASSNAMEBYCLASSID __MINGW_NAME_AW(LPFN_WSAGETSERVICECLASSNAMEBYCLASSID) +#define LPFN_WSASETSERVICE __MINGW_NAME_AW(LPFN_WSASETSERVICE) + + typedef SOCKET (WSAAPI *LPFN_ACCEPT)(SOCKET s,struct sockaddr *addr,int *addrlen); + typedef int (WSAAPI *LPFN_BIND)(SOCKET s,const struct sockaddr *name,int namelen); + typedef int (WSAAPI *LPFN_CLOSESOCKET)(SOCKET s); + typedef int (WSAAPI *LPFN_CONNECT)(SOCKET s,const struct sockaddr *name,int namelen); + typedef int (WSAAPI *LPFN_IOCTLSOCKET)(SOCKET s,long cmd,u_long *argp); + typedef int (WSAAPI *LPFN_GETPEERNAME)(SOCKET s,struct sockaddr *name,int *namelen); + typedef int (WSAAPI *LPFN_GETSOCKNAME)(SOCKET s,struct sockaddr *name,int *namelen); + typedef int (WSAAPI *LPFN_GETSOCKOPT)(SOCKET s,int level,int optname,char *optval,int *optlen); + typedef u_long (WSAAPI *LPFN_HTONL)(u_long hostlong); + typedef u_short (WSAAPI *LPFN_HTONS)(u_short hostshort); + typedef unsigned long (WSAAPI *LPFN_INET_ADDR)(const char *cp); + typedef char *(WSAAPI *LPFN_INET_NTOA)(struct in_addr in); + typedef int (WSAAPI *LPFN_LISTEN)(SOCKET s,int backlog); + typedef u_long (WSAAPI *LPFN_NTOHL)(u_long netlong); + typedef u_short (WSAAPI *LPFN_NTOHS)(u_short netshort); + typedef int (WSAAPI *LPFN_RECV)(SOCKET s,char *buf,int len,int flags); + typedef int (WSAAPI *LPFN_RECVFROM)(SOCKET s,char *buf,int len,int flags,struct sockaddr *from,int *fromlen); + typedef int (WSAAPI *LPFN_SELECT)(int nfds,fd_set *readfds,fd_set *writefds,fd_set *exceptfds,const struct timeval *timeout); + typedef int (WSAAPI *LPFN_SEND)(SOCKET s,const char *buf,int len,int flags); + typedef int (WSAAPI *LPFN_SENDTO)(SOCKET s,const char *buf,int len,int flags,const struct sockaddr *to,int tolen); + typedef int (WSAAPI *LPFN_SETSOCKOPT)(SOCKET s,int level,int optname,const char *optval,int optlen); + typedef int (WSAAPI *LPFN_SHUTDOWN)(SOCKET s,int how); + typedef SOCKET (WSAAPI *LPFN_SOCKET)(int af,int type,int protocol); + typedef struct hostent *(WSAAPI *LPFN_GETHOSTBYADDR)(const char *addr,int len,int type); + typedef struct hostent *(WSAAPI *LPFN_GETHOSTBYNAME)(const char *name); + typedef int (WSAAPI *LPFN_GETHOSTNAME)(char *name,int namelen); + typedef struct servent *(WSAAPI *LPFN_GETSERVBYPORT)(int port,const char *proto); + typedef struct servent *(WSAAPI *LPFN_GETSERVBYNAME)(const char *name,const char *proto); + typedef struct protoent *(WSAAPI *LPFN_GETPROTOBYNUMBER)(int number); + typedef struct protoent *(WSAAPI *LPFN_GETPROTOBYNAME)(const char *name); + typedef int (WSAAPI *LPFN_WSASTARTUP)(WORD wVersionRequested,LPWSADATA lpWSAData); + typedef int (WSAAPI *LPFN_WSACLEANUP)(void); + typedef void (WSAAPI *LPFN_WSASETLASTERROR)(int iError); + typedef int (WSAAPI *LPFN_WSAGETLASTERROR)(void); + typedef WINBOOL (WSAAPI *LPFN_WSAISBLOCKING)(void); + typedef int (WSAAPI *LPFN_WSAUNHOOKBLOCKINGHOOK)(void); + typedef FARPROC (WSAAPI *LPFN_WSASETBLOCKINGHOOK)(FARPROC lpBlockFunc); + typedef int (WSAAPI *LPFN_WSACANCELBLOCKINGCALL)(void); + typedef HANDLE (WSAAPI *LPFN_WSAASYNCGETSERVBYNAME)(HWND hWnd,u_int wMsg,const char *name,const char *proto,char *buf,int buflen); + typedef HANDLE (WSAAPI *LPFN_WSAASYNCGETSERVBYPORT)(HWND hWnd,u_int wMsg,int port,const char *proto,char *buf,int buflen); + typedef HANDLE (WSAAPI *LPFN_WSAASYNCGETPROTOBYNAME)(HWND hWnd,u_int wMsg,const char *name,char *buf,int buflen); + typedef HANDLE (WSAAPI *LPFN_WSAASYNCGETPROTOBYNUMBER)(HWND hWnd,u_int wMsg,int number,char *buf,int buflen); + typedef HANDLE (WSAAPI *LPFN_WSAASYNCGETHOSTBYNAME)(HWND hWnd,u_int wMsg,const char *name,char *buf,int buflen); + typedef HANDLE (WSAAPI *LPFN_WSAASYNCGETHOSTBYADDR)(HWND hWnd,u_int wMsg,const char *addr,int len,int type,char *buf,int buflen); + typedef int (WSAAPI *LPFN_WSACANCELASYNCREQUEST)(HANDLE hAsyncTaskHandle); + typedef int (WSAAPI *LPFN_WSAASYNCSELECT)(SOCKET s,HWND hWnd,u_int wMsg,long lEvent); + typedef SOCKET (WSAAPI *LPFN_WSAACCEPT)(SOCKET s,struct sockaddr *addr,LPINT addrlen,LPCONDITIONPROC lpfnCondition,DWORD_PTR dwCallbackData); + typedef WINBOOL (WSAAPI *LPFN_WSACLOSEEVENT)(WSAEVENT hEvent); + typedef int (WSAAPI *LPFN_WSACONNECT)(SOCKET s,const struct sockaddr *name,int namelen,LPWSABUF lpCallerData,LPWSABUF lpCalleeData,LPQOS lpSQOS,LPQOS lpGQOS); + typedef WSAEVENT (WSAAPI *LPFN_WSACREATEEVENT)(void); + typedef int (WSAAPI *LPFN_WSADUPLICATESOCKETA)(SOCKET s,DWORD dwProcessId,LPWSAPROTOCOL_INFOA lpProtocolInfo); + typedef int (WSAAPI *LPFN_WSADUPLICATESOCKETW)(SOCKET s,DWORD dwProcessId,LPWSAPROTOCOL_INFOW lpProtocolInfo); + typedef int (WSAAPI *LPFN_WSAENUMNETWORKEVENTS)(SOCKET s,WSAEVENT hEventObject,LPWSANETWORKEVENTS lpNetworkEvents); + typedef int (WSAAPI *LPFN_WSAENUMPROTOCOLSA)(LPINT lpiProtocols,LPWSAPROTOCOL_INFOA lpProtocolBuffer,LPDWORD lpdwBufferLength); + typedef int (WSAAPI *LPFN_WSAENUMPROTOCOLSW)(LPINT lpiProtocols,LPWSAPROTOCOL_INFOW lpProtocolBuffer,LPDWORD lpdwBufferLength); + typedef int (WSAAPI *LPFN_WSAEVENTSELECT)(SOCKET s,WSAEVENT hEventObject,long lNetworkEvents); + typedef WINBOOL (WSAAPI *LPFN_WSAGETOVERLAPPEDRESULT)(SOCKET s,LPWSAOVERLAPPED lpOverlapped,LPDWORD lpcbTransfer,WINBOOL fWait,LPDWORD lpdwFlags); + typedef WINBOOL (WSAAPI *LPFN_WSAGETQOSBYNAME)(SOCKET s,LPWSABUF lpQOSName,LPQOS lpQOS); + typedef int (WSAAPI *LPFN_WSAHTONL)(SOCKET s,u_long hostlong,u_long *lpnetlong); + typedef int (WSAAPI *LPFN_WSAHTONS)(SOCKET s,u_short hostshort,u_short *lpnetshort); + typedef int (WSAAPI *LPFN_WSAIOCTL)(SOCKET s,DWORD dwIoControlCode,LPVOID lpvInBuffer,DWORD cbInBuffer,LPVOID lpvOutBuffer,DWORD cbOutBuffer,LPDWORD lpcbBytesReturned,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + typedef SOCKET (WSAAPI *LPFN_WSAJOINLEAF)(SOCKET s,const struct sockaddr *name,int namelen,LPWSABUF lpCallerData,LPWSABUF lpCalleeData,LPQOS lpSQOS,LPQOS lpGQOS,DWORD dwFlags); + typedef int (WSAAPI *LPFN_WSANTOHL)(SOCKET s,u_long netlong,u_long *lphostlong); + typedef int (WSAAPI *LPFN_WSANTOHS)(SOCKET s,u_short netshort,u_short *lphostshort); + typedef int (WSAAPI *LPFN_WSARECV)(SOCKET s,LPWSABUF lpBuffers,DWORD dwBufferCount,LPDWORD lpNumberOfBytesRecvd,LPDWORD lpFlags,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + typedef int (WSAAPI *LPFN_WSARECVDISCONNECT)(SOCKET s,LPWSABUF lpInboundDisconnectData); + typedef int (WSAAPI *LPFN_WSARECVFROM)(SOCKET s,LPWSABUF lpBuffers,DWORD dwBufferCount,LPDWORD lpNumberOfBytesRecvd,LPDWORD lpFlags,struct sockaddr *lpFrom,LPINT lpFromlen,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + typedef WINBOOL (WSAAPI *LPFN_WSARESETEVENT)(WSAEVENT hEvent); + typedef int (WSAAPI *LPFN_WSASEND)(SOCKET s,LPWSABUF lpBuffers,DWORD dwBufferCount,LPDWORD lpNumberOfBytesSent,DWORD dwFlags,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + typedef int (WSAAPI *LPFN_WSASENDDISCONNECT)(SOCKET s,LPWSABUF lpOutboundDisconnectData); + typedef int (WSAAPI *LPFN_WSASENDTO)(SOCKET s,LPWSABUF lpBuffers,DWORD dwBufferCount,LPDWORD lpNumberOfBytesSent,DWORD dwFlags,const struct sockaddr *lpTo,int iTolen,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + typedef WINBOOL (WSAAPI *LPFN_WSASETEVENT)(WSAEVENT hEvent); + typedef SOCKET (WSAAPI *LPFN_WSASOCKETA)(int af,int type,int protocol,LPWSAPROTOCOL_INFOA lpProtocolInfo,GROUP g,DWORD dwFlags); + typedef SOCKET (WSAAPI *LPFN_WSASOCKETW)(int af,int type,int protocol,LPWSAPROTOCOL_INFOW lpProtocolInfo,GROUP g,DWORD dwFlags); + typedef DWORD (WSAAPI *LPFN_WSAWAITFORMULTIPLEEVENTS)(DWORD cEvents,const WSAEVENT *lphEvents,WINBOOL fWaitAll,DWORD dwTimeout,WINBOOL fAlertable); + typedef INT (WSAAPI *LPFN_WSAADDRESSTOSTRINGA)(LPSOCKADDR lpsaAddress,DWORD dwAddressLength,LPWSAPROTOCOL_INFOA lpProtocolInfo,LPSTR lpszAddressString,LPDWORD lpdwAddressStringLength); + typedef INT (WSAAPI *LPFN_WSAADDRESSTOSTRINGW)(LPSOCKADDR lpsaAddress,DWORD dwAddressLength,LPWSAPROTOCOL_INFOW lpProtocolInfo,LPWSTR lpszAddressString,LPDWORD lpdwAddressStringLength); + typedef INT (WSAAPI *LPFN_WSASTRINGTOADDRESSA)(LPSTR AddressString,INT AddressFamily,LPWSAPROTOCOL_INFOA lpProtocolInfo,LPSOCKADDR lpAddress,LPINT lpAddressLength); + typedef INT (WSAAPI *LPFN_WSASTRINGTOADDRESSW)(LPWSTR AddressString,INT AddressFamily,LPWSAPROTOCOL_INFOW lpProtocolInfo,LPSOCKADDR lpAddress,LPINT lpAddressLength); + typedef INT (WSAAPI *LPFN_WSALOOKUPSERVICEBEGINA)(LPWSAQUERYSETA lpqsRestrictions,DWORD dwControlFlags,LPHANDLE lphLookup); + typedef INT (WSAAPI *LPFN_WSALOOKUPSERVICEBEGINW)(LPWSAQUERYSETW lpqsRestrictions,DWORD dwControlFlags,LPHANDLE lphLookup); + typedef INT (WSAAPI *LPFN_WSALOOKUPSERVICENEXTA)(HANDLE hLookup,DWORD dwControlFlags,LPDWORD lpdwBufferLength,LPWSAQUERYSETA lpqsResults); + typedef INT (WSAAPI *LPFN_WSALOOKUPSERVICENEXTW)(HANDLE hLookup,DWORD dwControlFlags,LPDWORD lpdwBufferLength,LPWSAQUERYSETW lpqsResults); + typedef INT (WSAAPI *LPFN_WSANSPIOCTL)(HANDLE hLookup,DWORD dwControlCode,LPVOID lpvInBuffer,DWORD cbInBuffer,LPVOID lpvOutBuffer,DWORD cbOutBuffer,LPDWORD lpcbBytesReturned,LPWSACOMPLETION lpCompletion); + typedef INT (WSAAPI *LPFN_WSALOOKUPSERVICEEND)(HANDLE hLookup); + typedef INT (WSAAPI *LPFN_WSAINSTALLSERVICECLASSA)(LPWSASERVICECLASSINFOA lpServiceClassInfo); + typedef INT (WSAAPI *LPFN_WSAINSTALLSERVICECLASSW)(LPWSASERVICECLASSINFOW lpServiceClassInfo); + typedef INT (WSAAPI *LPFN_WSAREMOVESERVICECLASS)(LPGUID lpServiceClassId); + typedef INT (WSAAPI *LPFN_WSAGETSERVICECLASSINFOA)(LPGUID lpProviderId,LPGUID lpServiceClassId,LPDWORD lpdwBufSize,LPWSASERVICECLASSINFOA lpServiceClassInfo); + typedef INT (WSAAPI *LPFN_WSAGETSERVICECLASSINFOW)(LPGUID lpProviderId,LPGUID lpServiceClassId,LPDWORD lpdwBufSize,LPWSASERVICECLASSINFOW lpServiceClassInfo); + typedef INT (WSAAPI *LPFN_WSAENUMNAMESPACEPROVIDERSA)(LPDWORD lpdwBufferLength,LPWSANAMESPACE_INFOA lpnspBuffer); + typedef INT (WSAAPI *LPFN_WSAENUMNAMESPACEPROVIDERSW)(LPDWORD lpdwBufferLength,LPWSANAMESPACE_INFOW lpnspBuffer); + typedef INT (WSAAPI *LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDA)(LPGUID lpServiceClassId,LPSTR lpszServiceClassName,LPDWORD lpdwBufferLength); + typedef INT (WSAAPI *LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDW)(LPGUID lpServiceClassId,LPWSTR lpszServiceClassName,LPDWORD lpdwBufferLength); + typedef INT (WSAAPI *LPFN_WSASETSERVICEA)(LPWSAQUERYSETA lpqsRegInfo,WSAESETSERVICEOP essoperation,DWORD dwControlFlags); + typedef INT (WSAAPI *LPFN_WSASETSERVICEW)(LPWSAQUERYSETW lpqsRegInfo,WSAESETSERVICEOP essoperation,DWORD dwControlFlags); + typedef INT (WSAAPI *LPFN_WSAPROVIDERCONFIGCHANGE)(LPHANDLE lpNotificationHandle,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); +#endif + +#define WSADuplicateSocket __MINGW_NAME_AW(WSADuplicateSocket) +#define WSAEnumProtocols __MINGW_NAME_AW(WSAEnumProtocols) +#define WSAAddressToString __MINGW_NAME_AW(WSAAddressToString) +#define WSASocket __MINGW_NAME_AW(WSASocket) +#define WSAStringToAddress __MINGW_NAME_AW(WSAStringToAddress) +#define WSALookupServiceBegin __MINGW_NAME_AW(WSALookupServiceBegin) +#define WSALookupServiceNext __MINGW_NAME_AW(WSALookupServiceNext) +#define WSAInstallServiceClass __MINGW_NAME_AW(WSAInstallServiceClass) +#define WSAGetServiceClassInfo __MINGW_NAME_AW(WSAGetServiceClassInfo) +#define WSAEnumNameSpaceProviders __MINGW_NAME_AW(WSAEnumNameSpaceProviders) +#define WSAGetServiceClassNameByClassId __MINGW_NAME_AW(WSAGetServiceClassNameByClassId) +#define WSASetService __MINGW_NAME_AW(WSASetService) + +#ifndef __WINSOCK_WS1_SHARED +/* these 46 functions have the same prototypes as in winsock2 */ + WINSOCK_API_LINKAGE SOCKET WSAAPI accept(SOCKET s,struct sockaddr *addr,int *addrlen); + WINSOCK_API_LINKAGE int WSAAPI bind(SOCKET s,const struct sockaddr *name,int namelen); + WINSOCK_API_LINKAGE int WSAAPI closesocket(SOCKET s); + WINSOCK_API_LINKAGE int WSAAPI connect(SOCKET s,const struct sockaddr *name,int namelen); + WINSOCK_API_LINKAGE int WSAAPI ioctlsocket(SOCKET s,long cmd,u_long *argp); + WINSOCK_API_LINKAGE int WSAAPI getpeername(SOCKET s,struct sockaddr *name,int *namelen); + WINSOCK_API_LINKAGE int WSAAPI getsockname(SOCKET s,struct sockaddr *name,int *namelen); + WINSOCK_API_LINKAGE int WSAAPI getsockopt(SOCKET s,int level,int optname,char *optval,int *optlen); + WINSOCK_API_LINKAGE u_long WSAAPI htonl(u_long hostlong); + WINSOCK_API_LINKAGE u_short WSAAPI htons(u_short hostshort); + WINSOCK_API_LINKAGE unsigned long WSAAPI inet_addr(const char *cp); + WINSOCK_API_LINKAGE char *WSAAPI inet_ntoa(struct in_addr in); + WINSOCK_API_LINKAGE int WSAAPI listen(SOCKET s,int backlog); + WINSOCK_API_LINKAGE u_long WSAAPI ntohl(u_long netlong); + WINSOCK_API_LINKAGE u_short WSAAPI ntohs(u_short netshort); + WINSOCK_API_LINKAGE int WSAAPI recv(SOCKET s,char *buf,int len,int flags); + WINSOCK_API_LINKAGE int WSAAPI recvfrom(SOCKET s,char *buf,int len,int flags,struct sockaddr *from,int *fromlen); + WINSOCK_API_LINKAGE int WSAAPI select(int nfds,fd_set *readfds,fd_set *writefds,fd_set *exceptfds,const struct timeval *timeout); + WINSOCK_API_LINKAGE int WSAAPI send(SOCKET s,const char *buf,int len,int flags); + WINSOCK_API_LINKAGE int WSAAPI sendto(SOCKET s,const char *buf,int len,int flags,const struct sockaddr *to,int tolen); + WINSOCK_API_LINKAGE int WSAAPI setsockopt(SOCKET s,int level,int optname,const char *optval,int optlen); + WINSOCK_API_LINKAGE int WSAAPI shutdown(SOCKET s,int how); + WINSOCK_API_LINKAGE SOCKET WSAAPI socket(int af,int type,int protocol); + WINSOCK_API_LINKAGE struct hostent *WSAAPI gethostbyaddr(const char *addr,int len,int type); + WINSOCK_API_LINKAGE struct hostent *WSAAPI gethostbyname(const char *name); + WINSOCK_API_LINKAGE int WSAAPI gethostname(char *name,int namelen); + WINSOCK_API_LINKAGE struct servent *WSAAPI getservbyport(int port,const char *proto); + WINSOCK_API_LINKAGE struct servent *WSAAPI getservbyname(const char *name,const char *proto); + WINSOCK_API_LINKAGE struct protoent *WSAAPI getprotobynumber(int number); + WINSOCK_API_LINKAGE struct protoent *WSAAPI getprotobyname(const char *name); + WINSOCK_API_LINKAGE int WSAAPI WSAStartup(WORD wVersionRequested,LPWSADATA lpWSAData); + WINSOCK_API_LINKAGE int WSAAPI WSACleanup(void); + WINSOCK_API_LINKAGE void WSAAPI WSASetLastError(int iError); + WINSOCK_API_LINKAGE int WSAAPI WSAGetLastError(void); + WINSOCK_API_LINKAGE WINBOOL WSAAPI WSAIsBlocking(void); + WINSOCK_API_LINKAGE int WSAAPI WSAUnhookBlockingHook(void); + WINSOCK_API_LINKAGE FARPROC WSAAPI WSASetBlockingHook(FARPROC lpBlockFunc); + WINSOCK_API_LINKAGE int WSAAPI WSACancelBlockingCall(void); + WINSOCK_API_LINKAGE HANDLE WSAAPI WSAAsyncGetServByName(HWND hWnd,u_int wMsg,const char *name,const char *proto,char *buf,int buflen); + WINSOCK_API_LINKAGE HANDLE WSAAPI WSAAsyncGetServByPort(HWND hWnd,u_int wMsg,int port,const char *proto,char *buf,int buflen); + WINSOCK_API_LINKAGE HANDLE WSAAPI WSAAsyncGetProtoByName(HWND hWnd,u_int wMsg,const char *name,char *buf,int buflen); + WINSOCK_API_LINKAGE HANDLE WSAAPI WSAAsyncGetProtoByNumber(HWND hWnd,u_int wMsg,int number,char *buf,int buflen); + WINSOCK_API_LINKAGE HANDLE WSAAPI WSAAsyncGetHostByName(HWND hWnd,u_int wMsg,const char *name,char *buf,int buflen); + WINSOCK_API_LINKAGE HANDLE WSAAPI WSAAsyncGetHostByAddr(HWND hWnd,u_int wMsg,const char *addr,int len,int type,char *buf,int buflen); + WINSOCK_API_LINKAGE int WSAAPI WSACancelAsyncRequest(HANDLE hAsyncTaskHandle); + WINSOCK_API_LINKAGE int WSAAPI WSAAsyncSelect(SOCKET s,HWND hWnd,u_int wMsg,long lEvent); +#endif /* __WINSOCK_WS1_SHARED */ + WINSOCK_API_LINKAGE SOCKET WSAAPI WSAAccept(SOCKET s,struct sockaddr *addr,LPINT addrlen,LPCONDITIONPROC lpfnCondition,DWORD_PTR dwCallbackData); + WINSOCK_API_LINKAGE WINBOOL WSAAPI WSACloseEvent(WSAEVENT hEvent); + WINSOCK_API_LINKAGE int WSAAPI WSAConnect(SOCKET s,const struct sockaddr *name,int namelen,LPWSABUF lpCallerData,LPWSABUF lpCalleeData,LPQOS lpSQOS,LPQOS lpGQOS); + WINSOCK_API_LINKAGE WSAEVENT WSAAPI WSACreateEvent(void); + WINSOCK_API_LINKAGE int WSAAPI WSADuplicateSocketA(SOCKET s,DWORD dwProcessId,LPWSAPROTOCOL_INFOA lpProtocolInfo); + WINSOCK_API_LINKAGE int WSAAPI WSADuplicateSocketW(SOCKET s,DWORD dwProcessId,LPWSAPROTOCOL_INFOW lpProtocolInfo); + WINSOCK_API_LINKAGE int WSAAPI WSAEnumNetworkEvents(SOCKET s,WSAEVENT hEventObject,LPWSANETWORKEVENTS lpNetworkEvents); + WINSOCK_API_LINKAGE int WSAAPI WSAEnumProtocolsA(LPINT lpiProtocols,LPWSAPROTOCOL_INFOA lpProtocolBuffer,LPDWORD lpdwBufferLength); + WINSOCK_API_LINKAGE int WSAAPI WSAEnumProtocolsW(LPINT lpiProtocols,LPWSAPROTOCOL_INFOW lpProtocolBuffer,LPDWORD lpdwBufferLength); + WINSOCK_API_LINKAGE int WSAAPI WSAEventSelect(SOCKET s,WSAEVENT hEventObject,long lNetworkEvents); + WINSOCK_API_LINKAGE WINBOOL WSAAPI WSAGetOverlappedResult(SOCKET s,LPWSAOVERLAPPED lpOverlapped,LPDWORD lpcbTransfer,WINBOOL fWait,LPDWORD lpdwFlags); + WINSOCK_API_LINKAGE WINBOOL WSAAPI WSAGetQOSByName(SOCKET s,LPWSABUF lpQOSName,LPQOS lpQOS); + WINSOCK_API_LINKAGE int WSAAPI WSAHtonl(SOCKET s,u_long hostlong,u_long *lpnetlong); + WINSOCK_API_LINKAGE int WSAAPI WSAHtons(SOCKET s,u_short hostshort,u_short *lpnetshort); + WINSOCK_API_LINKAGE int WSAAPI WSAIoctl(SOCKET s,DWORD dwIoControlCode,LPVOID lpvInBuffer,DWORD cbInBuffer,LPVOID lpvOutBuffer,DWORD cbOutBuffer,LPDWORD lpcbBytesReturned,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + WINSOCK_API_LINKAGE SOCKET WSAAPI WSAJoinLeaf(SOCKET s,const struct sockaddr *name,int namelen,LPWSABUF lpCallerData,LPWSABUF lpCalleeData,LPQOS lpSQOS,LPQOS lpGQOS,DWORD dwFlags); + WINSOCK_API_LINKAGE int WSAAPI WSANtohl(SOCKET s,u_long netlong,u_long *lphostlong); + WINSOCK_API_LINKAGE int WSAAPI WSANtohs(SOCKET s,u_short netshort,u_short *lphostshort); + WINSOCK_API_LINKAGE int WSAAPI WSARecv(SOCKET s,LPWSABUF lpBuffers,DWORD dwBufferCount,LPDWORD lpNumberOfBytesRecvd,LPDWORD lpFlags,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + WINSOCK_API_LINKAGE int WSAAPI WSARecvDisconnect(SOCKET s,LPWSABUF lpInboundDisconnectData); + WINSOCK_API_LINKAGE int WSAAPI WSARecvFrom(SOCKET s,LPWSABUF lpBuffers,DWORD dwBufferCount,LPDWORD lpNumberOfBytesRecvd,LPDWORD lpFlags,struct sockaddr *lpFrom,LPINT lpFromlen,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + WINSOCK_API_LINKAGE WINBOOL WSAAPI WSAResetEvent(WSAEVENT hEvent); + WINSOCK_API_LINKAGE int WSAAPI WSASend(SOCKET s,LPWSABUF lpBuffers,DWORD dwBufferCount,LPDWORD lpNumberOfBytesSent,DWORD dwFlags,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + WINSOCK_API_LINKAGE int WSAAPI WSASendDisconnect(SOCKET s,LPWSABUF lpOutboundDisconnectData); + WINSOCK_API_LINKAGE int WSAAPI WSASendTo(SOCKET s,LPWSABUF lpBuffers,DWORD dwBufferCount,LPDWORD lpNumberOfBytesSent,DWORD dwFlags,const struct sockaddr *lpTo,int iTolen,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + WINSOCK_API_LINKAGE WINBOOL WSAAPI WSASetEvent(WSAEVENT hEvent); + WINSOCK_API_LINKAGE SOCKET WSAAPI WSASocketA(int af,int type,int protocol,LPWSAPROTOCOL_INFOA lpProtocolInfo,GROUP g,DWORD dwFlags); + WINSOCK_API_LINKAGE SOCKET WSAAPI WSASocketW(int af,int type,int protocol,LPWSAPROTOCOL_INFOW lpProtocolInfo,GROUP g,DWORD dwFlags); + WINSOCK_API_LINKAGE DWORD WSAAPI WSAWaitForMultipleEvents(DWORD cEvents,const WSAEVENT *lphEvents,WINBOOL fWaitAll,DWORD dwTimeout,WINBOOL fAlertable); + WINSOCK_API_LINKAGE INT WSAAPI WSAAddressToStringA(LPSOCKADDR lpsaAddress,DWORD dwAddressLength,LPWSAPROTOCOL_INFOA lpProtocolInfo,LPSTR lpszAddressString,LPDWORD lpdwAddressStringLength); + WINSOCK_API_LINKAGE INT WSAAPI WSAAddressToStringW(LPSOCKADDR lpsaAddress,DWORD dwAddressLength,LPWSAPROTOCOL_INFOW lpProtocolInfo,LPWSTR lpszAddressString,LPDWORD lpdwAddressStringLength); + WINSOCK_API_LINKAGE INT WSAAPI WSAStringToAddressA(LPSTR AddressString,INT AddressFamily,LPWSAPROTOCOL_INFOA lpProtocolInfo,LPSOCKADDR lpAddress,LPINT lpAddressLength); + WINSOCK_API_LINKAGE INT WSAAPI WSAStringToAddressW(LPWSTR AddressString,INT AddressFamily,LPWSAPROTOCOL_INFOW lpProtocolInfo,LPSOCKADDR lpAddress,LPINT lpAddressLength); + WINSOCK_API_LINKAGE INT WSAAPI WSALookupServiceBeginA(LPWSAQUERYSETA lpqsRestrictions,DWORD dwControlFlags,LPHANDLE lphLookup); + WINSOCK_API_LINKAGE INT WSAAPI WSALookupServiceBeginW(LPWSAQUERYSETW lpqsRestrictions,DWORD dwControlFlags,LPHANDLE lphLookup); + WINSOCK_API_LINKAGE INT WSAAPI WSALookupServiceNextA(HANDLE hLookup,DWORD dwControlFlags,LPDWORD lpdwBufferLength,LPWSAQUERYSETA lpqsResults); + WINSOCK_API_LINKAGE INT WSAAPI WSALookupServiceNextW(HANDLE hLookup,DWORD dwControlFlags,LPDWORD lpdwBufferLength,LPWSAQUERYSETW lpqsResults); + WINSOCK_API_LINKAGE INT WSAAPI WSANSPIoctl(HANDLE hLookup,DWORD dwControlCode,LPVOID lpvInBuffer,DWORD cbInBuffer,LPVOID lpvOutBuffer,DWORD cbOutBuffer,LPDWORD lpcbBytesReturned,LPWSACOMPLETION lpCompletion); + WINSOCK_API_LINKAGE INT WSAAPI WSALookupServiceEnd(HANDLE hLookup); + WINSOCK_API_LINKAGE INT WSAAPI WSAInstallServiceClassA(LPWSASERVICECLASSINFOA lpServiceClassInfo); + WINSOCK_API_LINKAGE INT WSAAPI WSAInstallServiceClassW(LPWSASERVICECLASSINFOW lpServiceClassInfo); + WINSOCK_API_LINKAGE INT WSAAPI WSARemoveServiceClass(LPGUID lpServiceClassId); + WINSOCK_API_LINKAGE INT WSAAPI WSAGetServiceClassInfoA(LPGUID lpProviderId,LPGUID lpServiceClassId,LPDWORD lpdwBufSize,LPWSASERVICECLASSINFOA lpServiceClassInfo); + WINSOCK_API_LINKAGE INT WSAAPI WSAGetServiceClassInfoW(LPGUID lpProviderId,LPGUID lpServiceClassId,LPDWORD lpdwBufSize,LPWSASERVICECLASSINFOW lpServiceClassInfo); + WINSOCK_API_LINKAGE INT WSAAPI WSAEnumNameSpaceProvidersA(LPDWORD lpdwBufferLength,LPWSANAMESPACE_INFOA lpnspBuffer); + WINSOCK_API_LINKAGE INT WSAAPI WSAEnumNameSpaceProvidersW(LPDWORD lpdwBufferLength,LPWSANAMESPACE_INFOW lpnspBuffer); + WINSOCK_API_LINKAGE INT WSAAPI WSAGetServiceClassNameByClassIdA(LPGUID lpServiceClassId,LPSTR lpszServiceClassName,LPDWORD lpdwBufferLength); + WINSOCK_API_LINKAGE INT WSAAPI WSAGetServiceClassNameByClassIdW(LPGUID lpServiceClassId,LPWSTR lpszServiceClassName,LPDWORD lpdwBufferLength); + WINSOCK_API_LINKAGE INT WSAAPI WSASetServiceA(LPWSAQUERYSETA lpqsRegInfo,WSAESETSERVICEOP essoperation,DWORD dwControlFlags); + WINSOCK_API_LINKAGE INT WSAAPI WSASetServiceW(LPWSAQUERYSETW lpqsRegInfo,WSAESETSERVICEOP essoperation,DWORD dwControlFlags); + WINSOCK_API_LINKAGE INT WSAAPI WSAProviderConfigChange(LPHANDLE lpNotificationHandle,LPWSAOVERLAPPED lpOverlapped,LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine); + +#define WSAMAKEASYNCREPLY(buflen,error) MAKELONG(buflen,error) +#define WSAMAKESELECTREPLY(event,error) MAKELONG(event,error) +#define WSAGETASYNCBUFLEN(lParam) LOWORD(lParam) +#define WSAGETASYNCERROR(lParam) HIWORD(lParam) +#define WSAGETSELECTEVENT(lParam) LOWORD(lParam) +#define WSAGETSELECTERROR(lParam) HIWORD(lParam) + +#if (_WIN32_WINNT >= 0x0600) +typedef struct _WSANAMESPACE_INFOEXA { + GUID NSProviderId; + DWORD dwNameSpace; + WINBOOL fActive; + DWORD dwVersion; + LPSTR lpszIdentifier; + BLOB ProviderSpecific; +} WSANAMESPACE_INFOEXA, *PWSANAMESPACE_INFOEXA, *LPWSANAMESPACE_INFOEXA; + +typedef struct _WSANAMESPACE_INFOEXW { + GUID NSProviderId; + DWORD dwNameSpace; + WINBOOL fActive; + DWORD dwVersion; + LPWSTR lpszIdentifier; + BLOB ProviderSpecific; +} WSANAMESPACE_INFOEXW, *PWSANAMESPACE_INFOEXW, *LPWSANAMESPACE_INFOEXW; + +__MINGW_TYPEDEF_AW(WSANAMESPACE_INFOEX) +__MINGW_TYPEDEF_AW(PWSANAMESPACE_INFOEX) +__MINGW_TYPEDEF_AW(LPWSANAMESPACE_INFOEX) + +typedef struct _WSAQUERYSET2A { + DWORD dwSize; + LPSTR lpszServiceInstanceName; + LPWSAVERSION lpVersion; + LPSTR lpszComment; + DWORD dwNameSpace; + LPGUID lpNSProviderId; + LPSTR lpszContext; + DWORD dwNumberOfProtocols; + LPAFPROTOCOLS lpafpProtocols; + LPSTR lpszQueryString; + DWORD dwNumberOfCsAddrs; + LPCSADDR_INFO lpcsaBuffer; + DWORD dwOutputFlags; + LPBLOB lpBlob; +} WSAQUERYSET2A, *PWSAQUERYSET2A, *LPWSAQUERYSET2A; + +typedef struct _WSAQUERYSET2W { + DWORD dwSize; + LPWSTR lpszServiceInstanceName; + LPWSAVERSION lpVersion; + LPWSTR lpszComment; + DWORD dwNameSpace; + LPGUID lpNSProviderId; + LPTSTR lpszContext; + DWORD dwNumberOfProtocols; + LPAFPROTOCOLS lpafpProtocols; + LPWSTR lpszQueryString; + DWORD dwNumberOfCsAddrs; + LPCSADDR_INFO lpcsaBuffer; + DWORD dwOutputFlags; + LPBLOB lpBlob; +} WSAQUERYSET2W, *PWSAQUERYSET2W, *LPWSAQUERYSET2W; + +#define POLLRDNORM 0x0100 +#define POLLRDBAND 0x0200 +#define POLLIN (POLLRDNORM | POLLRDBAND) +#define POLLPRI 0x0400 + +#define POLLWRNORM 0x0010 +#define POLLOUT (POLLWRNORM) +#define POLLWRBAND 0x0020 + +#define POLLERR 0x0001 +#define POLLHUP 0x0002 +#define POLLNVAL 0x0004 + +typedef struct pollfd { + SOCKET fd; + short events; + short revents; +} WSAPOLLFD, *PWSAPOLLFD, *LPWSAPOLLFD; + +WINSOCK_API_LINKAGE WINBOOL PASCAL WSAConnectByList( + SOCKET s, + PSOCKET_ADDRESS_LIST SocketAddressList, + LPDWORD LocalAddressLength, + LPSOCKADDR LocalAddress, + LPDWORD RemoteAddressLength, + LPSOCKADDR RemoteAddress, + const struct timeval *timeout, + LPWSAOVERLAPPED Reserved +); + +WINSOCK_API_LINKAGE WINBOOL PASCAL WSAConnectByNameA( + SOCKET s, + LPSTR nodename, + LPSTR servicename, + LPDWORD LocalAddressLength, + LPSOCKADDR LocalAddress, + LPDWORD RemoteAddressLength, + LPSOCKADDR RemoteAddress, + const struct timeval *timeout, + LPWSAOVERLAPPED Reserved +); + +WINSOCK_API_LINKAGE WINBOOL PASCAL WSAConnectByNameW( + SOCKET s, + LPWSTR nodename, + LPWSTR servicename, + LPDWORD LocalAddressLength, + LPSOCKADDR LocalAddress, + LPDWORD RemoteAddressLength, + LPSOCKADDR RemoteAddress, + const struct timeval *timeout, + LPWSAOVERLAPPED Reserved +); +#define WSAConnectByName __MINGW_NAME_AW(WSAConnectByName) + +INT WSAAPI WSAEnumNameSpaceProvidersExA( + LPDWORD lpdwBufferLength, + LPWSANAMESPACE_INFOEXA lpnspBuffer +); + +INT WSAAPI WSAEnumNameSpaceProvidersExW( + LPDWORD lpdwBufferLength, + LPWSANAMESPACE_INFOEXW lpnspBuffer +); +#define WSAEnumNameSpaceProvidersEx __MINGW_NAME_AW(WSAEnumNameSpaceProvidersEx) + +int WSAAPI WSAPoll( + WSAPOLLFD fdarray[], + ULONG nfds, + INT timeout +); + +int WSAAPI WSASendMsg( + SOCKET s, + LPWSAMSG lpMsg, + DWORD dwFlags, + LPDWORD lpNumberOfBytesSent, + LPWSAOVERLAPPED lpOverlapped, + LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine +); +#endif /*(_WIN32_WINNT >= 0x0600)*/ + +#ifdef __cplusplus +} +#endif + +#ifdef _NEED_POPPACK +#include +#endif + +#ifdef IPV6STRICT +#include +#endif + +#endif /* _WINSOCK2API_ */ diff --git a/win32/include/winapi/ws2def.h b/win32/include/winapi/ws2def.h new file mode 100644 index 00000000..4b0e2dad --- /dev/null +++ b/win32/include/winapi/ws2def.h @@ -0,0 +1,39 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ + +#ifndef _WS2DEF_ +#define _WS2DEF_ + +#include <_mingw.h> + +/* FIXME FIXME FIXME FIXME FIXME: Much more data need moving here. + * This holds only SCOPE_LEVEL and SCOPE_ID so that compilations + * do not fail. + */ + +typedef enum _SCOPE_LEVEL { + ScopeLevelInterface = 1, + ScopeLevelLink = 2, + ScopeLevelSubnet = 3, + ScopeLevelAdmin = 4, + ScopeLevelSite = 5, + ScopeLevelOrganization = 8, + ScopeLevelGlobal = 14, + ScopeLevelCount = 16 +} SCOPE_LEVEL; + +typedef struct _SCOPE_ID { + __C89_NAMELESS union { + __C89_NAMELESS struct { + ULONG Zone : 28; + ULONG Level : 4; + }; + ULONG Value; + }; +} SCOPE_ID, *PSCOPE_ID; + +#endif /* _WS2DEF_ */ + diff --git a/win32/include/winapi/ws2ipdef.h b/win32/include/winapi/ws2ipdef.h new file mode 100644 index 00000000..cb503bd2 --- /dev/null +++ b/win32/include/winapi/ws2ipdef.h @@ -0,0 +1,94 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ +#ifndef _INC_WS2IPDEF +#define _INC_WS2IPDEF + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct ipv6_mreq { + struct in6_addr ipv6mr_multiaddr; + unsigned int ipv6mr_interface; +} IPV6_MREQ; + +struct sockaddr_in6_old { + short sin6_family; + u_short sin6_port; + u_long sin6_flowinfo; + struct in6_addr sin6_addr; +}; + +typedef union sockaddr_gen { + struct sockaddr Address; + struct sockaddr_in AddressIn; + struct sockaddr_in6_old AddressIn6; +} sockaddr_gen; + +struct sockaddr_in6 { + short sin6_family; + u_short sin6_port; + u_long sin6_flowinfo; + struct in6_addr sin6_addr; + __C89_NAMELESS union { + u_long sin6_scope_id; + SCOPE_ID sin6_scope_struct; + }; +}; + +typedef struct sockaddr_in6 SOCKADDR_IN6; +typedef struct sockaddr_in6 *PSOCKADDR_IN6; +typedef struct sockaddr_in6 *LPSOCKADDR_IN6; + +typedef struct _INTERFACE_INFO { + u_long iiFlags; + sockaddr_gen iiAddress; + sockaddr_gen iiBroadcastAddress; + sockaddr_gen iiNetmask; +} INTERFACE_INFO,*LPINTERFACE_INFO; + +typedef enum _MULTICAST_MODE_TYPE { + MCAST_INCLUDE = 0, + MCAST_EXCLUDE +} MULTICAST_MODE_TYPE; + +typedef struct _sockaddr_in6_pair { + PSOCKADDR_IN6 SourceAddress; + PSOCKADDR_IN6 DestinationAddress; +} SOCKADDR_IN6_PAIR, *PSOCKADDR_IN6_PAIR; + +typedef union _SOCKADDR_INET { + SOCKADDR_IN Ipv4; + SOCKADDR_IN6 Ipv6; + ADDRESS_FAMILY si_family; +} SOCKADDR_INET, *PSOCKADDR_INET; + +typedef struct group_filter { + ULONG gf_interface; + SOCKADDR_STORAGE gf_group; + MULTICAST_MODE_TYPE gf_fmode; + ULONG gf_numsrc; + SOCKADDR_STORAGE gf_slist[1]; +} GROUP_FILTER, *PGROUP_FILTER; + +typedef struct group_req { + ULONG gr_interface; + SOCKADDR_STORAGE gr_group; +} GROUP_REQ, *PGROUP_REQ; + +typedef struct group_source_req { + ULONG gsr_interface; + SOCKADDR_STORAGE gsr_group; + SOCKADDR_STORAGE gsr_source; +} GROUP_SOURCE_REQ, *PGROUP_SOURCE_REQ; + +#ifdef __cplusplus +} +#endif + +#endif /*_INC_WS2IPDEF*/ diff --git a/win32/include/winapi/ws2tcpip.h b/win32/include/winapi/ws2tcpip.h new file mode 100644 index 00000000..4e4d7a4a --- /dev/null +++ b/win32/include/winapi/ws2tcpip.h @@ -0,0 +1,437 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ +#ifndef _WS2TCPIP_H_ +#define _WS2TCPIP_H_ + +#include <_mingw_unicode.h> + +#include +#include + +struct ip_mreq_source { + struct in_addr imr_multiaddr; + struct in_addr imr_sourceaddr; + struct in_addr imr_interface; +}; + +struct ip_msfilter { + struct in_addr imsf_multiaddr; + struct in_addr imsf_interface; + u_long imsf_fmode; + u_long imsf_numsrc; + struct in_addr imsf_slist[1]; +}; + +#define IP_MSFILTER_SIZE(numsrc) (sizeof(struct ip_msfilter)-sizeof(struct in_addr) + (numsrc)*sizeof(struct in_addr)) + +#define SIO_GET_INTERFACE_LIST _IOR('t',127,u_long) + +#define SIO_GET_INTERFACE_LIST_EX _IOR('t',126,u_long) +#define SIO_SET_MULTICAST_FILTER _IOW('t',125,u_long) +#define SIO_GET_MULTICAST_FILTER _IOW('t',124 | IOC_IN,u_long) + +#define IP_OPTIONS 1 +#define IP_HDRINCL 2 +#define IP_TOS 3 +#define IP_TTL 4 +#define IP_MULTICAST_IF 9 +#define IP_MULTICAST_TTL 10 +#define IP_MULTICAST_LOOP 11 +#define IP_ADD_MEMBERSHIP 12 +#define IP_DROP_MEMBERSHIP 13 +#define IP_DONTFRAGMENT 14 +#define IP_ADD_SOURCE_MEMBERSHIP 15 +#define IP_DROP_SOURCE_MEMBERSHIP 16 +#define IP_BLOCK_SOURCE 17 +#define IP_UNBLOCK_SOURCE 18 +#define IP_PKTINFO 19 +#define IP_RECEIVE_BROADCAST 22 + +#define IPV6_HDRINCL 2 +#define IPV6_UNICAST_HOPS 4 +#define IPV6_MULTICAST_IF 9 +#define IPV6_MULTICAST_HOPS 10 +#define IPV6_MULTICAST_LOOP 11 +#define IPV6_ADD_MEMBERSHIP 12 +#define IPV6_DROP_MEMBERSHIP 13 +#define IPV6_JOIN_GROUP IPV6_ADD_MEMBERSHIP +#define IPV6_LEAVE_GROUP IPV6_DROP_MEMBERSHIP +#define IPV6_PKTINFO 19 +#define IPV6_HOPLIMIT 21 +#define IPV6_PROTECTION_LEVEL 23 + +#define PROTECTION_LEVEL_UNRESTRICTED 10 +#define PROTECTION_LEVEL_DEFAULT 20 +#define PROTECTION_LEVEL_RESTRICTED 30 + +#define UDP_NOCHECKSUM 1 +#define UDP_CHECKSUM_COVERAGE 20 + +#define TCP_EXPEDITED_1122 0x0002 + + +#include + + +#define SS_PORT(ssp) (((struct sockaddr_in*)(ssp))->sin_port) + +#define IN6ADDR_ANY_INIT { 0 } +#define IN6ADDR_LOOPBACK_INIT { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } + +#ifdef __cplusplus +extern "C" { +#endif + + extern const struct in6_addr in6addr_any; + extern const struct in6_addr in6addr_loopback; + +#define WS2TCPIP_INLINE __CRT_INLINE + +int IN6_ADDR_EQUAL(const struct in6_addr *,const struct in6_addr *); +int IN6_IS_ADDR_UNSPECIFIED(const struct in6_addr *); +int IN6_IS_ADDR_LOOPBACK(const struct in6_addr *); +int IN6_IS_ADDR_MULTICAST(const struct in6_addr *); +int IN6_IS_ADDR_LINKLOCAL(const struct in6_addr *); +int IN6_IS_ADDR_SITELOCAL(const struct in6_addr *); +int IN6_IS_ADDR_V4MAPPED(const struct in6_addr *); +int IN6_IS_ADDR_V4COMPAT(const struct in6_addr *); +int IN6_IS_ADDR_MC_NODELOCAL(const struct in6_addr *); +int IN6_IS_ADDR_MC_LINKLOCAL(const struct in6_addr *); +int IN6_IS_ADDR_MC_SITELOCAL(const struct in6_addr *); +int IN6_IS_ADDR_MC_ORGLOCAL(const struct in6_addr *); +int IN6_IS_ADDR_MC_GLOBAL(const struct in6_addr *); +int IN6ADDR_ISANY(const struct sockaddr_in6 *); +int IN6ADDR_ISLOOPBACK(const struct sockaddr_in6 *); +void IN6_SET_ADDR_UNSPECIFIED(struct in6_addr *); +void IN6_SET_ADDR_LOOPBACK(struct in6_addr *); +void IN6ADDR_SETANY(struct sockaddr_in6 *); +void IN6ADDR_SETLOOPBACK(struct sockaddr_in6 *); + +#ifndef __CRT__NO_INLINE +WS2TCPIP_INLINE int IN6_ADDR_EQUAL(const struct in6_addr *a,const struct in6_addr *b) { return (memcmp(a,b,sizeof(struct in6_addr))==0); } +WS2TCPIP_INLINE int IN6_IS_ADDR_UNSPECIFIED(const struct in6_addr *a) { return ((a->s6_words[0]==0) && (a->s6_words[1]==0) && (a->s6_words[2]==0) && (a->s6_words[3]==0) && (a->s6_words[4]==0) && (a->s6_words[5]==0) && (a->s6_words[6]==0) && (a->s6_words[7]==0)); } +WS2TCPIP_INLINE int IN6_IS_ADDR_LOOPBACK(const struct in6_addr *a) { return ((a->s6_words[0]==0) && (a->s6_words[1]==0) && (a->s6_words[2]==0) && (a->s6_words[3]==0) && (a->s6_words[4]==0) && (a->s6_words[5]==0) && (a->s6_words[6]==0) && (a->s6_words[7]==0x0100)); } +WS2TCPIP_INLINE int IN6_IS_ADDR_MULTICAST(const struct in6_addr *a) { return (a->s6_bytes[0]==0xff); } +WS2TCPIP_INLINE int IN6_IS_ADDR_LINKLOCAL(const struct in6_addr *a) { return ((a->s6_bytes[0]==0xfe) && ((a->s6_bytes[1] & 0xc0)==0x80)); } +WS2TCPIP_INLINE int IN6_IS_ADDR_SITELOCAL(const struct in6_addr *a) { return ((a->s6_bytes[0]==0xfe) && ((a->s6_bytes[1] & 0xc0)==0xc0)); } +WS2TCPIP_INLINE int IN6_IS_ADDR_V4MAPPED(const struct in6_addr *a) { return ((a->s6_words[0]==0) && (a->s6_words[1]==0) && (a->s6_words[2]==0) && (a->s6_words[3]==0) && (a->s6_words[4]==0) && (a->s6_words[5]==0xffff)); } +WS2TCPIP_INLINE int IN6_IS_ADDR_V4COMPAT(const struct in6_addr *a) { return ((a->s6_words[0]==0) && (a->s6_words[1]==0) && (a->s6_words[2]==0) && (a->s6_words[3]==0) && (a->s6_words[4]==0) && (a->s6_words[5]==0) && !((a->s6_words[6]==0) && (a->s6_addr[14]==0) && ((a->s6_addr[15]==0) || (a->s6_addr[15]==1)))); } +WS2TCPIP_INLINE int IN6_IS_ADDR_MC_NODELOCAL(const struct in6_addr *a) { return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_bytes[1] & 0xf)==1); } +WS2TCPIP_INLINE int IN6_IS_ADDR_MC_LINKLOCAL(const struct in6_addr *a) { return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_bytes[1] & 0xf)==2); } +WS2TCPIP_INLINE int IN6_IS_ADDR_MC_SITELOCAL(const struct in6_addr *a) { return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_bytes[1] & 0xf)==5); } +WS2TCPIP_INLINE int IN6_IS_ADDR_MC_ORGLOCAL(const struct in6_addr *a) { return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_bytes[1] & 0xf)==8); } +WS2TCPIP_INLINE int IN6_IS_ADDR_MC_GLOBAL(const struct in6_addr *a) { return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_bytes[1] & 0xf)==0xe); } +WS2TCPIP_INLINE int IN6ADDR_ISANY(const struct sockaddr_in6 *a) { return ((a->sin6_family==AF_INET6) && IN6_IS_ADDR_UNSPECIFIED(&a->sin6_addr)); } +WS2TCPIP_INLINE int IN6ADDR_ISLOOPBACK(const struct sockaddr_in6 *a) { return ((a->sin6_family==AF_INET6) && IN6_IS_ADDR_LOOPBACK(&a->sin6_addr)); } +WS2TCPIP_INLINE void IN6_SET_ADDR_UNSPECIFIED(struct in6_addr *a) { memset(a->s6_bytes,0,sizeof(struct in6_addr)); } +WS2TCPIP_INLINE void IN6_SET_ADDR_LOOPBACK(struct in6_addr *a) { + memset(a->s6_bytes,0,sizeof(struct in6_addr)); + a->s6_bytes[15] = 1; +} +WS2TCPIP_INLINE void IN6ADDR_SETANY(struct sockaddr_in6 *a) { + a->sin6_family = AF_INET6; + a->sin6_port = 0; + a->sin6_flowinfo = 0; + IN6_SET_ADDR_UNSPECIFIED(&a->sin6_addr); + a->sin6_scope_id = 0; +} +WS2TCPIP_INLINE void IN6ADDR_SETLOOPBACK(struct sockaddr_in6 *a) { + a->sin6_family = AF_INET6; + a->sin6_port = 0; + a->sin6_flowinfo = 0; + IN6_SET_ADDR_LOOPBACK(&a->sin6_addr); + a->sin6_scope_id = 0; +} +#endif /* !__CRT__NO_INLINE */ + +#ifdef __cplusplus +} +#endif + +typedef struct _INTERFACE_INFO_EX { + u_long iiFlags; + SOCKET_ADDRESS iiAddress; + SOCKET_ADDRESS iiBroadcastAddress; + SOCKET_ADDRESS iiNetmask; +} INTERFACE_INFO_EX,*LPINTERFACE_INFO_EX; + +#define IFF_UP 0x00000001 +#define IFF_BROADCAST 0x00000002 +#define IFF_LOOPBACK 0x00000004 +#define IFF_POINTTOPOINT 0x00000008 +#define IFF_MULTICAST 0x00000010 + +typedef struct in_pktinfo { + IN_ADDR ipi_addr; + UINT ipi_ifindex; +} IN_PKTINFO; + +C_ASSERT(sizeof(IN_PKTINFO)==8); + +typedef struct in6_pktinfo { + IN6_ADDR ipi6_addr; + UINT ipi6_ifindex; +} IN6_PKTINFO; + +C_ASSERT(sizeof(IN6_PKTINFO)==20); + +#define EAI_AGAIN WSATRY_AGAIN +#define EAI_BADFLAGS WSAEINVAL +#define EAI_FAIL WSANO_RECOVERY +#define EAI_FAMILY WSAEAFNOSUPPORT +#define EAI_MEMORY WSA_NOT_ENOUGH_MEMORY + +#define EAI_NONAME WSAHOST_NOT_FOUND +#define EAI_SERVICE WSATYPE_NOT_FOUND +#define EAI_SOCKTYPE WSAESOCKTNOSUPPORT + +#define EAI_NODATA EAI_NONAME + +typedef struct addrinfo { + int ai_flags; + int ai_family; + int ai_socktype; + int ai_protocol; + size_t ai_addrlen; + char *ai_canonname; + struct sockaddr *ai_addr; + struct addrinfo *ai_next; +} ADDRINFOA,*PADDRINFOA; + +typedef struct addrinfoW { + int ai_flags; + int ai_family; + int ai_socktype; + int ai_protocol; + size_t ai_addrlen; + PWSTR ai_canonname; + struct sockaddr *ai_addr; + struct addrinfoW *ai_next; +} ADDRINFOW,*PADDRINFOW; + +typedef __MINGW_NAME_AW(ADDRINFO) ADDRINFOT,*PADDRINFOT; + +typedef ADDRINFOA ADDRINFO,*LPADDRINFO; + +#define AI_PASSIVE 0x1 +#define AI_CANONNAME 0x2 +#define AI_NUMERICHOST 0x4 +#if (_WIN32_WINNT >= 0x0600) +#define AI_ADDRCONFIG 0x0400 +#define AI_NON_AUTHORITATIVE 0x04000 +#define AI_SECURE 0x08000 +#define AI_RETURN_PREFERRED_NAMES 0x010000 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#define GetAddrInfo __MINGW_NAME_AW(GetAddrInfo) + + WINSOCK_API_LINKAGE int WSAAPI getaddrinfo(const char *nodename,const char *servname,const struct addrinfo *hints,struct addrinfo **res); + WINSOCK_API_LINKAGE int WSAAPI GetAddrInfoW(PCWSTR pNodeName,PCWSTR pServiceName,const ADDRINFOW *pHints,PADDRINFOW *ppResult); + +#define GetAddrInfoA getaddrinfo + +#if INCL_WINSOCK_API_TYPEDEFS + typedef int (WSAAPI *LPFN_GETADDRINFO)(const char *nodename,const char *servname,const struct addrinfo *hints,struct addrinfo **res); + typedef int (WSAAPI *LPFN_GETADDRINFOW)(PCWSTR pNodeName,PCWSTR pServiceName,const ADDRINFOW *pHints,PADDRINFOW *ppResult); + +#define LPFN_GETADDRINFOA LPFN_GETADDRINFO + +#define LPFN_GETADDRINFOT __MINGW_NAME_AW(LPFN_GETADDRINFO) +#endif + +#define FreeAddrInfo __MINGW_NAME_AW(FreeAddrInfo) + + WINSOCK_API_LINKAGE void WSAAPI freeaddrinfo(LPADDRINFO pAddrInfo); + WINSOCK_API_LINKAGE void WSAAPI FreeAddrInfoW(PADDRINFOW pAddrInfo); + +#define FreeAddrInfoA freeaddrinfo + +#if INCL_WINSOCK_API_TYPEDEFS + typedef void (WSAAPI *LPFN_FREEADDRINFO)(struct addrinfo *ai); + typedef void (WSAAPI *LPFN_FREEADDRINFOW)(PADDRINFOW pAddrInfo); + +#define LPFN_FREEADDRINFOA LPFN_FREEADDRINFO + +#define LPFN_FREEADDRINFOT __MINGW_NAME_AW(LPFN_FREEADDRINFO) +#endif + + typedef int socklen_t; + +#define GetNameInfo __MINGW_NAME_AW(GetNameInfo) + + WINSOCK_API_LINKAGE int WSAAPI getnameinfo(const struct sockaddr *sa,socklen_t salen,char *host,DWORD hostlen,char *serv,DWORD servlen,int flags); + WINSOCK_API_LINKAGE INT WSAAPI GetNameInfoW(const SOCKADDR *pSockaddr,socklen_t SockaddrLength,PWCHAR pNodeBuffer,DWORD NodeBufferSize,PWCHAR pServiceBuffer,DWORD ServiceBufferSize,INT Flags); + +#define GetNameInfoA getnameinfo + +#if INCL_WINSOCK_API_TYPEDEFS + typedef int (WSAAPI *LPFN_GETNAMEINFO)(const struct sockaddr *sa,socklen_t salen,char *host,DWORD hostlen,char *serv,DWORD servlen,int flags); + typedef INT (WSAAPI *LPFN_GETNAMEINFOW)(const SOCKADDR *pSockaddr,socklen_t SockaddrLength,PWCHAR pNodeBuffer,DWORD NodeBufferSize,PWCHAR pServiceBuffer,DWORD ServiceBufferSize,INT Flags); + +#define LPFN_GETNAMEINFOA LPFN_GETNAMEINFO + +#define LPFN_GETNAMEINFOT __MINGW_NAME_AW(LPFN_GETNAMEINFO) +#endif + +#define gai_strerror __MINGW_NAME_AW(gai_strerror) + +#define GAI_STRERROR_BUFFER_SIZE 1024 + +char *gai_strerrorA (int); +WCHAR *gai_strerrorW(int); + +#define NI_MAXHOST 1025 +#define NI_MAXSERV 32 + +#define INET_ADDRSTRLEN 22 +#define INET6_ADDRSTRLEN 65 + +#define NI_NOFQDN 0x01 +#define NI_NUMERICHOST 0x02 +#define NI_NAMEREQD 0x04 +#define NI_NUMERICSERV 0x08 +#define NI_DGRAM 0x10 + +#include + +#if (_WIN32_WINNT >= 0x0600) +#define addrinfoEx __MINGW_NAME_AW(addrinfoEx) +#define PADDRINFOEX __MINGW_NAME_AW(PADDRINFOEX) +#define GetAddrInfoEx __MINGW_NAME_AW(GetAddrInfoEx) +#define SetAddrInfoEx __MINGW_NAME_AW(SetAddrInfoEx) +#define FreeAddrInfoEx __MINGW_NAME_AW(FreeAddrInfoEx) + + typedef struct addrinfoExA { + int ai_flags; + int ai_family; + int ai_socktype; + int ai_protocol; + size_t ai_addrlen; + LPCSTR ai_canonname; + struct sockaddr *ai_addr; + void *ai_blob; + size_t ai_bloblen; + LPGUID ai_provider; + struct addrinfoexA *ai_next; + } ADDRINFOEXA, *PADDRINFOEXA; + + typedef struct addrinfoExW { + int ai_flags; + int ai_family; + int ai_socktype; + int ai_protocol; + size_t ai_addrlen; + LPCWSTR ai_canonname; + struct sockaddr *ai_addr; + void *ai_blob; + size_t ai_bloblen; + LPGUID ai_provider; + struct addrinfoexW *ai_next; + } ADDRINFOEXW, *PADDRINFOEXW; + +typedef PVOID LPLOOKUPSERVICE_COMPLETION_ROUTINE; /*reserved*/ + +WINSOCK_API_LINKAGE int WSAAPI GetAddrInfoExA(PCSTR pName, PCSTR pServiceName, DWORD dwNameSpace, + LPGUID lpNspId,const ADDRINFOEXA *pHints,PADDRINFOEXA *ppResult, + struct timeval *timeout,LPOVERLAPPED lpOverlapped, + LPLOOKUPSERVICE_COMPLETION_ROUTINE lpCompletionRoutine, + LPHANDLE lpNameHandle); +WINSOCK_API_LINKAGE int WSAAPI GetAddrInfoExW(PCWSTR pName,PCWSTR pServiceName,DWORD dwNameSpace, + LPGUID lpNspId,const ADDRINFOEXW *pHints,PADDRINFOEXW *ppResult, + struct timeval *timeout,LPOVERLAPPED lpOverlapped, + LPLOOKUPSERVICE_COMPLETION_ROUTINE lpCompletionRoutine, + LPHANDLE lpNameHandle); + +WINSOCK_API_LINKAGE int WSAAPI SetAddrInfoExA(PCSTR pName, PCSTR pServiceName, SOCKET_ADDRESS *pAddresses, + DWORD dwAddressCount,LPBLOB lpBlob,DWORD dwFlags,DWORD dwNameSpace, + LPGUID lpNspId,struct timeval *timeout,LPOVERLAPPED lpOverlapped, + LPLOOKUPSERVICE_COMPLETION_ROUTINE lpCompletionRoutine, + LPHANDLE lpNameHandle); +WINSOCK_API_LINKAGE int WSAAPI SetAddrInfoExW(PCWSTR pName,PCWSTR pServiceName,SOCKET_ADDRESS *pAddresses, + DWORD dwAddressCount,LPBLOB lpBlob,DWORD dwFlags,DWORD dwNameSpace, + LPGUID lpNspId,struct timeval *timeout,LPOVERLAPPED lpOverlapped, + LPLOOKUPSERVICE_COMPLETION_ROUTINE lpCompletionRoutine, + LPHANDLE lpNameHandle); + +WINSOCK_API_LINKAGE void WSAAPI FreeAddrInfoExA(PADDRINFOEXA pAddrInfo); +WINSOCK_API_LINKAGE void WSAAPI FreeAddrInfoExW(PADDRINFOEXW pAddrInfo); + +#if INCL_WINSOCK_API_TYPEDEFS +#define LPFN_GETADDRINFOEX __MINGW_NAME_AW(LPFN_GETADDRINFOEX) + typedef int (WSAAPI *LPFN_GETADDRINFOEXA)(PCSTR pName, PCSTR pServiceName, DWORD dwNameSpace, + LPGUID lpNspId,const ADDRINFOEXA *pHints,PADDRINFOEXA *ppResult, + struct timeval *timeout,LPOVERLAPPED lpOverlapped, + LPLOOKUPSERVICE_COMPLETION_ROUTINE lpCompletionRoutine, + LPHANDLE lpNameHandle); + typedef int (WSAAPI *LPFN_GETADDRINFOEXW)(PCWSTR pName,PCWSTR pServiceName,DWORD dwNameSpace, + LPGUID lpNspId,const ADDRINFOEXW *pHints,PADDRINFOEXW *ppResult, + struct timeval *timeout,LPOVERLAPPED lpOverlapped, + LPLOOKUPSERVICE_COMPLETION_ROUTINE lpCompletionRoutine, + LPHANDLE lpNameHandle); + +#define LPFN_SETADDRINFOEX __MINGW_NAME_AW(LPFN_SETADDRINFOEX) + typedef int (WSAAPI *LPFN_SETADDRINFOEXA)(PCSTR pName, PCSTR pServiceName, SOCKET_ADDRESS *pAddresses, + DWORD dwAddressCount,LPBLOB lpBlob,DWORD dwFlags,DWORD dwNameSpace, + LPGUID lpNspId,struct timeval *timeout,LPOVERLAPPED lpOverlapped, + LPLOOKUPSERVICE_COMPLETION_ROUTINE lpCompletionRoutine, + LPHANDLE lpNameHandle); + typedef int (WSAAPI *LPFN_SETADDRINFOEXW)(PCWSTR pName,PCWSTR pServiceName,SOCKET_ADDRESS *pAddresses, + DWORD dwAddressCount,LPBLOB lpBlob,DWORD dwFlags,DWORD dwNameSpace, + LPGUID lpNspId,struct timeval *timeout,LPOVERLAPPED lpOverlapped, + LPLOOKUPSERVICE_COMPLETION_ROUTINE lpCompletionRoutine, + LPHANDLE lpNameHandle); + +#define LPFN_FREEADDRINFOEX __MINGW_NAME_AW(LPFN_FREEADDRINFOEX) + typedef void (WSAAPI *LPFN_FREEADDRINFOEXA)(PADDRINFOEXA pAddrInfo); + typedef void (WSAAPI *LPFN_FREEADDRINFOEXW)(PADDRINFOEXW pAddrInfo); +#endif /* INCL_WINSOCK_API_TYPEDEFS */ + + +WINSOCK_API_LINKAGE int WSAAPI WSAImpersonateSocketPeer( + SOCKET Socket, + const struct sockaddr *PeerAddress, + ULONG peerAddressLen +); + +WINSOCK_API_LINKAGE int WSAAPI WSAQuerySocketSecurity( + SOCKET Socket, + const SOCKET_SECURITY_QUERY_TEMPLATE *SecurityQueryTemplate, + ULONG SecurityQueryTemplateLen, + SOCKET_SECURITY_QUERY_INFO *SecurityQueryInfo, + ULONG *SecurityQueryInfoLen, + LPWSAOVERLAPPED Overlapped, + LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine +); + +WINSOCK_API_LINKAGE int WSAAPI WSARevertImpersonation(void); + +WINSOCK_API_LINKAGE int WSAAPI WSASetSocketPeerTargetName( + SOCKET Socket, + const SOCKET_PEER_TARGET_NAME *PeerTargetName, + ULONG PeerTargetNameLen, + LPWSAOVERLAPPED Overlapped, + LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine +); + +WINSOCK_API_LINKAGE int WSAAPI WSASetSocketSecurity( + SOCKET Socket, + const SOCKET_SECURITY_SETTINGS *SecuritySettings, + ULONG SecuritySettingsLen, + LPWSAOVERLAPPED Overlapped, + LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine +); + +#endif /*(_WIN32_WINNT >= 0x0600)*/ + +#ifdef __cplusplus +} +#endif + +#endif /* _WS2TCPIP_H_ */