Headers diff for wsock32.dll between 6.1.7600.16385-Windows_7.0 and 6.3.9600.17415-Windows_8.1 versions

nspapi.h (6.1.7600.16385-Windows_7.0)		nspapi.h (6.3.9600.17415-Windows_8.1)

skipping to change at line 30		skipping to change at line 30

You must include "basetyps.h" first. Some types should		You must include "basetyps.h" first. Some types should
use definitions from base files rather than redefine here.		use definitions from base files rather than redefine here.
Unfortunately, so such base file exists.		Unfortunately, so such base file exists.

--*/		--*/

#ifndef _NSPAPI_INCLUDED		#ifndef _NSPAPI_INCLUDED
#define _NSPAPI_INCLUDED		#define _NSPAPI_INCLUDED


		#include <winapifamily.h>

		#pragma region Desktop Family
		#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)

#ifdef __cplusplus		#ifdef __cplusplus
extern "C" {		extern "C" {
#endif /* __cplusplus */		#endif /* __cplusplus */

#ifndef _tagBLOB_DEFINED		#ifndef _tagBLOB_DEFINED
#define _tagBLOB_DEFINED		#define _tagBLOB_DEFINED
#define _BLOB_DEFINED		#define _BLOB_DEFINED
#define _LPBLOB_DEFINED		#define _LPBLOB_DEFINED
typedef struct _BLOB {		typedef struct _BLOB {
ULONG cbSize ;		ULONG cbSize ;

skipping to change at line 516		skipping to change at line 521
#endif // UNICODE		#endif // UNICODE

typedef DWORD (* LPFN_NSPAPI) (VOID ) ;		typedef DWORD (* LPFN_NSPAPI) (VOID ) ;

//		//
// Structures for using the service routines asynchronously.		// Structures for using the service routines asynchronously.
//		//
typedef		typedef
VOID		VOID
(*LPSERVICE_CALLBACK_PROC) (		(*LPSERVICE_CALLBACK_PROC) (

__in LPARAM lParam,		_In_ LPARAM lParam,
__in HANDLE hAsyncTaskHandle		_In_ HANDLE hAsyncTaskHandle
);		);

typedef struct _SERVICE_ASYNC_INFO {		typedef struct _SERVICE_ASYNC_INFO {
LPSERVICE_CALLBACK_PROC lpServiceCallbackProc;		LPSERVICE_CALLBACK_PROC lpServiceCallbackProc;
LPARAM lParam;		LPARAM lParam;
HANDLE hAsyncTaskHandle;		HANDLE hAsyncTaskHandle;
} SERVICE_ASYNC_INFO, PSERVICE_ASYNC_INFO, FAR LPSERVICE_ASYNC_INFO;		} SERVICE_ASYNC_INFO, PSERVICE_ASYNC_INFO, FAR LPSERVICE_ASYNC_INFO;

//		//
// Public NSP API prototypes.		// Public NSP API prototypes.
//		//
INT		INT
APIENTRY		APIENTRY
EnumProtocolsA (		EnumProtocolsA (

__in_opt LPINT lpiProtocols,		_In_opt_ LPINT lpiProtocols,
__out_bcount(*lpdwBufferLength) LPVOID lpProtocolBuffer,		_Out_writes_bytes_(*lpdwBufferLength) LPVOID lpProtocolBuffer,
__inout LPDWORD lpdwBufferLength		_Inout_ LPDWORD lpdwBufferLength
);		);
//		//
// Public NSP API prototypes.		// Public NSP API prototypes.
//		//
INT		INT
APIENTRY		APIENTRY
EnumProtocolsW (		EnumProtocolsW (

__in_opt LPINT lpiProtocols,		_In_opt_ LPINT lpiProtocols,
__out_bcount(*lpdwBufferLength) LPVOID lpProtocolBuffer,		_Out_writes_bytes_(*lpdwBufferLength) LPVOID lpProtocolBuffer,
__inout LPDWORD lpdwBufferLength		_Inout_ LPDWORD lpdwBufferLength
);		);
#ifdef UNICODE		#ifdef UNICODE
#define EnumProtocols EnumProtocolsW		#define EnumProtocols EnumProtocolsW
#else		#else
#define EnumProtocols EnumProtocolsA		#define EnumProtocols EnumProtocolsA
#endif // !UNICODE		#endif // !UNICODE

INT		INT
APIENTRY		APIENTRY
GetAddressByNameA (		GetAddressByNameA (

__in DWORD dwNameSpace,		_In_ DWORD dwNameSpace,
__in LPGUID lpServiceType,		_In_ LPGUID lpServiceType,
__in_opt LPSTR lpServiceName,		_In_opt_ LPSTR lpServiceName,
__in_opt LPINT lpiProtocols,		_In_opt_ LPINT lpiProtocols,
__in DWORD dwResolution,		_In_ DWORD dwResolution,
__in_opt LPSERVICE_ASYNC_INFO lpServiceAsyncInfo,		_In_opt_ LPSERVICE_ASYNC_INFO lpServiceAsyncInfo,
__out_bcount(*lpdwBufferLength) LPVOID lpCsaddrBuffer,		_Out_writes_bytes_(*lpdwBufferLength) LPVOID lpCsaddrBuffer
__inout LPDWORD lpdwBufferLength,		,
__inout_bcount_opt(*lpdwAliasBufferLength) LPSTR lpAliasBuffer,		_Inout_ LPDWORD lpdwBufferLength,
__inout LPDWORD lpdwAliasBufferLength		_Inout_updates_opt_(*lpdwAliasBufferLength) LPSTR lpAliasBuffer,
		_Inout_ LPDWORD lpdwAliasBufferLength
);		);
INT		INT
APIENTRY		APIENTRY
GetAddressByNameW (		GetAddressByNameW (

__in DWORD dwNameSpace,		_In_ DWORD dwNameSpace,
__in LPGUID lpServiceType,		_In_ LPGUID lpServiceType,
__in_opt LPWSTR lpServiceName,		_In_opt_ LPWSTR lpServiceName,
__in_opt LPINT lpiProtocols,		_In_opt_ LPINT lpiProtocols,
__in DWORD dwResolution,		_In_ DWORD dwResolution,
__in_opt LPSERVICE_ASYNC_INFO lpServiceAsyncInfo,		_In_opt_ LPSERVICE_ASYNC_INFO lpServiceAsyncInfo,
__out_bcount(*lpdwBufferLength) LPVOID lpCsaddrBuffer,		_Out_writes_bytes_(*lpdwBufferLength) LPVOID lpCsaddrBuffer
__inout LPDWORD lpdwBufferLength,		,
__inout_ecount_opt(*lpdwAliasBufferLength) LPWSTR lpAliasBuffer,		_Inout_ LPDWORD lpdwBufferLength,
__inout LPDWORD lpdwAliasBufferLength		_Inout_updates_opt_(*lpdwAliasBufferLength) LPWSTR lpAliasBuffer,
		_Inout_ LPDWORD lpdwAliasBufferLength
);		);
#ifdef UNICODE		#ifdef UNICODE
#define GetAddressByName GetAddressByNameW		#define GetAddressByName GetAddressByNameW
#else		#else
#define GetAddressByName GetAddressByNameA		#define GetAddressByName GetAddressByNameA
#endif // !UNICODE		#endif // !UNICODE

INT		INT
APIENTRY		APIENTRY
GetTypeByNameA (		GetTypeByNameA (

__in LPSTR lpServiceName,		_In_ LPSTR lpServiceName,
__inout LPGUID lpServiceType		_Inout_ LPGUID lpServiceType
);		);
INT		INT
APIENTRY		APIENTRY
GetTypeByNameW (		GetTypeByNameW (

__in LPWSTR lpServiceName,		_In_ LPWSTR lpServiceName,
__inout LPGUID lpServiceType		_Inout_ LPGUID lpServiceType
);		);
#ifdef UNICODE		#ifdef UNICODE
#define GetTypeByName GetTypeByNameW		#define GetTypeByName GetTypeByNameW
#else		#else
#define GetTypeByName GetTypeByNameA		#define GetTypeByName GetTypeByNameA
#endif // !UNICODE		#endif // !UNICODE

INT		INT
APIENTRY		APIENTRY
GetNameByTypeA (		GetNameByTypeA (

__in LPGUID lpServiceType,		_In_ LPGUID lpServiceType,
__out_bcount(dwNameLength) LPSTR lpServiceName,		_Out_writes_bytes_(dwNameLength) LPSTR lpServiceName,
__in DWORD dwNameLength		_In_ DWORD dwNameLength
);		);
INT		INT
APIENTRY		APIENTRY
GetNameByTypeW (		GetNameByTypeW (

__in LPGUID lpServiceType,		_In_ LPGUID lpServiceType,
__out_bcount(dwNameLength) LPWSTR lpServiceName,		_Out_writes_bytes_(dwNameLength) LPWSTR lpServiceName,
__in DWORD dwNameLength		_In_ DWORD dwNameLength
);		);
#ifdef UNICODE		#ifdef UNICODE
#define GetNameByType GetNameByTypeW		#define GetNameByType GetNameByTypeW
#else		#else
#define GetNameByType GetNameByTypeA		#define GetNameByType GetNameByTypeA
#endif // !UNICODE		#endif // !UNICODE

INT		INT
APIENTRY		APIENTRY
SetServiceA (		SetServiceA (

__in DWORD dwNameSpace,		_In_ DWORD dwNameSpace,
__in DWORD dwOperation,		_In_ DWORD dwOperation,
__in DWORD dwFlags,		_In_ DWORD dwFlags,
__in LPSERVICE_INFOA lpServiceInfo,		_In_ LPSERVICE_INFOA lpServiceInfo,
__in_opt LPSERVICE_ASYNC_INFO lpServiceAsyncInfo,		_In_opt_ LPSERVICE_ASYNC_INFO lpServiceAsyncInfo,
__out LPDWORD lpdwStatusFlags		_Out_ LPDWORD lpdwStatusFlags
);		);
INT		INT
APIENTRY		APIENTRY
SetServiceW (		SetServiceW (

__in DWORD dwNameSpace,		_In_ DWORD dwNameSpace,
__in DWORD dwOperation,		_In_ DWORD dwOperation,
__in DWORD dwFlags,		_In_ DWORD dwFlags,
__in LPSERVICE_INFOW lpServiceInfo,		_In_ LPSERVICE_INFOW lpServiceInfo,
__in_opt LPSERVICE_ASYNC_INFO lpServiceAsyncInfo,		_In_opt_ LPSERVICE_ASYNC_INFO lpServiceAsyncInfo,
__out LPDWORD lpdwStatusFlags		_Out_ LPDWORD lpdwStatusFlags
);		);
#ifdef UNICODE		#ifdef UNICODE
#define SetService SetServiceW		#define SetService SetServiceW
#else		#else
#define SetService SetServiceA		#define SetService SetServiceA
#endif // !UNICODE		#endif // !UNICODE

INT		INT
APIENTRY		APIENTRY
GetServiceA (		GetServiceA (

__in DWORD dwNameSpace,		_In_ DWORD dwNameSpace,
__in LPGUID lpGuid,		_In_ LPGUID lpGuid,
__in LPSTR lpServiceName,		_In_ LPSTR lpServiceName,
__in DWORD dwProperties,		_In_ DWORD dwProperties,
__out_bcount(*lpdwBufferSize) LPVOID lpBuffer,		_Out_writes_bytes_(*lpdwBufferSize) LPVOID lpBuffer,
__inout LPDWORD lpdwBufferSize,		_Inout_ LPDWORD lpdwBufferSize,
__in_opt LPSERVICE_ASYNC_INFO lpServiceAsyncInfo		_In_opt_ LPSERVICE_ASYNC_INFO lpServiceAsyncInfo
);		);
INT		INT
APIENTRY		APIENTRY
GetServiceW (		GetServiceW (

__in DWORD dwNameSpace,		_In_ DWORD dwNameSpace,
__in LPGUID lpGuid,		_In_ LPGUID lpGuid,
__in LPWSTR lpServiceName,		_In_ LPWSTR lpServiceName,
__in DWORD dwProperties,		_In_ DWORD dwProperties,
__out_bcount(*lpdwBufferSize) LPVOID lpBuffer,		_Out_writes_bytes_(*lpdwBufferSize) LPVOID lpBuffer,
__inout LPDWORD lpdwBufferSize,		_Inout_ LPDWORD lpdwBufferSize,
__in_opt LPSERVICE_ASYNC_INFO lpServiceAsyncInfo		_In_opt_ LPSERVICE_ASYNC_INFO lpServiceAsyncInfo
);		);
#ifdef UNICODE		#ifdef UNICODE
#define GetService GetServiceW		#define GetService GetServiceW
#else		#else
#define GetService GetServiceA		#define GetService GetServiceA
#endif // !UNICODE		#endif // !UNICODE

#ifdef __cplusplus		#ifdef __cplusplus
}		}
#endif /* __cplusplus */		#endif /* __cplusplus */


		#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
		#pragma endregion

#endif // _NSPAPI_INCLUDED		#endif // _NSPAPI_INCLUDED

End of changes. 15 change blocks.
64 lines changed or deleted		74 lines changed or added

winsock.h (6.1.7600.16385-Windows_7.0)		winsock.h (6.3.9600.17415-Windows_8.1)

//$TAG BIZDEV		#include <winapifamily.h>
// $IPCategory:
// $DealPointID: 118736
// $AgreementName: berkeley software distribution license
// $AgreementType: oss license
// $ExternalOrigin: regents of the university of california
//$ENDTAG

//$TAG ENGR
// $Owner: vadime
// $Module: published_inc
//
//$ENDTAG

/* WINSOCK.H--definitions to be used with the WINSOCK.DLL		/* WINSOCK.H--definitions to be used with the WINSOCK.DLL
* Copyright (c) Microsoft Corporation. All rights reserved.		* Copyright (c) Microsoft Corporation. All rights reserved.
*		*
* This header file corresponds to version 1.1 of the Windows Sockets specificat ion.		* This header file corresponds to version 1.1 of the Windows Sockets specificat ion.
*		*
* This file includes parts which are Copyright (c) 1982-1986 Regents		* This file includes parts which are Copyright (c) 1982-1986 Regents
* of the University of California. All rights reserved. The		* of the University of California. All rights reserved. The
* Berkeley Software License Agreement specifies the terms and		* Berkeley Software License Agreement specifies the terms and
* conditions for redistribution.		* conditions for redistribution.
*		*
*/		*/

#ifndef _WINSOCKAPI_		#ifndef _WINSOCKAPI_
#define _WINSOCKAPI_		#define _WINSOCKAPI_

#if _MSC_VER > 1000		#if _MSC_VER > 1000
#pragma once		#pragma once
#endif		#endif


		#pragma region Desktop Family
		#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)

/*		/*
* Pull in WINDOWS.H if necessary		* Pull in WINDOWS.H if necessary
*/		*/
#ifndef _INC_WINDOWS		#ifndef _INC_WINDOWS
#include <windows.h>		#include <windows.h>
#endif /* _INC_WINDOWS */		#endif /* _INC_WINDOWS */

/*		/*
* Basic system type definitions, taken from the BSD file sys/types.h.		* Basic system type definitions, taken from the BSD file sys/types.h.
*/		*/

skipping to change at line 738		skipping to change at line 729
#define EREMOTE WSAEREMOTE		#define EREMOTE WSAEREMOTE
#endif		#endif

/* Socket function prototypes */		/* Socket function prototypes */

#ifdef __cplusplus		#ifdef __cplusplus
extern "C" {		extern "C" {
#endif		#endif

SOCKET PASCAL FAR accept (		SOCKET PASCAL FAR accept (

__in SOCKET s,		_In_ SOCKET s,
__out_bcount_opt(addrlen) struct sockaddr FAR addr,		_Out_writes_bytes_opt_(addrlen) struct sockaddr FAR
__inout_opt int FAR *addrlen);		addr,
		_Inout_opt_ int FAR *addrlen);

int PASCAL FAR bind (		int PASCAL FAR bind (

__in SOCKET s,		_In_ SOCKET s,
__in_bcount(namelen) const struct sockaddr FAR *addr,		_In_reads_bytes_(namelen) const struct sockaddr FAR *addr,
__in int namelen);		_In_ int namelen);

int PASCAL FAR closesocket ( IN SOCKET s);		int PASCAL FAR closesocket ( IN SOCKET s);

int PASCAL FAR connect (		int PASCAL FAR connect (

__in SOCKET s,		_In_ SOCKET s,
__in_bcount(namelen) const struct sockaddr FAR *name,		_In_reads_bytes_(namelen) const struct sockaddr FAR *nam
__in int namelen);		e,
		_In_ int namelen);

int PASCAL FAR ioctlsocket (		int PASCAL FAR ioctlsocket (

__in SOCKET s,		_In_ SOCKET s,
__in long cmd,		_In_ long cmd,
__inout u_long FAR *argp);		_Inout_ u_long FAR *argp);

int PASCAL FAR getpeername (		int PASCAL FAR getpeername (

__in SOCKET s,		_In_ SOCKET s,
__out_bcount_part(namelen, namelen) struct sockadd		_Out_writes_bytes_to_(namelen, namelen) struct soc
r FAR *name,		kaddr FAR *name,
__inout int FAR * namelen);		_Inout_ int FAR * namelen);

int PASCAL FAR getsockname (		int PASCAL FAR getsockname (

__in SOCKET s,		_In_ SOCKET s,
__out_bcount_part(namelen, namelen) struct sockadd		_Out_writes_bytes_to_(namelen, namelen) struct soc
r FAR *name,		kaddr FAR *name,
__inout int FAR * namelen);		_Inout_ int FAR * namelen);

int PASCAL FAR getsockopt (		int PASCAL FAR getsockopt (

__in SOCKET s,		_In_ SOCKET s,
__in int level,		_In_ int level,
__in int optname,		_In_ int optname,
__out_bcount(optlen) char FAR optval,		_Out_writes_bytes_(optlen) char FAR optval,
__inout int FAR *optlen);		_Inout_ int FAR *optlen);


u_long PASCAL FAR htonl ( __in u_long hostlong);		u_long PASCAL FAR htonl ( _In_ u_long hostlong);


u_short PASCAL FAR htons (__in u_short hostshort);		u_short PASCAL FAR htons (_In_ u_short hostshort);


unsigned long PASCAL FAR inet_addr (__in const char FAR * cp);		unsigned long PASCAL FAR inet_addr (_In_z_ const char FAR * cp);


char FAR * PASCAL FAR inet_ntoa (__in struct in_addr in);		char FAR * PASCAL FAR inet_ntoa (_In_ struct in_addr in);

int PASCAL FAR listen (		int PASCAL FAR listen (

__in SOCKET s,		_In_ SOCKET s,
__in int backlog);		_In_ int backlog);


u_long PASCAL FAR ntohl (__in u_long netlong);		u_long PASCAL FAR ntohl (_In_ u_long netlong);


u_short PASCAL FAR ntohs (__in u_short netshort);		u_short PASCAL FAR ntohs (_In_ u_short netshort);

int PASCAL FAR recv (		int PASCAL FAR recv (

__in SOCKET s,		_In_ SOCKET s,
__out_bcount_part(len, return) __out_data_source(NETWORK) c		_Out_writes_bytes_to_(len, return) __out_data_source(NETWOR
har FAR * buf,		K) char FAR * buf,
__in int len,		_In_ int len,
__in int flags);		_In_ int flags);

int PASCAL FAR recvfrom (		int PASCAL FAR recvfrom (

__in SOCKET s,		_In_ SOCKET s,
__out_bcount_part(len, return) __out_data_source(NETWOR		_Out_writes_bytes_to_(len, return) __out_data_source(NE
K) char FAR * buf,		TWORK) char FAR * buf,
__in int len,		_In_ int len,
__in int flags,		_In_ int flags,
__out_bcount_opt(fromlen) struct sockaddr FAR from,		_Out_writes_bytes_to_opt_(fromlen, fromlen) struct so
__inout_opt int FAR * fromlen);		ckaddr FAR * from,
		_Inout_opt_ int FAR * fromlen);

int PASCAL FAR select (		int PASCAL FAR select (

__in int nfds,		_In_ int nfds,
__inout_opt fd_set FAR *readfds,		_Inout_opt_ fd_set FAR *readfds,
__inout_opt fd_set FAR *writefds,		_Inout_opt_ fd_set FAR *writefds,
__inout_opt fd_set FAR *exceptfds,		_Inout_opt_ fd_set FAR *exceptfds,
__in_opt const struct timeval FAR *timeout);		_In_opt_ const struct timeval FAR *timeout);

int PASCAL FAR send (		int PASCAL FAR send (

__in SOCKET s,		_In_ SOCKET s,
__in_bcount(len) const char FAR * buf,		_In_reads_bytes_(len) const char FAR * buf,
__in int len,		_In_ int len,
__in int flags);		_In_ int flags);

int PASCAL FAR sendto (		int PASCAL FAR sendto (

__in SOCKET s,		_In_ SOCKET s,
__in_bcount(len) const char FAR * buf,		_In_reads_bytes_(len) const char FAR * buf,
__in int len,		_In_ int len,
__in int flags,		_In_ int flags,
__in_bcount_opt(tolen) const struct sockaddr FAR *to,		_In_reads_bytes_opt_(tolen) const struct sockaddr FAR *to
__in int tolen);		,
		_In_ int tolen);

int PASCAL FAR setsockopt (		int PASCAL FAR setsockopt (

__in SOCKET s,		_In_ SOCKET s,
__in int level,		_In_ int level,
__in int optname,		_In_ int optname,
__in_bcount_opt(optlen) const char FAR * optval,		_In_reads_bytes_opt_(optlen) const char FAR * optval,
__in int optlen);		_In_ int optlen);

int PASCAL FAR shutdown (		int PASCAL FAR shutdown (

__in SOCKET s,		_In_ SOCKET s,
__in int how);		_In_ int how);

SOCKET PASCAL FAR socket (		SOCKET PASCAL FAR socket (

__in int af,		_In_ int af,
__in int type,		_In_ int type,
__in int protocol);		_In_ int protocol);

/* Database function prototypes */		/* Database function prototypes */

struct hostent FAR * PASCAL FAR gethostbyaddr(		struct hostent FAR * PASCAL FAR gethostbyaddr(

__in_bcount(len) const char FAR *		_In_reads_bytes_(len) const char F
addr,		AR * addr,
__in int len,		_In_ int len,
__in int type);		_In_ int type);


struct hostent FAR * PASCAL FAR gethostbyname(__in_z const char FAR * name);		struct hostent FAR * PASCAL FAR gethostbyname(_In_z_ const char FAR * name);

int PASCAL FAR gethostname (		int PASCAL FAR gethostname (

__out_bcount_part(namelen, return) char FAR * name,		_Out_writes_bytes_to_(namelen, return) char FAR * na
__in int namelen);		me,
		_In_ int namelen);

struct servent FAR * PASCAL FAR getservbyport(		struct servent FAR * PASCAL FAR getservbyport(

__in int port,		_In_ int port,
__in_z const char FAR * proto);		_In_z_ const char FAR * proto);

struct servent FAR * PASCAL FAR getservbyname(		struct servent FAR * PASCAL FAR getservbyname(

__in_z const char FAR * name,		_In_z_ const char FAR * name,
__in_z const char FAR * proto);		_In_z_ const char FAR * proto);


struct protoent FAR * PASCAL FAR getprotobynumber(__in int proto);		struct protoent FAR * PASCAL FAR getprotobynumber(_In_ int proto);


struct protoent FAR * PASCAL FAR getprotobyname(__in_z const char FAR * name);		struct protoent FAR * PASCAL FAR getprotobyname(_In_z_ const char FAR * name);

/* Microsoft Windows Extension function prototypes */		/* Microsoft Windows Extension function prototypes */

int PASCAL FAR WSAStartup(		int PASCAL FAR WSAStartup(

__in WORD wVersionRequired,		_In_ WORD wVersionRequired,
__out LPWSADATA lpWSAData);		_Out_ LPWSADATA lpWSAData);

int PASCAL FAR WSACleanup(void);		int PASCAL FAR WSACleanup(void);


void PASCAL FAR WSASetLastError(__in int iError);		void PASCAL FAR WSASetLastError(_In_ int iError);

int PASCAL FAR WSAGetLastError(void);		int PASCAL FAR WSAGetLastError(void);

BOOL PASCAL FAR WSAIsBlocking(void);		BOOL PASCAL FAR WSAIsBlocking(void);

int PASCAL FAR WSAUnhookBlockingHook(void);		int PASCAL FAR WSAUnhookBlockingHook(void);


FARPROC PASCAL FAR WSASetBlockingHook(__in FARPROC lpBlockFunc);		FARPROC PASCAL FAR WSASetBlockingHook(_In_ FARPROC lpBlockFunc);

int PASCAL FAR WSACancelBlockingCall(void);		int PASCAL FAR WSACancelBlockingCall(void);

HANDLE PASCAL FAR WSAAsyncGetServByName(		HANDLE PASCAL FAR WSAAsyncGetServByName(

__in HWND hWnd,		_In_ HWND hWnd,
__in u_int wMsg,		_In_ u_int wMsg,
__in const char FAR * name,		_In_z_ const char FAR * name,
__in const char FAR * proto,		_In_z_ const char FAR * proto,
__out_bcount(buflen) char FAR * buf,		_Out_writes_bytes_(buflen) char FAR * bu
__in int buflen);		f,
		_In_ int buflen);

HANDLE PASCAL FAR WSAAsyncGetServByPort(		HANDLE PASCAL FAR WSAAsyncGetServByPort(

__in HWND hWnd,		_In_ HWND hWnd,
__in u_int wMsg,		_In_ u_int wMsg,
__in int port,		_In_ int port,
__in const char FAR * proto,		_In_ const char FAR * proto,
__out_bcount(buflen) char FAR * buf,		_Out_writes_bytes_(buflen) char FAR * bu
__in int buflen);		f,
		_In_ int buflen);

HANDLE PASCAL FAR WSAAsyncGetProtoByName(		HANDLE PASCAL FAR WSAAsyncGetProtoByName(

__in HWND hWnd,		_In_ HWND hWnd,
__in u_int wMsg,		_In_ u_int wMsg,
__in const char FAR * name,		_In_z_ const char FAR * name,
__out_bcount(buflen) char FAR * buf,		_Out_writes_bytes_(buflen) char FAR * b
__in int buflen);		uf,
		_In_ int buflen);

HANDLE PASCAL FAR WSAAsyncGetProtoByNumber(		HANDLE PASCAL FAR WSAAsyncGetProtoByNumber(

__in HWND hWnd,		_In_ HWND hWnd,
__in u_int wMsg,		_In_ u_int wMsg,
__in int number,		_In_ int number,
__out_bcount(buflen) char FAR * buf,		_Out_writes_bytes_(buflen) char FAR *
__in int buflen);		buf,
		_In_ int buflen);

HANDLE PASCAL FAR WSAAsyncGetHostByName(		HANDLE PASCAL FAR WSAAsyncGetHostByName(

__in HWND hWnd,		_In_ HWND hWnd,
__in u_int wMsg,		_In_ u_int wMsg,
__in const char FAR * name,		_In_z_ const char FAR * name,
__out_bcount(buflen) char FAR * buf,		_Out_writes_bytes_(buflen) char FAR * bu
__in int buflen);		f,
		_In_ int buflen);

HANDLE PASCAL FAR WSAAsyncGetHostByAddr(		HANDLE PASCAL FAR WSAAsyncGetHostByAddr(

__in HWND hWnd,		_In_ HWND hWnd,
__in u_int wMsg,		_In_ u_int wMsg,
__in const char FAR * addr,		_In_ const char FAR * addr,
__in int len,		_In_ int len,
__in int type,		_In_ int type,
__out_bcount(buflen) char FAR * buf,		_Out_writes_bytes_(buflen) char FAR * bu
__in int buflen);		f,
		_In_ int buflen);


int PASCAL FAR WSACancelAsyncRequest(__in HANDLE hAsyncTaskHandle);		int PASCAL FAR WSACancelAsyncRequest(_In_ HANDLE hAsyncTaskHandle);

int PASCAL FAR WSAAsyncSelect(		int PASCAL FAR WSAAsyncSelect(

__in SOCKET s,		_In_ SOCKET s,
__in HWND hWnd,		_In_ HWND hWnd,
__in u_int wMsg,		_In_ u_int wMsg,
__in long lEvent);		_In_ long lEvent);

int PASCAL FAR WSARecvEx (		int PASCAL FAR WSARecvEx (

__in SOCKET s,		_In_ SOCKET s,
__out_bcount_part(len, return) __out_data_source(NETWO		_Out_writes_bytes_to_(len, return) __out_data_source(N
RK) char FAR * buf,		ETWORK) char FAR * buf,
__in int len,		_In_ int len,
__inout int FAR *flags);		_Inout_ int FAR *flags);

typedef struct _TRANSMIT_FILE_BUFFERS {		typedef struct _TRANSMIT_FILE_BUFFERS {
PVOID Head;		PVOID Head;
DWORD HeadLength;		DWORD HeadLength;
PVOID Tail;		PVOID Tail;
DWORD TailLength;		DWORD TailLength;
} TRANSMIT_FILE_BUFFERS, PTRANSMIT_FILE_BUFFERS, LPTRANSMIT_FILE_BUFFERS;		} TRANSMIT_FILE_BUFFERS, PTRANSMIT_FILE_BUFFERS, LPTRANSMIT_FILE_BUFFERS;

#define TF_DISCONNECT 0x01		#define TF_DISCONNECT 0x01
#define TF_REUSE_SOCKET 0x02		#define TF_REUSE_SOCKET 0x02
#define TF_WRITE_BEHIND 0x04		#define TF_WRITE_BEHIND 0x04

BOOL		BOOL
PASCAL FAR		PASCAL FAR
TransmitFile (		TransmitFile (

__in SOCKET hSocket,		_In_ SOCKET hSocket,
__in HANDLE hFile,		_In_ HANDLE hFile,
__in DWORD nNumberOfBytesToWrite,		_In_ DWORD nNumberOfBytesToWrite,
__in DWORD nNumberOfBytesPerSend,		_In_ DWORD nNumberOfBytesPerSend,
__inout_opt LPOVERLAPPED lpOverlapped,		_Inout_opt_ LPOVERLAPPED lpOverlapped,
__in_opt LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,		_In_opt_ LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
__in DWORD dwReserved		_In_ DWORD dwReserved
);		);

BOOL		BOOL
PASCAL FAR		PASCAL FAR
AcceptEx (		AcceptEx (

__in SOCKET sListenSocket,		_In_ SOCKET sListenSocket,
__in SOCKET sAcceptSocket,		_In_ SOCKET sAcceptSocket,
__out_bcount_part(dwReceiveDatalength+dwLocalAddressLength+dwRemoteAddressLe		_Out_writes_bytes_to_(dwReceiveDataLength+dwLocalAddressLength+dwRemoteAddre
ngth,		ssLength,
*lpdwBytesReceived) PVOID lpOutputBuffer,		*lpdwBytesReceived) PVOID lpOutputBuffer,

__in DWORD dwReceiveDataLength,		_In_ DWORD dwReceiveDataLength,
__in DWORD dwLocalAddressLength,		_In_ DWORD dwLocalAddressLength,
__in DWORD dwRemoteAddressLength,		_In_ DWORD dwRemoteAddressLength,
__out LPDWORD lpdwBytesReceived,		_Out_ LPDWORD lpdwBytesReceived,
__inout LPOVERLAPPED lpOverlapped		_Inout_ LPOVERLAPPED lpOverlapped
);		);

VOID		VOID
PASCAL FAR		PASCAL FAR
GetAcceptExSockaddrs (		GetAcceptExSockaddrs (

__in_bcount(dwReceiveDataLength+dwLocalAddressLength+dwRemoteAddressLength)		_In_reads_bytes_(dwReceiveDataLength+dwLocalAddressLength+dwRemoteAddressLen
PVOID lpOutputBuffer,		gth) PVOID lpOutputBuffer,
__in DWORD dwReceiveDataLength,		_In_ DWORD dwReceiveDataLength,
__in DWORD dwLocalAddressLength,		_In_ DWORD dwLocalAddressLength,
__in DWORD dwRemoteAddressLength,		_In_ DWORD dwRemoteAddressLength,
__deref_out_bcount(LocalSockaddrLength) struct sockaddr *LocalSockaddr,		_Outptr_result_bytebuffer_(LocalSockaddrLength) struct sockaddr *LocalSock
__out LPINT LocalSockaddrLength,		addr,
__deref_out_bcount(RemoteSockaddrLength) struct sockaddr *RemoteSockaddr,		_Out_ LPINT LocalSockaddrLength,
__out LPINT RemoteSockaddrLength		_Outptr_result_bytebuffer_(RemoteSockaddrLength) struct sockaddr *RemoteSo
		ckaddr,
		_Out_ LPINT RemoteSockaddrLength
);		);

#ifdef __cplusplus		#ifdef __cplusplus
}		}
#endif		#endif

/* Microsoft Windows Extended data types */		/* Microsoft Windows Extended data types */
typedef struct sockaddr SOCKADDR;		typedef struct sockaddr SOCKADDR;
typedef struct sockaddr *PSOCKADDR;		typedef struct sockaddr *PSOCKADDR;
typedef struct sockaddr FAR *LPSOCKADDR;		typedef struct sockaddr FAR *LPSOCKADDR;

skipping to change at line 1079		skipping to change at line 1070
* to a WSAAsyncSelect().		* to a WSAAsyncSelect().
*/		*/
#define WSAGETSELECTERROR(lParam) HIWORD(lParam)		#define WSAGETSELECTERROR(lParam) HIWORD(lParam)

#if(_WIN32_WINNT >= 0x0501)		#if(_WIN32_WINNT >= 0x0501)
#ifdef IPV6STRICT		#ifdef IPV6STRICT
#error WINSOCK2 required.		#error WINSOCK2 required.
#endif // IPV6STRICT		#endif // IPV6STRICT
#endif //(_WIN32_WINNT >= 0x0501)		#endif //(_WIN32_WINNT >= 0x0501)


		#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
		#pragma endregion

#endif /* _WINSOCKAPI_ */		#endif /* _WINSOCKAPI_ */

End of changes. 48 change blocks.
169 lines changed or deleted		176 lines changed or added

This html diff was produced by rfcdiff 1.41.