From 1756811b9923dcfef575a79e0ff6a45664520773 Mon Sep 17 00:00:00 2001 From: Mumit Khan Date: Tue, 29 Feb 2000 03:14:40 +0000 Subject: [PATCH] 2000-02-28 Mumit Khan Patches from Jan Nijtmans : * include/wtypes.h (PBLOB, LPBLOB): Define. * include/winsock2.h: Much more complete version. (FD_SET, SOMAXCONN): Protect common macros defined by winsock.h. --- winsup/w32api/ChangeLog | 5 + winsup/w32api/include/winsock2.h | 605 ++++++++++++++++++++++++++++--- winsup/w32api/include/wtypes.h | 2 +- 3 files changed, 556 insertions(+), 56 deletions(-) diff --git a/winsup/w32api/ChangeLog b/winsup/w32api/ChangeLog index ea8cf766f..c0a4cbbb1 100644 --- a/winsup/w32api/ChangeLog +++ b/winsup/w32api/ChangeLog @@ -1,5 +1,10 @@ 2000-02-28 Mumit Khan + Patches from Jan Nijtmans : + * include/wtypes.h (PBLOB, LPBLOB): Define. + * include/winsock2.h: Much more complete version. + (FD_SET, SOMAXCONN): Protect common macros defined by winsock.h. + Patches from Jan Nijtmans : * include/winsock.h (FD_CLR): Add missing ')'. (timercmp): Fix macro to handle all 6 comparison operators. diff --git a/winsup/w32api/include/winsock2.h b/winsup/w32api/include/winsock2.h index ea748f0dc..180b43cb3 100644 --- a/winsup/w32api/include/winsock2.h +++ b/winsup/w32api/include/winsock2.h @@ -2,7 +2,7 @@ Definitions for winsock 2 - FIXME: This is mostly a stub for now. Taken from the Wine project. + Initially taken from the Wine project. Portions Copyright (c) 1980, 1983, 1988, 1993 The Regents of the University of California. All rights reserved. @@ -12,54 +12,333 @@ #ifndef _WINSOCK2_H #define _WINSOCK2_H -#define _GNU_H_WINDOWS32_SOCKETS + +/* Macros that are also defined in winsock.h, and need to be overridden. + These will go away once we have a completely standalone winsock2.h. */ +#ifdef FD_SET +#define _FD_SET_DEFINED +#endif +#include + +#ifndef _NSPAPI_H +#include +#endif +#ifndef _WTYPES_H +#include +#endif + #ifdef __cplusplus extern "C" { #endif -#include +#define ADDR_ANY INADDR_ANY + +#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 FROM_PROTOCOL_INFO (-1) + +#define SO_DONTLINGER (u_int)(~SO_LINGER) +#define SO_GROUP_ID 0x2001 +#define SO_GROUP_PRIORITY 0x2002 +/* FIXME/TODO: need this because we also include winsock.h. */ +#undef SOMAXCONN +#define SOMAXCONN 0x7fffffff +#define SO_MAX_MSG_SIZE 0x2003 +#define SO_PROTOCOL_INFOA 0x2004 +#define SO_PROTOCOL_INFOW 0x2005 +#ifdef UNICODE +#define SO_PROTOCOL_INFO SO_PROTOCOL_INFOW +#else +#define SO_PROTOCOL_INFO SO_PROTOCOL_INFOA +#endif +#define PVD_CONFIG 0x3001 + +#define FD_READ_BIT 0 +#define FD_WRITE_BIT 1 +#define FD_OOB_BIT 2 +#define FD_ACCEPT_BIT 3 +#define FD_CONNECT_BIT 4 +#define FD_CLOSE_BIT 5 +#define FD_QOS_BIT 6 +#define FD_GROUP_QOS_BIT 7 +#define FD_MAX_EVENTS 8 +#define FD_ALL_EVENTS (255) + +#if !defined(_FD_SET_DEFINED) +#undef FD_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) +#else +#undef _FD_SET_DEFINED +#endif + +#define MSG_INTERRUPT 0x10 +#define MSG_MAXIOVLEN 16 + +#define WSAEDISCON (WSABASEERR+101) +#define WSAENOMORE (WSABASEERR+102) +#define WSAECANCELLED (WSABASEERR+103) +#define WSAEINVALIDPROCTABLE (WSABASEERR+104) +#define WSAEINVALIDPROVIDER (WSABASEERR+105) +#define WSAEPROVIDERFAILEDINIT (WSABASEERR+106) +#define WSASYSCALLFAILURE (WSABASEERR+107) +#define WSASERVICE_NOT_FOUND (WSABASEERR+108) +#define WSATYPE_NOT_FOUND (WSABASEERR+109) +#define WSA_E_NO_MORE (WSABASEERR+110) +#define WSA_E_CANCELLED (WSABASEERR+111) +#define WSAEREFUSED (WSABASEERR+112) + +#define WSAAPI WINAPI +#define WSAEVENT HANDLE +#define LPWSAEVENT LPHANDLE +#define WSAOVERLAPPED OVERLAPPED +typedef struct _OVERLAPPED *LPWSAOVERLAPPED; -#define FD_MAX_EVENTS 10 -#define FD_READ_BIT 0 -#define FD_WRITE_BIT 1 -#define FD_OOB_BIT 2 -#define FD_ACCEPT_BIT 3 -#define FD_CONNECT_BIT 4 -#define FD_CLOSE_BIT 5 -#define FROM_PROTOCOL_INFO -1 -#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 MAX_PROTOCOL_CHAIN 7 -#define BASE_PROTOCOL 1 -#define LAYERED_PROTOCOL 0 -#define WSAPROTOCOL_LEN 255 -#define WSA_FLAG_OVERLAPPED 0x01 -#define WSA_FLAG_MULTIPOINT_C_ROOT 0x02 -#define WSA_FLAG_MULTIPOINT_C_LEAF 0x04 -#define WSA_FLAG_MULTIPOINT_D_ROOT 0x08 -#define WSA_FLAG_MULTIPOINT_D_LEAF 0x10 -typedef HANDLE WSAEVENT; -typedef unsigned int GROUP; -#ifndef GUID_DEFINED -#define GUID_DEFINED -typedef struct _GUID { - unsigned long Data1; - unsigned short Data2; - unsigned short Data3; - unsigned char Data4[8]; -} GUID,*REFGUID,*LPGUID; -#endif /* GUID_DEFINED */ +#define WSA_IO_PENDING (ERROR_IO_PENDING) +#define WSA_IO_INCOMPLETE (ERROR_IO_INCOMPLETE) +#define WSA_INVALID_HANDLE (ERROR_INVALID_HANDLE) +#define WSA_INVALID_PARAMETER (ERROR_INVALID_PARAMETER) +#define WSA_NOT_ENOUGH_MEMORY (ERROR_NOT_ENOUGH_MEMORY) +#define WSA_OPERATION_ABORTED (ERROR_OPERATION_ABORTED) + +#define WSA_INVALID_EVENT ((WSAEVENT)NULL) +#define WSA_MAXIMUM_WAIT_EVENTS (MAXIMUM_WAIT_OBJECTS) +#define WSA_WAIT_FAILED ((DWORD)-1L) +#define WSA_WAIT_EVENT_0 (WAIT_OBJECT_0) +#define WSA_WAIT_IO_COMPLETION (WAIT_IO_COMPLETION) +#define WSA_WAIT_TIMEOUT (WAIT_TIMEOUT) +#define WSA_INFINITE (INFINITE) + +typedef struct _WSABUF { + unsigned long len; + char *buf; +} WSABUF, *LPWSABUF; + +typedef enum +{ + BestEffortService, + ControlledLoadService, + PredictiveService, + GuaranteedDelayService, + GuaranteedService +} GUARANTEE; + +typedef long int32; + +typedef struct _flowspec +{ + int32 TokenRate; + int32 TokenBucketSize; + int32 PeakBandwidth; + int32 Latency; + int32 DelayVariation; + GUARANTEE LevelOfGuarantee; + int32 CostOfCall; + int32 NetworkAvailability; +} FLOWSPEC, *LPFLOWSPEC; + +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]; + long lNetworkEvents; + int iErrorCode[FD_MAX_EVENTS]; } WSANETWORKEVENTS, *LPWSANETWORKEVENTS; + +#define MAX_PROTOCOL_CHAIN 7 + +#define BASE_PROTOCOL 1 +#define LAYERED_PROTOCOL 0 + +typedef enum _WSAESETSERVICEOP +{ + RNRSERVICE_REGISTER=0, + RNRSERVICE_DEREGISTER, + RNRSERVICE_DELETE +} WSAESETSERVICEOP, *PWSAESETSERVICEOP, *LPWSAESETSERVICEOP; + +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; + +#ifdef UNICODE +typedef WSAQUERYSETW WSAQUERYSET; +typedef PWSAQUERYSETW PWSAQUERYSET; +typedef LPWSAQUERYSETW LPWSAQUERYSET; +#else +typedef WSAQUERYSETA WSAQUERYSET; +typedef PWSAQUERYSETA PWSAQUERYSET; +typedef LPWSAQUERYSETA LPWSAQUERYSET; +#endif + +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; + +#ifdef UNICODE +typedef WSANSCLASSINFOW WSANSCLASSINFO; +typedef PWSANSCLASSINFOW PWSANSCLASSINFO; +typedef LPWSANSCLASSINFOW LPWSANSCLASSINFO; +#else +typedef WSANSCLASSINFOA WSANSCLASSINFO; +typedef PWSANSCLASSINFOA PWSANSCLASSINFO; +typedef LPWSANSCLASSINFOA LPWSANSCLASSINFO; +#endif + +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; + +#ifdef UNICODE +typedef WSASERVICECLASSINFOW WSASERVICECLASSINFO; +typedef PWSASERVICECLASSINFOW PWSASERVICECLASSINFO; +typedef LPWSASERVICECLASSINFOW LPWSASERVICECLASSINFO; +#else +typedef WSASERVICECLASSINFOA WSASERVICECLASSINFO; +typedef PWSASERVICECLASSINFOA PWSASERVICECLASSINFO; +typedef LPWSASERVICECLASSINFOA LPWSASERVICECLASSINFO; +#endif + +typedef struct _WSANAMESPACE_INFOA { + GUID NSProviderId; + DWORD dwNameSpace; + BOOL fActive; + DWORD dwVersion; + LPSTR lpszIdentifier; +} WSANAMESPACE_INFOA, *PWSANAMESPACE_INFOA, *LPWSANAMESPACE_INFOA; + +typedef struct _WSANAMESPACE_INFOW { + GUID NSProviderId; + DWORD dwNameSpace; + BOOL fActive; + DWORD dwVersion; + LPWSTR lpszIdentifier; +} WSANAMESPACE_INFOW, *PWSANAMESPACE_INFOW, *LPWSANAMESPACE_INFOW; + +#ifdef UNICODE +typedef WSANAMESPACE_INFOW WSANAMESPACE_INFO; +typedef PWSANAMESPACE_INFOW PWSANAMESPACE_INFO; +typedef LPWSANAMESPACE_INFOW LPWSANAMESPACE_INFO; +#else +typedef WSANAMESPACE_INFOA WSANAMESPACE_INFO; +typedef PWSANAMESPACE_INFOA PWSANAMESPACE_INFO; +typedef LPWSANAMESPACE_INFOA LPWSANAMESPACE_INFO; +#endif + typedef struct _WSAPROTOCOLCHAIN { int ChainLen; DWORD ChainEntries[MAX_PROTOCOL_CHAIN]; -} WSAPROTOCOLCHAIN,*LPWSAPROTOCOLCHAIN; +} WSAPROTOCOLCHAIN, *LPWSAPROTOCOLCHAIN; + +#define WSAPROTOCOL_LEN 255 + typedef struct _WSAPROTOCOL_INFOA { DWORD dwServiceFlags1; DWORD dwServiceFlags2; @@ -80,8 +359,9 @@ typedef struct _WSAPROTOCOL_INFOA { int iSecurityScheme; DWORD dwMessageSize; DWORD dwProviderReserved; - CHAR szProtocol[WSAPROTOCOL_LEN+1]; -} WSAPROTOCOL_INFOA,*LPWSAPROTOCOL_INFOA; + CHAR szProtocol[WSAPROTOCOL_LEN+1]; +} WSAPROTOCOL_INFOA, *LPWSAPROTOCOL_INFOA; + typedef struct _WSAPROTOCOL_INFOW { DWORD dwServiceFlags1; DWORD dwServiceFlags2; @@ -103,27 +383,242 @@ typedef struct _WSAPROTOCOL_INFOW { DWORD dwMessageSize; DWORD dwProviderReserved; WCHAR szProtocol[WSAPROTOCOL_LEN+1]; -} WSAPROTOCOL_INFOW,*LPWSAPROTOCOL_INFOW; -SOCKET PASCAL WSASocketA(int,int,int,LPWSAPROTOCOL_INFOA,GROUP,DWORD); -SOCKET PASCAL WSASocketW(int,int,int,LPWSAPROTOCOL_INFOW,GROUP,DWORD); -#define WSACreateEvent() CreateEvent(NULL, TRUE, FALSE, NULL) -int PASCAL WSAEnumNetworkEvents(SOCKET s, WSAEVENT hEventObject, LPWSANETWORKEVENTS lpNetworkEvents); -int PASCAL WSAEventSelect(SOCKET s, WSAEVENT hEventObject, long lNetworkEvents); +} WSAPROTOCOL_INFOW, * LPWSAPROTOCOL_INFOW; + +typedef int (CALLBACK *LPCONDITIONPROC)(LPWSABUF, LPWSABUF, LPQOS, LPQOS, LPWSABUF, LPWSABUF, GROUP *, DWORD); +typedef void (WINAPI *LPWSAOVERLAPPED_COMPLETION_ROUTINE)(DWORD, DWORD, LPWSAOVERLAPPED, DWORD); + #ifdef UNICODE -#define SO_PROTOCOL_INFO SO_PROTOCOL_INFOW -#define WSAPROTOCOL_INFO WSAPROTOCOL_INFOW -#define LPWSAPROTOCOL_INFO LPWSAPROTOCOL_INFOW +typedef WSAPROTOCOL_INFOW WSAPROTOCOL_INFO; +typedef LPWSAPROTOCOL_INFOW LPWSAPROTOCOL_INFO; +#else +typedef WSAPROTOCOL_INFOA WSAPROTOCOL_INFO; +typedef LPWSAPROTOCOL_INFOA LPWSAPROTOCOL_INFO; +#endif + +#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 TH_NETDEV 0x00000001 +#define TH_TAPI 0x00000002 + +#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) + +SOCKET WINAPI WSAAccept(SOCKET, struct sockaddr *, LPINT, LPCONDITIONPROC, DWORD); +INT WINAPI WSAAddressToStringA(LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFOA, LPSTR, LPDWORD); +INT WINAPI WSAAddressToStringW(LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFOW, LPWSTR, LPDWORD); +BOOL WINAPI WSACloseEvent(WSAEVENT); +int WINAPI WSAConnect(SOCKET, const struct sockaddr *, int, LPWSABUF, LPWSABUF, LPQOS, LPQOS); +WSAEVENT WINAPI WSACreateEvent(void); +int WINAPI WSADuplicateSocketA(SOCKET, DWORD, LPWSAPROTOCOL_INFOA); +int WINAPI WSADuplicateSocketW(SOCKET, DWORD, LPWSAPROTOCOL_INFOW); +INT WINAPI WSAEnumNameSpaceProvidersA(LPDWORD, LPWSANAMESPACE_INFOA); +INT WINAPI WSAEnumNameSpaceProvidersW(LPDWORD, LPWSANAMESPACE_INFOW); +int WINAPI WSAEnumNetworkEvents(SOCKET, WSAEVENT, LPWSANETWORKEVENTS); +int WINAPI WSAEnumProtocolsA(LPINT, LPWSAPROTOCOL_INFOA, LPDWORD); +int WINAPI WSAEnumProtocolsW(LPINT, LPWSAPROTOCOL_INFOW, LPDWORD); +int WINAPI WSAEventSelect(SOCKET, WSAEVENT, long); +BOOL WINAPI WSAGetOverlappedResult(SOCKET, LPWSAOVERLAPPED, LPDWORD, BOOL, LPDWORD); +BOOL WINAPI WSAGetQOSByName(SOCKET, LPWSABUF, LPQOS); +INT WINAPI WSAGetServiceClassInfoA(LPGUID, LPGUID, LPDWORD, LPWSASERVICECLASSINFOA); +INT WINAPI WSAGetServiceClassInfoW(LPGUID, LPGUID, LPDWORD, LPWSASERVICECLASSINFOW); +INT WINAPI WSAGetServiceClassNameByClassIdA(LPGUID, LPSTR, LPDWORD); +INT WINAPI WSAGetServiceClassNameByClassIdW(LPGUID, LPWSTR, LPDWORD); +int WINAPI WSAHtonl(SOCKET, unsigned long, unsigned long *); +int WINAPI WSAHtons(SOCKET, unsigned short, unsigned short *); +INT WINAPI WSAInstallServiceClassA(LPWSASERVICECLASSINFOA); +INT WINAPI WSAInstallServiceClassW(LPWSASERVICECLASSINFOW); +int WINAPI WSAIoctl(SOCKET, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +SOCKET WINAPI WSAJoinLeaf(SOCKET, const struct sockaddr *, int, LPWSABUF, LPWSABUF, LPQOS, LPQOS, DWORD); +INT WINAPI WSALookupServiceBeginA(LPWSAQUERYSETA, DWORD, LPHANDLE); +INT WINAPI WSALookupServiceBeginW(LPWSAQUERYSETW lpqsRestrictions, DWORD, LPHANDLE); +INT WINAPI WSALookupServiceNextA(HANDLE, DWORD, LPDWORD, LPWSAQUERYSETA); +INT WINAPI WSALookupServiceNextW(HANDLE, DWORD, LPDWORD, LPWSAQUERYSETW); +INT WINAPI WSALookupServiceEnd(HANDLE); +int WINAPI WSANtohl(SOCKET, unsigned long, unsigned long *); +int WINAPI WSANtohs(SOCKET, unsigned short, unsigned short *); +int WINAPI WSARecv(SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +int WINAPI WSARecvDisconnect(SOCKET, LPWSABUF); +int WINAPI WSARecvFrom(SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, struct sockaddr *, LPINT, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +INT WINAPI WSARemoveServiceClass(LPGUID); +BOOL WINAPI WSAResetEvent(WSAEVENT); +int WINAPI WSASend(SOCKET, LPWSABUF, DWORD, LPDWORD, DWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +int WINAPI WSASendDisconnect(SOCKET, LPWSABUF); +int WINAPI WSASendTo(SOCKET, LPWSABUF, DWORD, LPDWORD, DWORD, const struct sockaddr *, int, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +BOOL WINAPI WSASetEvent(WSAEVENT); +INT WSAAPI WSASetServiceA(LPWSAQUERYSETA, WSAESETSERVICEOP, DWORD); +INT WINAPI WSASetServiceW(LPWSAQUERYSETW, WSAESETSERVICEOP, DWORD); +SOCKET WINAPI WSASocketA(int, int, int, LPWSAPROTOCOL_INFOA, GROUP, DWORD); +SOCKET WINAPI WSASocketW(int, int, int, LPWSAPROTOCOL_INFOW, GROUP, DWORD); +INT WINAPI WSAStringToAddressA(LPSTR, INT, LPWSAPROTOCOL_INFOA, LPSOCKADDR, LPINT); +INT WINAPI WSAStringToAddressW(LPWSTR, INT, LPWSAPROTOCOL_INFOW, LPSOCKADDR, LPINT); +DWORD WINAPI WSAWaitForMultipleEvents(DWORD, const WSAEVENT *, BOOL, DWORD, BOOL); + +typedef SOCKET (WINAPI *LPFN_WSAACCEPT)(SOCKET, struct sockaddr *, LPINT, LPCONDITIONPROC, DWORD); +typedef INT (WINAPI *LPFN_WSAADDRESSTOSTRINGA)(LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFOA, LPSTR, LPDWORD); +typedef INT (WINAPI *LPFN_WSAADDRESSTOSTRINGW)(LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFOW, LPWSTR, LPDWORD); +typedef BOOL (WINAPI *LPFN_WSACLOSEEVENT)(WSAEVENT); +typedef int (WINAPI *LPFN_WSACONNECT)(SOCKET, const struct sockaddr *, int, LPWSABUF, LPWSABUF, LPQOS, LPQOS); +typedef WSAEVENT (WINAPI *LPFN_WSACREATEEVENT)(void); +typedef int (WINAPI *LPFN_WSADUPLICATESOCKETA)(SOCKET, DWORD, LPWSAPROTOCOL_INFOA); +typedef int (WINAPI *LPFN_WSADUPLICATESOCKETW)(SOCKET, DWORD, LPWSAPROTOCOL_INFOW); +typedef INT (WINAPI *LPFN_WSAENUMNAMESPACEPROVIDERSA)(LPDWORD, LPWSANAMESPACE_INFOA); +typedef INT (WINAPI *LPFN_WSAENUMNAMESPACEPROVIDERSW)(LPDWORD, LPWSANAMESPACE_INFOW); +typedef int (WINAPI *LPFN_WSAENUMNETWORKEVENTS)(SOCKET, WSAEVENT, LPWSANETWORKEVENTS); +typedef int (WINAPI *LPFN_WSAENUMPROTOCOLSA)(LPINT, LPWSAPROTOCOL_INFOA, LPDWORD); +typedef int (WINAPI *LPFN_WSAENUMPROTOCOLSW)(LPINT, LPWSAPROTOCOL_INFOW, LPDWORD); +typedef int (WINAPI *LPFN_WSAEVENTSELECT)(SOCKET, WSAEVENT, long); +typedef BOOL (WINAPI *LPFN_WSAGETOVERLAPPEDRESULT)(SOCKET, LPWSAOVERLAPPED, LPDWORD, BOOL, LPDWORD); +typedef BOOL (WINAPI *LPFN_WSAGETQOSBYNAME)(SOCKET, LPWSABUF, LPQOS); +typedef INT (WINAPI *LPFN_WSAGETSERVICECLASSINFOA)(LPGUID, LPGUID, LPDWORD, LPWSASERVICECLASSINFOA); +typedef INT (WINAPI *LPFN_WSAGETSERVICECLASSINFOW)(LPGUID, LPGUID, LPDWORD, LPWSASERVICECLASSINFOW); +typedef INT (WINAPI *LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDA)(LPGUID, LPSTR, LPDWORD); +typedef INT (WINAPI *LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDW)(LPGUID, LPWSTR, LPDWORD); +typedef int (WINAPI *LPFN_WSAHTONL)(SOCKET, unsigned long, unsigned long *); +typedef int (WINAPI *LPFN_WSAHTONS)(SOCKET, unsigned short, unsigned short *); +typedef INT (WINAPI *LPFN_WSAINSTALLSERVICECLASSA)(LPWSASERVICECLASSINFOA); +typedef INT (WINAPI *LPFN_WSAINSTALLSERVICECLASSW)(LPWSASERVICECLASSINFOW); +typedef int (WINAPI *LPFN_WSAIOCTL)(SOCKET, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +typedef SOCKET (WINAPI *LPFN_WSAJOINLEAF)(SOCKET, const struct sockaddr *, int, LPWSABUF, LPWSABUF, LPQOS, LPQOS, DWORD); +typedef INT (WINAPI *LPFN_WSALOOKUPSERVICEBEGINA)(LPWSAQUERYSETA, DWORD, LPHANDLE); +typedef INT (WINAPI *LPFN_WSALOOKUPSERVICEBEGINW)(LPWSAQUERYSETW, DWORD, LPHANDLE); +typedef INT (WINAPI *LPFN_WSALOOKUPSERVICENEXTA)(HANDLE, DWORD, LPDWORD, LPWSAQUERYSETA); +typedef INT (WINAPI *LPFN_WSALOOKUPSERVICENEXTW)(HANDLE, DWORD, LPDWORD, LPWSAQUERYSETW); +typedef INT (WINAPI *LPFN_WSALOOKUPSERVICEEND)(HANDLE); +typedef int (WINAPI *LPFN_WSANTOHL)(SOCKET, unsigned long, unsigned long *); +typedef int (WINAPI *LPFN_WSANTOHS)(SOCKET, unsigned short, unsigned short *); +typedef int (WINAPI *LPFN_WSARECV)(SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +typedef int (WINAPI *LPFN_WSARECVDISCONNECT)(SOCKET, LPWSABUF); +typedef int (WINAPI *LPFN_WSARECVFROM)(SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, struct sockaddr *, LPINT, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +typedef INT (WINAPI *LPFN_WSAREMOVESERVICECLASS)(LPGUID); +typedef BOOL (WINAPI *LPFN_WSARESETEVENT)(WSAEVENT); +typedef int (WINAPI *LPFN_WSASEND)(SOCKET, LPWSABUF, DWORD, LPDWORD, DWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +typedef int (WINAPI *LPFN_WSASENDDISCONNECT)(SOCKET, LPWSABUF); +typedef int (WINAPI *LPFN_WSASENDTO)(SOCKET, LPWSABUF, DWORD, LPDWORD, DWORD, const struct sockaddr *, int, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); +typedef BOOL (WINAPI *LPFN_WSASETEVENT)(WSAEVENT); +typedef INT (WINAPI *LPFN_WSASETSERVICEA)(LPWSAQUERYSETA, WSAESETSERVICEOP, DWORD); +typedef INT (WINAPI *LPFN_WSASETSERVICEW)(LPWSAQUERYSETW, WSAESETSERVICEOP, DWORD); +typedef SOCKET (WINAPI *LPFN_WSASOCKETA)(int, int, int, LPWSAPROTOCOL_INFOA, GROUP, DWORD); +typedef SOCKET (WINAPI *LPFN_WSASOCKETW)(int, int, int, LPWSAPROTOCOL_INFOW, GROUP, DWORD); +typedef INT (WINAPI *LPFN_WSASTRINGTOADDRESSA)(LPSTR, INT, LPWSAPROTOCOL_INFOA, LPSOCKADDR, LPINT); +typedef INT (WINAPI *LPFN_WSASTRINGTOADDRESSW)(LPWSTR, INT, LPWSAPROTOCOL_INFOW, LPSOCKADDR, LPINT); +typedef DWORD (WINAPI *LPFN_WSAWAITFORMULTIPLEEVENTS)(DWORD, const WSAEVENT *, BOOL, DWORD, BOOL); + +#ifdef UNICODE +#define LPFN_WSAADDRESSTOSTRING LPFN_WSAADDRESSTOSTRINGW +#define LPFN_WSADUPLICATESOCKET LPFN_WSADUPLICATESOCKETW +#define LPFN_WSAENUMNAMESPACEPROVIDERS LPFN_WSAENUMNAMESPACEPROVIDERSW +#define LPFN_WSAENUMPROTOCOLS LPFN_WSAENUMPROTOCOLSW +#define LPFN_WSAGETSERVICECLASSINFO LPFN_WSAGETSERVICECLASSINFOW +#define LPFN_WSAGETSERVICECLASSNAMEBYCLASSID LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDW +#define LPFN_WSAINSTALLSERVICECLASS LPFN_WSAINSTALLSERVICECLASSW +#define LPFN_WSALOOKUPSERVICEBEGIN LPFN_WSALOOKUPSERVICEBEGINW +#define LPFN_WSALOOKUPSERVICENEXT LPFN_WSALOOKUPSERVICENEXTW +#define LPFN_WSASETSERVICE LPFN_WSASETSERVICEW +#define LPFN_WSASOCKET LPFN_WSASOCKETW +#define LPFN_WSASTRINGTOADDRESS LPFN_WSASTRINGTOADDRESSW +#define WSAAddressToString WSAAddressToStringW +#define WSADuplicateSocket WSADuplicateSocketW +#define WSAEnumNameSpaceProviders WSAEnumNameSpaceProvidersW +#define WSAEnumProtocols WSAEnumProtocolsW +#define WSAGetServiceClassInfo WSAGetServiceClassInfoW +#define WSAGetServiceClassNameByClassId WSAGetServiceClassNameByClassIdW +#define WSASetService WSASetServiceW #define WSASocket WSASocketW +#define WSAStringToAddress WSAStringToAddressW +#define WSALookupServiceBegin WSALookupServiceBeginW +#define WSALookupServiceNext WSALookupServiceNextW +#define WSAInstallServiceClass WSAInstallServiceClassW #else -#define SO_PROTOCOL_INFO SO_PROTOCOL_INFOA -#define WSAPROTOCOL_INFO WSAPROTOCOL_INFOA -#define LPWSAPROTOCOL_INFO LPWSAPROTOCOL_INFOA +#define LPFN_WSAADDRESSTOSTRING LPFN_WSAADDRESSTOSTRINGA +#define LPFN_WSADUPLICATESOCKET LPFN_WSADUPLICATESOCKETW +#define LPFN_WSAENUMNAMESPACEPROVIDERS LPFN_WSAENUMNAMESPACEPROVIDERSA +#define LPFN_WSAENUMPROTOCOLS LPFN_WSAENUMPROTOCOLSA +#define LPFN_WSAGETSERVICECLASSINFO LPFN_WSAGETSERVICECLASSINFOA +#define LPFN_WSAGETSERVICECLASSNAMEBYCLASSID LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDA +#define LPFN_WSAINSTALLSERVICECLASS LPFN_WSAINSTALLSERVICECLASSA +#define LPFN_WSALOOKUPSERVICEBEGIN LPFN_WSALOOKUPSERVICEBEGINA +#define LPFN_WSALOOKUPSERVICENEXT LPFN_WSALOOKUPSERVICENEXTA +#define LPFN_WSASETSERVICE LPFN_WSASETSERVICEA +#define LPFN_WSASOCKET LPFN_WSASOCKETA +#define LPFN_WSASTRINGTOADDRESS LPFN_WSASTRINGTOADDRESSA +#define WSAAddressToString WSAAddressToStringA +#define WSADuplicateSocket WSADuplicateSocketA +#define WSAEnumNameSpaceProviders WSAEnumNameSpaceProvidersA +#define WSAEnumProtocols WSAEnumProtocolsA +#define WSAGetServiceClassInfo WSAGetServiceClassInfoA +#define WSAGetServiceClassNameByClassId WSAGetServiceClassNameByClassIdA +#define WSAInstallServiceClass WSAInstallServiceClassA +#define WSALookupServiceBegin WSALookupServiceBeginA +#define WSALookupServiceNext WSALookupServiceNextA #define WSASocket WSASocketA -#endif /* UNICODE */ +#define WSAStringToAddress WSAStringToAddressA +#define WSASetService WSASetServiceA +#endif #ifdef __cplusplus } #endif #endif - diff --git a/winsup/w32api/include/wtypes.h b/winsup/w32api/include/wtypes.h index 2222f91af..930ea7aa7 100644 --- a/winsup/w32api/include/wtypes.h +++ b/winsup/w32api/include/wtypes.h @@ -14,7 +14,7 @@ extern "C" { typedef struct _BLOB { ULONG cbSize; BYTE *pBlobData; -} BLOB; +} BLOB,*PBLOB,*LPBLOB; typedef enum tagDVASPECT { DVASPECT_CONTENT=1, DVASPECT_THUMBNAIL=2, -- 2.43.5