OSDN > 브라 우즈 소프트웨어 > Software Development > Code Generators > MinGW - Minimalist GNU for Windows > SCM > git > mingw-org-wsl > Commit

MinGW - Minimalist GNU for Windows
Fork
mingw-dist
build-aux
wtklite
pexports
website
mingw-get
mingw-org-wsl
mingw-pkgspecs
Donation

R/O
HTTP
SSH
HTTPS

mingw-org-wsl: Commit

The MinGW.OSDN Windows System Libraries. Formerly designated as "MinGW.org Windows System Libraries", this encapsulates the "mingwrt" C runtime library extensions, and the "w32api" 32-bit MS-Windows API libraries.

Please note that this project no longer owns the "MinGW.org" domain name; any software which may be distributed from that domain is NOT supported by this project.

Commit MetaInfo

Revision	411a15dacafc564d2620284f0393e1879488761e (tree)
Time	2017-11-25 02:04:18
Author	Keith Marshall <keith@user...>
Commiter	Keith Marshall

Log Message

Make <winsock.h> and <winsock2.h> duplicate code congruent.

Change Summary

modified: w32api/ChangeLog (diff)
modified: w32api/include/winsock.h (diff)
modified: w32api/include/winsock2.h (diff)
modified: w32api/include/ws2spi.h (diff)

Incremental Difference

--- a/w32api/ChangeLog

+++ b/w32api/ChangeLog

		@@ -1,3 +1,30 @@
	1	+2017-11-24 Keith Marshall <keith@users.osdn.me>
	2	+
	3	+ Make <winsock.h> and <winsock2.h> duplicate code congruent.
	4	+
	5	+ * include/winsock.h (SOMAXCONN): Move definition into...
	6	+ [!__INSIDE_MSYS__]: ...this guarded scope.
	7	+
	8	+ * include/winsock2.h: Rearrange as necessary.
	9	+ [_BEGIN_C_DECLS, _END_C_DECLS]: Keep them balanced.
	10	+ (_USE_SYS_TYPES_FD_SET): Define and use, as in <winsock.h>
	11	+ [!_WINSOCK_ANOMALOUS_TYPEDEFS] (FD_SET): Declare function, not type.
	12	+ [!_WINSOCK_ANOMALOUS_TYPEDEFS] (PFD_SET, LPFD_SET): Suppress typedefs.
	13	+ (FD_SET, FD_ISSET, FD_CLR, FD_ZERO): Reimplement, as in <winsock.h>
	14	+ (FD_READ_BIT, FD_WRITE_BIT, FD_OOB_BIT, FD_ACCEPT_BIT)
	15	+ (FD_CONNECT_BIT, FD_CLOSE_BIT, FD_QOS_BIT, FD_GROUP_QOS_BIT)
	16	+ (FD_ROUTING_INTERFACE_CHANGE_BIT, FD_ADDRESS_LIST_CHANGE_BIT)
	17	+ (FD_MAX_EVENTS): Enumerate them, as in <winsock.h>
	18	+ [!(defined __INSIDE_CYGWIN__ \|\| defined __INSIDE_MSYS__)]: Recast...
	19	+ [!defined __INSIDE_MSYS__]: ...as this, throughout.
	20	+ (gethostname): Update function prototype, adding...
	21	+ (WINSOCK_API_LINKAGE): ...this DLL import control attribute.
	22	+
	23	+ * include/ws2spi.h: Tidy layout; assert copyright.
	24	+ [_BEGIN_C_DECLS, _END_C_DECLS]: Use them, as appropriate.
	25	+ (LPFD_SET): Delete all type references; use...
	26	+ (fd_set *): ...this instead.
	27	+
1	28	2017-11-14 Keith Marshall <keith@users.osdn.me>
2	29
3	30	Establish default selection for WinSock API declaration.

--- a/w32api/include/winsock.h

+++ b/w32api/include/winsock.h

		@@ -496,20 +496,10 @@ struct sockproto
496	496
497	497	#define SOL_SOCKET 0xFFFF
498	498
499		-#ifndef _WINSOCK2_H
500		-/* FIXME: Is this behaviour correct?
501		- * Historically, <winsock.h> defined SOMAXCONN unconditionally, with a
502		- * value of 5. However, <winsock2.h> defines it, using a significantly
503		- * different value, only when compiling native Windows code, and doesn't
504		- * define it at all, when compiling for Cygwin or MSYS. To accommodate
505		- * this difference in philosophy, we must now suppress this definition
506		- * in <winsock.h>, when <winsock.h> has been included by <winsock2.h>
507		- */
508		-#define SOMAXCONN 5
509		-#endif /* !_WINSOCK2_H */
510		-
511	499	#ifndef __INSIDE_MSYS__
512	500
	501	+#define SOMAXCONN 5
	502	+
513	503	#define MSG_OOB 1
514	504	#define MSG_PEEK 2
515	505	#define MSG_DONTROUTE 4

--- a/w32api/include/winsock2.h

+++ b/w32api/include/winsock2.h

		@@ -39,6 +39,7 @@
39	39	*
40	40	*/
41	41	#if !(defined _WINSOCK2_H \|\| defined _WINSOCK_H)
	42	+#pragma GCC system_header
42	43	#define _WINSOCK2_H
43	44
44	45	/* WinSock v2 deprecates several features, which are standard

		@@ -49,7 +50,6 @@
49	50	#define __WINSOCK2_DEPRECATED __MINGW_ATTRIB_DEPRECATED
50	51
51	52	#define _WINSOCK_H /* to prevent later inclusion of winsock.h */
52		-#pragma GCC system_header
53	53
54	54	#define _GNU_H_WINDOWS32_SOCKETS
55	55	#define __WINSOCK_H_SOURCED__ 1

		@@ -59,8 +59,6 @@
59	59	#include <sys/bsdtypes.h>
60	60	#include <sys/time.h>
61	61
62		-#undef __WINSOCK_H_SOURCED__
63		-
64	62	#ifndef WINSOCK_API_LINKAGE
65	63	#ifdef __W32API_USE_DLLIMPORT__
66	64	#define WINSOCK_API_LINKAGE DECLSPEC_IMPORT

		@@ -69,6 +67,17 @@
69	67	#endif
70	68	#endif
71	69
	70	+#if ! defined _USE_SYS_TYPES_FD_SET && defined USE_SYS_TYPES_FD_SET
	71	+/* Originally defined by the deprecated name, USE_SYS_TYPES_FD_SET, users
	72	+ * may specify this to suppress warnings, in the event that (incompatible)
	73	+ * fd_set manipulation macros may have been inherited from <sys/types.h>;
	74	+ * accommodate use of the deprecated feature test name.
	75	+ */
	76	+#warning "Feature test macro USE_SYS_TYPES_FD_SET is deprecated."
	77	+#warning "Use the _USE_SYS_TYPES_FD_SET feature test macro instead."
	78	+#define _USE_SYS_TYPES_FD_SET 1
	79	+#endif
	80	+
72	81	_BEGIN_C_DECLS
73	82
74	83	/* Names common to Winsock1.1 and Winsock2

		@@ -95,61 +104,87 @@ struct fd_set
95	104	SOCKET fd_array[FD_SETSIZE];
96	105	} fd_set;
97	106
98		-int PASCAL __WSAFDIsSet (SOCKET, fd_set *);
	107	+#ifndef FD_ISSET
	108	+int FD_ISSET (SOCKET, fd_set *);
	109	+#define FD_ISSET( __fd, __set ) __FD_ISSET ((__fd), (__set))
99	110
100		-#ifndef FD_CLR
101		-#define FD_CLR( fd, set ) do \
102		- { u_int __i; \
103		- for (__i = 0; __i < ((fd_set *)(set))->fd_count ; __i++) \
104		- { if (((fd_set *)(set))->fd_array[__i] == (fd)) \
105		- { while (__i < ((fd_set *)(set))->fd_count-1) \
106		- { ((fd_set *)(set))->fd_array[__i] \
107		- = ((fd_set *)(set))->fd_array[__i + 1]; __i++; \
108		- } \
109		- ((fd_set *)(set))->fd_count--; \
110		- break; \
111		- } \
112		- } \
113		- } while (0)
114		-#endif /* ! defined FD_CLR */
	111	+/* Microsoft provide this library function equivalent of the FD_ISSET
	112	+ * macro, and erroneously claim that it is neccessary to implement the
	113	+ * macro. We could just as easily implement it entirely inline...
	114	+ */
	115	+int PASCAL __WSAFDIsSet (SOCKET, fd_set *);
	116	+/* ...but, given the availability of the library function, we may just
	117	+ * as well use it.
	118	+ */
	119	+__CRT_ALIAS int __FD_ISSET( SOCKET __fd, fd_set *__set )
	120	+{ return __WSAFDIsSet (__fd, __set); }
	121	+#endif /* ! defined FD_ISSET */
115	122
116	123	#ifndef FD_SET
117		-/* FIXME: this differs from the original definition in <winsock.h>, and also
118		- * from the corresponding definition in Cygwin's <sys/types.h>, (which isn't
119		- * compatible with the WinSock fd_set type); which is correct?
	124	+#if !_WINSOCK_ANOMALOUS_TYPEDEFS
	125	+/* WinSock is intended to mimic the Berkeley Sockets API, for which
	126	+ * POSIX.1 provides a reference specification; this states that FD_SET
	127	+ * may be implemented as either a macro, or as a function. The reference
	128	+ * <winsock.h> implementation at http://www.sockets.com/winsock.htm#WinsockH
	129	+ * includes a typedef for FD_SET, which a) conflicts with the latter POSIX.1
	130	+ * provision, and b) creates potential confusion with the former. Thus, we
	131	+ * prefer to conform with POSIX.1 functional semantics, and recommend that
	132	+ * users avoid the potentially confusing FD_SET typedefs, so allowing us
	133	+ * to provide this function prototype:
	134	+ */
	135	+void FD_SET (SOCKET, fd_set *);
	136	+
	137	+#else /* _WINSOCK_ANOMALOUS_TYPEDEFS */
	138	+/* However, for users who insist on eschewing standard C/C++ syntax, and
	139	+ * for whatever reason must use FD_SET as a data type, instead of correctly
	140	+ * referring to fd_set, or for pointer references, use PFD_SET or LPFD_SET
	141	+ * instead of standard fd_set * references, we make these anomalous types
	142	+ * visible, when the _WINSOCK_ANOMALOUS_TYPEDEFS feature test macro is
	143	+ * defined with a non-zero value.
120	144	*/
121		-#define FD_SET( fd, set ) do \
122		- { u_int __i; \
123		- for (__i = 0; __i < ((fd_set *)(set))->fd_count ; __i++) \
124		- if (((fd_set *)(set))->fd_array[__i] == (fd)) break; \
125		- if (__i == ((fd_set *)(set))->fd_count) \
126		- { if (((fd_set *)(set))->fd_count < FD_SETSIZE) \
127		- { ((fd_set *)(set))->fd_array[__i] = (fd); \
128		- ((fd_set *)(set))->fd_count++; \
129		- } \
130		- } \
131		- } while (0)
	145	+#warning "FD_SET, PFD_SET, and LPFD_SET data types are non-portable."
	146	+#warning "Use portable fd_set, and fd_set * type references instead."
	147	+
	148	+typedef struct fd_set FD_SET, PFD_SET, LPFD_SET;
	149	+#endif
	150	+#define FD_SET( __fd, __set ) __FD_SET ((__fd), (__set))
	151	+__CRT_ALIAS void __FD_SET (SOCKET __fd, fd_set *__set)
	152	+{ if( (__set->fd_count < FD_SETSIZE) && ! FD_ISSET (__fd, __set) )
	153	+ __set->fd_array[__set->fd_count++] = __fd;
	154	+}
132	155	#endif /* ! defined FD_SET */
133	156
	157	+#ifndef FD_CLR
	158	+void FD_CLR (SOCKET, fd_set *);
	159	+#define FD_CLR( __fd, __set ) __FD_CLR ((__fd), (__set))
	160	+__CRT_ALIAS void __FD_CLR (SOCKET __fd, fd_set *__set)
	161	+{ u_int __m, __n; for (__m = __n = 0; __n < __set->fd_count; __n++)
	162	+ { if (__fd != __set->fd_array[__n])
	163	+ { if (__m < __n) __set->fd_array[__m] = __set->fd_array[__n];
	164	+ ++__m;
	165	+ }
	166	+ } __set->fd_count = __m;
	167	+}
	168	+#endif /* ! defined FD_CLR */
	169	+
134	170	#ifndef FD_ZERO
135		-#define FD_ZERO( set ) (((fd_set *)(set))->fd_count = 0)
	171	+void FD_ZERO (fd_set *);
	172	+#define FD_ZERO( __set ) __FD_ZERO (__set)
	173	+__CRT_ALIAS void __FD_ZERO (fd_set *__set)
	174	+{ __set->fd_count = 0; }
136	175	#endif /* ! defined FD_ZERO */
137	176
138		-#ifndef FD_ISSET
139		-#define FD_ISSET( fd, set ) __WSAFDIsSet((SOCKET)(fd), (fd_set *)(set))
140		-#endif /* ! defined FD_ISSET */
141		-
142		-#elif ! defined USE_SYS_TYPES_FD_SET
	177	+#elif ! defined _USE_SYS_TYPES_FD_SET
143	178	/* Definitions from <sys/types.h> probably aren't what the user wants;
144	179	* if they know what they are doing, and they are sure that this really
145		- * is what they want, then they may enable the USE_SYS_TYPES_FD_SET
	180	+ * is what they want, then they may enable the _USE_SYS_TYPES_FD_SET
146	181	* feature test macro, to suppress this warning.
147	182	*/
148	183	#warning "fd_set and associated macros have been defined in <sys/types.h>"
149	184	#warning "Your <sys/types.h> may cause runtime problems with W32 sockets."
150	185	#endif /* !_SYS_TYPES_FD_SET */
151	186
152		-#if ! (defined __INSIDE_CYGWIN__ \|\| defined __INSIDE_MSYS__)
	187	+#ifndef __INSIDE_MSYS__
153	188
154	189	struct hostent
155	190	{ char *h_name;

		@@ -165,7 +200,7 @@ struct linger
165	200	u_short l_linger;
166	201	};
167	202
168		-#endif /* ! (__INSIDE_CYGWIN__ \|\| __INSIDE_MSYS__) */
	203	+#endif /* !__INSIDE_MSYS__ */
169	204
170	205	#define IOCPARM_MASK 0x7F
171	206	#define IOC_VOID 0x20000000

		@@ -173,7 +208,7 @@ struct linger
173	208	#define IOC_IN 0x80000000
174	209	#define IOC_INOUT (IOC_IN \| IOC_OUT)
175	210
176		-#if ! (defined __INSIDE_CYGWIN__ \|\| defined __INSIDE_MSYS__)
	211	+#ifndef __INSIDE_MSYS__
177	212
178	213	#define _IO(x,y) (IOC_VOID\|((x)<<8)\|(y))
179	214	#define _IOR(x,y,t) (IOC_OUT\|(((long)sizeof(t)&IOCPARM_MASK)<<16)\|((x)<<8)\|(y))

		@@ -181,7 +216,7 @@ struct linger
181	216
182	217	#define FIONBIO _IOW('f', 126, u_long)
183	218
184		-#endif /* ! (__INSIDE_CYGWIN__ \|\| __INSIDE_MSYS__) */
	219	+#endif /* !__INSIDE_MSYS__ */
185	220
186	221	#define FIONREAD _IOR('f', 127, u_long)
187	222	#define FIOASYNC _IOW('f', 125, u_long)

		@@ -191,7 +226,7 @@ struct linger
191	226	#define SIOCGLOWAT _IOR('s', 3, u_long)
192	227	#define SIOCATMARK _IOR('s', 7, u_long)
193	228
194		-#if ! ( defined __INSIDE_CYGWIN__ \|\| defined __INSIDE_MSYS__)
	229	+#ifndef __INSIDE_MSYS__
195	230
196	231	struct netent
197	232	{ char *n_name;

		@@ -213,7 +248,7 @@ struct protoent
213	248	short p_proto;
214	249	};
215	250
216		-#endif /* ! (__INSIDE_CYGWIN__ \|\| __INSIDE_MSYS__) */
	251	+#endif /* !__INSIDE_MSYS__ */
217	252
218	253	#define IPPROTO_IP 0
219	254	#define IPPROTO_ICMP 1

		@@ -228,7 +263,8 @@ struct protoent
228	263	#define IPPROTO_RAW 255
229	264	#define IPPROTO_MAX 256
230	265
231		-/* IPv6 options */
	266	+/* IPv6 options: these are unsupported, prior to Winsock v2.
	267	+ */
232	268	#define IPPROTO_HOPOPTS 0 /* IPv6 Hop-by-Hop options */
233	269	#define IPPROTO_IPV6 41 /* IPv6 header */
234	270	#define IPPROTO_ROUTING 43 /* IPv6 Routing header */

		@@ -323,7 +359,7 @@ struct WSAData
323	359	char *lpVendorInfo;
324	360	} WSADATA, *LPWSADATA;
325	361
326		-#if ! (defined __INSIDE_CYGWIN__ \|\| defined __INSIDE_MSYS__)
	362	+#ifndef __INSIDE_MSYS__
327	363
328	364	#define IP_OPTIONS 1
329	365	#define SO_DEBUG 1

		@@ -348,7 +384,7 @@ struct WSAData
348	384	#define SO_ERROR 0x1007
349	385	#define SO_TYPE 0x1008
350	386
351		-#endif /* ! (__INSIDE_CYGWIN__ \|\| __INSIDE_MSYS__) */
	387	+#endif /* !__INSIDE_MSYS__ */
352	388
353	389	#define INVALID_SOCKET (SOCKET)(~0)
354	390	#define SOCKET_ERROR (-1)

		@@ -457,7 +493,7 @@ struct sockproto
457	493
458	494	#define SOL_SOCKET 0xFFFF
459	495
460		-#if ! (defined __INSIDE_CYGWIN__ \|\| defined __INSIDE_MSYS__)
	496	+#ifndef __INSIDE_MSYS__
461	497
462	498	#define SOMAXCONN 0x7FFFFFFF /* (5) in WinSock1.1 */
463	499

		@@ -465,42 +501,64 @@ struct sockproto
465	501	#define MSG_PEEK 2
466	502	#define MSG_DONTROUTE 4
467	503
468		-#endif /* ! (__INSIDE_CYGWIN__ \|\| __INSIDE_MSYS__) */
	504	+#endif /* !__INSIDE_MSYS__ */
469	505
470	506	#define MSG_MAXIOVLEN 16
471	507	#define MSG_PARTIAL 0x8000
472	508	#define MAXGETHOSTSTRUCT 1024
473	509
474		-#define FD_READ_BIT 0
475		-#define FD_READ (1 << FD_READ_BIT)
476		-#define FD_WRITE_BIT 1
477		-#define FD_WRITE (1 << FD_WRITE_BIT)
478		-#define FD_OOB_BIT 2
479		-#define FD_OOB (1 << FD_OOB_BIT)
480		-#define FD_ACCEPT_BIT 3
481		-#define FD_ACCEPT (1 << FD_ACCEPT_BIT)
482		-#define FD_CONNECT_BIT 4
483		-#define FD_CONNECT (1 << FD_CONNECT_BIT)
484		-#define FD_CLOSE_BIT 5
485		-#define FD_CLOSE (1 << FD_CLOSE_BIT)
486		-/* WinSock v1.1 defines no further events, beyond FD_CLOSE (32);
487		- * the following are specific to WinSock v2.
	510	+enum
	511	+{ /* Enumerate the flags used to represent the events which may be
	512	+ * detected on any socket, when monitored via an fd_set array.
	513	+ */
	514	+ FD_READ_BIT = 0,
	515	+# define FD_READ (1 << FD_READ_BIT)
	516	+
	517	+ FD_WRITE_BIT,
	518	+# define FD_WRITE (1 << FD_WRITE_BIT)
	519	+
	520	+ FD_OOB_BIT,
	521	+# define FD_OOB (1 << FD_OOB_BIT)
	522	+
	523	+ FD_ACCEPT_BIT,
	524	+# define FD_ACCEPT (1 << FD_ACCEPT_BIT)
	525	+
	526	+ FD_CONNECT_BIT,
	527	+# define FD_CONNECT (1 << FD_CONNECT_BIT)
	528	+
	529	+ FD_CLOSE_BIT,
	530	+# define FD_CLOSE (1 << FD_CLOSE_BIT)
	531	+
	532	+# ifdef _WINSOCK2_H
	533	+/* WinSock v1.1 defines no further events, beyond FD_CLOSE (1 << 5 = 32).
	534	+ * The following are specific to WinSock v2; for convenience, they may be
	535	+ * enumerated here, but they are exposed only when <winsock.h> is included
	536	+ * indirectly, by way of including <winsock2.h>
488	537	*/
489		-#define FD_QOS_BIT 6
490		-#define FD_QOS (1 << FD_QOS_BIT)
491		-#define FD_GROUP_QOS_BIT 7
492		-#define FD_GROUP_QOS (1 << FD_GROUP_QOS_BIT)
493		-#define FD_ROUTING_INTERFACE_CHANGE_BIT 8
494		-#define FD_ROUTING_INTERFACE_CHANGE (1 << FD_ROUTING_INTERFACE_CHANGE_BIT)
495		-#define FD_ADDRESS_LIST_CHANGE_BIT 9
496		-#define FD_ADDRESS_LIST_CHANGE (1 << FD_ADDRESS_LIST_CHANGE_BIT)
497		-
498		-#define FD_MAX_EVENTS 10
499		-#define FD_ALL_EVENTS ((1 << FD_MAX_EVENTS) - 1)
	538	+ FD_QOS_BIT,
	539	+# define FD_QOS (1 << FD_QOS_BIT)
	540	+
	541	+ FD_GROUP_QOS_BIT,
	542	+# define FD_GROUP_QOS (1 << FD_GROUP_QOS_BIT)
	543	+
	544	+ FD_ROUTING_INTERFACE_CHANGE_BIT,
	545	+# define FD_ROUTING_INTERFACE_CHANGE (1 << FD_ROUTING_INTERFACE_CHANGE_BIT)
	546	+
	547	+ FD_ADDRESS_LIST_CHANGE_BIT,
	548	+# define FD_ADDRESS_LIST_CHANGE (1 << FD_ADDRESS_LIST_CHANGE_BIT)
	549	+
	550	+# endif /* _WINSOCK2_H */
	551	+ /* Regardless of WinSock version, FD_MAX_EVENTS represents the first
	552	+ * unused flag bit, whence we may deduce FD_ALL_EVENTS, as a mask for
	553	+ * all supported event flags, specific to the WinSock version in use.
	554	+ */
	555	+ FD_MAX_EVENTS,
	556	+# define FD_ALL_EVENTS ((1 << FD_MAX_EVENTS) - 1)
	557	+};
500	558
501	559	#define WSANO_ADDRESS WSANO_DATA
502	560
503		-#if ! (defined __INSIDE_CYGWIN__ \|\| defined __INSIDE_MSYS__)
	561	+#ifndef __INSIDE_MSYS__
504	562
505	563	#define h_errno WSAGetLastError()
506	564	#define HOST_NOT_FOUND WSAHOST_NOT_FOUND

		@@ -509,7 +567,7 @@ struct sockproto
509	567	#define NO_DATA WSANO_DATA
510	568	#define NO_ADDRESS WSANO_ADDRESS
511	569
512		-#endif /* ! (__INSIDE_CYGWIN__ \|\| __INSIDE_MSYS__) */
	570	+#endif /* !__INSIDE_MSYS__ */
513	571
514	572	WINSOCK_API_LINKAGE SOCKET PASCAL accept (SOCKET, struct sockaddr , int );
515	573

		@@ -542,7 +600,6 @@ WINSOCK_API_LINKAGE DECLARE_STDCALL_P (struct servent *) getservbyname (const c
542	600	WINSOCK_API_LINKAGE DECLARE_STDCALL_P (struct protoent *) getprotobynumber (int);
543	601	WINSOCK_API_LINKAGE DECLARE_STDCALL_P (struct protoent ) getprotobyname (const char );
544	602
545		-
546	603	typedef SOCKET (PASCAL LPFN_ACCEPT) (SOCKET, struct sockaddr , int *);
547	604
548	605	typedef int (PASCAL LPFN_BIND) (SOCKET, const struct sockaddr , int);

		@@ -629,7 +686,7 @@ typedef HANDLE (PASCAL LPFN_WSAASYNCGETHOSTBYADDR) (HWND, u_int, const char, i
629	686	typedef int (PASCAL *LPFN_WSACANCELASYNCREQUEST) (HANDLE);
630	687	typedef int (PASCAL *LPFN_WSAASYNCSELECT) (SOCKET, HWND, u_int, long);
631	688
632		-#if ! (defined __INSIDE_CYGWIN__ \|\| defined __INSIDE_MSYS__)
	689	+#ifndef __INSIDE_MSYS__
633	690
634	691	WINSOCK_API_LINKAGE u_long PASCAL htonl (u_long);
635	692	WINSOCK_API_LINKAGE u_long PASCAL ntohl (u_long);

		@@ -637,9 +694,9 @@ WINSOCK_API_LINKAGE u_short PASCAL htons (u_short);
637	694	WINSOCK_API_LINKAGE u_short PASCAL ntohs (u_short);
638	695	WINSOCK_API_LINKAGE int PASCAL select (int nfds, fd_set , fd_set , fd_set , const struct timeval );
639	696
640		-#endif /* ! (__INSIDE_CYGWIN__ \|\| __INSIDE_MSYS__) */
	697	+#endif /* !__INSIDE_MSYS__ */
641	698
642		-int PASCAL gethostname (char *, int);
	699	+WINSOCK_API_LINKAGE int PASCAL gethostname (char *, int);
643	700
644	701	#define WSAMAKEASYNCREPLY(b,e) MAKELONG(b,e)
645	702	#define WSAMAKESELECTREPLY(e,error) MAKELONG(e,error)

		@@ -653,12 +710,16 @@ typedef struct sockaddr_storage SOCKADDR_STORAGE, *PSOCKADDR_STORAGE;
653	710	typedef struct sockaddr_in SOCKADDR_IN, PSOCKADDR_IN, LPSOCKADDR_IN;
654	711	typedef struct linger LINGER, PLINGER, LPLINGER;
655	712	typedef struct in_addr IN_ADDR, PIN_ADDR, LPIN_ADDR;
656		-typedef struct fd_set FD_SET, PFD_SET, LPFD_SET;
657	713	typedef struct hostent HOSTENT, PHOSTENT, LPHOSTENT;
658	714	typedef struct servent SERVENT, PSERVENT, LPSERVENT;
659	715	typedef struct protoent PROTOENT, PPROTOENT, LPPROTOENT;
660	716	typedef struct timeval TIMEVAL, PTIMEVAL, LPTIMEVAL;
661	717
	718	+_END_C_DECLS
	719	+
	720	+
	721	+#undef __WINSOCK_H_SOURCED__
	722	+
662	723	/* winsock2 additions */
663	724	#define __WINSOCK2_H_SOURCED__
664	725

		@@ -670,6 +731,8 @@ typedef struct timeval TIMEVAL, PTIMEVAL, LPTIMEVAL;
670	731	*/
671	732	#include "nspapi.h"
672	733
	734	+_BEGIN_C_DECLS
	735	+
673	736	#define ADDR_ANY INADDR_ANY
674	737
675	738	#define IN_CLASSD(i) (((long)(i) & 0xF0000000) == 0xE0000000)

--- a/w32api/include/ws2spi.h

+++ b/w32api/include/ws2spi.h

		@@ -1,202 +1,305 @@
1	1	/*
2	2	* ws2spi.h
3	3	*
4		- * Winsock 2 Service Provider Interface.
	4	+ * WinSock v2 Service Provider Interface.
5	5	*
	6	+ * $Id$
6	7	*
7		- * THIS SOFTWARE IS NOT COPYRIGHTED
	8	+ * Written by Casper S. Hornstrup <chorns@users.sourceforge.net>
	9	+ * Copyright (C) 2002-2004, 2006, 2017, MinGW.org Project
8	10	*
9		- * This source code is offered for use in the public domain. You may
10		- * use, modify or distribute it freely.
11	11	*
12		- * This code is distributed in the hope that it will be useful but
13		- * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
14		- * DISCLAIMED. This includes but is not limited to warranties of
15		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	12	+ * Permission is hereby granted, free of charge, to any person obtaining a
	13	+ * copy of this software and associated documentation files (the "Software"),
	14	+ * to deal in the Software without restriction, including without limitation
	15	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
	16	+ * and/or sell copies of the Software, and to permit persons to whom the
	17	+ * Software is furnished to do so, subject to the following conditions:
	18	+ *
	19	+ * The above copyright notice and this permission notice (including the next
	20	+ * paragraph) shall be included in all copies or substantial portions of the
	21	+ * Software.
	22	+ *
	23	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	24	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	25	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	26	+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	27	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	28	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	29	+ * DEALINGS IN THE SOFTWARE.
16	30	*
17	31	*/
18	32	#ifndef _WS2SPI_H
19		-#define _WS2SPI_H
20		-#if __GNUC__ >= 3
21	33	#pragma GCC system_header
22		-#endif
	34	+#define _WS2SPI_H
23	35
24	36	#include <winsock2.h>
25	37
26		-#ifdef __cplusplus
27		-extern "C" {
28		-#endif /* __cplusplus */
	38	+_BEGIN_C_DECLS
29	39
30		-#define WSPAPI WSAAPI
31		-#define WSPDESCRIPTION_LEN 255
	40	+#define WSPAPI WSAAPI
	41	+#define WSPDESCRIPTION_LEN 255
32	42
33	43	#ifndef RC_INVOKED
34	44
35		-typedef struct WSPData {
36		- WORD wVersion;
37		- WORD wHighVersion;
38		- WCHAR szDescription[WSPDESCRIPTION_LEN+1];
	45	+typedef
	46	+struct WSPData
	47	+{ WORD wVersion;
	48	+ WORD wHighVersion;
	49	+ WCHAR szDescription[WSPDESCRIPTION_LEN+1];
39	50	} WSPDATA, FAR *LPWSPDATA;
40		-typedef struct _WSATHREADID {
41		- HANDLE ThreadHandle;
42		- DWORD Reserved;
	51	+
	52	+typedef
	53	+struct _WSATHREADID
	54	+{ HANDLE ThreadHandle;
	55	+ DWORD Reserved;
43	56	} WSATHREADID, FAR *LPWSATHREADID;
44	57
45		-typedef BOOL (CALLBACK FAR *LPBLOCKINGCALLBACK)(DWORD);
46		-typedef VOID (CALLBACK FAR *LPWSAUSERAPC)(DWORD);
47		-
48		-/* Prototypes for service provider procedure table */
49		-typedef SOCKET (WSPAPI *LPWSPACCEPT)(SOCKET,LPSOCKADDR,LPINT,LPCONDITIONPROC,DWORD,LPINT);
50		-typedef INT (WSPAPI *LPWSPADDRESSTOSTRING)(LPSOCKADDR,DWORD,LPWSAPROTOCOL_INFOW,LPWSTR,LPDWORD,LPINT);
51		-typedef INT (WSPAPI *LPWSPASYNCSELECT)(SOCKET,HWND,UINT,LONG,LPINT);
52		-typedef INT (WSPAPI LPWSPBIND)(SOCKET,const struct sockaddr,INT,LPINT);
53		-typedef INT (WSPAPI *LPWSPCANCELBLOCKINGCALL)(LPINT);
54		-typedef INT (WSPAPI *LPWSPCLEANUP)(LPINT);
55		-typedef INT (WSPAPI *LPWSPCLOSESOCKET)(SOCKET,LPINT);
56		-typedef INT (WSPAPI LPWSPCONNECT)(SOCKET,const struct sockaddr,INT,LPWSABUF,LPWSABUF,LPQOS,LPQOS,LPINT);
57		-typedef INT (WSPAPI *LPWSPDUPLICATESOCKET)(SOCKET,DWORD,LPWSAPROTOCOL_INFOW,LPINT);
58		-typedef INT (WSPAPI *LPWSPENUMNETWORKEVENTS)(SOCKET,WSAEVENT,LPWSANETWORKEVENTS,LPINT);
59		-typedef INT (WSPAPI *LPWSPEVENTSELECT)(SOCKET,WSAEVENT,LONG,LPINT);
60		-typedef BOOL (WSPAPI *LPWSPGETOVERLAPPEDRESULT)(SOCKET,LPWSAOVERLAPPED,LPDWORD,BOOL,LPDWORD,LPINT);
61		-typedef INT (WSPAPI *LPWSPGETPEERNAME)(SOCKET,LPSOCKADDR,LPINT,LPINT);
62		-typedef BOOL (WSPAPI *LPWSPGETQOSBYNAME)(SOCKET,LPWSABUF,LPQOS,LPINT);
63		-typedef INT (WSPAPI *LPWSPGETSOCKNAME)(SOCKET,LPSOCKADDR,LPINT,LPINT);
64		-typedef INT (WSPAPI LPWSPGETSOCKOPT)(SOCKET,INT,INT,CHAR FAR,LPINT,LPINT);
65		-typedef INT (WSPAPI *LPWSPIOCTL)(SOCKET,DWORD,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,
66		- LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE,LPWSATHREADID,LPINT);
67		-typedef SOCKET (WSPAPI LPWSPJOINLEAF)(SOCKET,const struct sockaddr,INT,LPWSABUF,LPWSABUF,LPQOS,LPQOS,DWORD,LPINT);
68		-typedef INT (WSPAPI *LPWSPLISTEN)(SOCKET,INT,LPINT);
69		-typedef INT (WSPAPI *LPWSPRECV)(SOCKET,LPWSABUF,DWORD,LPDWORD,LPDWORD,
70		-LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE,LPWSATHREADID,LPINT);
71		-typedef INT (WSPAPI *LPWSPRECVDISCONNECT)(SOCKET,LPWSABUF,LPINT);
72		-typedef INT (WSPAPI *LPWSPRECVFROM)(SOCKET,LPWSABUF,DWORD,LPDWORD,LPDWORD,LPSOCKADDR,
73		-LPINT,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE,LPWSATHREADID,LPINT);
74		-typedef INT (WSPAPI LPWSPSELECT)(INT,LPFD_SET,LPFD_SET,LPFD_SET,CONST TIMEVAL,LPINT);
75		-typedef INT (WSPAPI *LPWSPSEND)(SOCKET,LPWSABUF,DWORD,LPDWORD,DWORD,
76		-LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE,LPWSATHREADID,LPINT);
77		-typedef INT (WSPAPI *LPWSPSENDDISCONNECT)(SOCKET,LPWSABUF,LPINT);
78		-typedef INT (WSPAPI LPWSPSENDTO)(SOCKET,LPWSABUF,DWORD,LPDWORD,DWORD,const struct sockaddr,
79		- INT,LPWSAOVERLAPPED,LPWSAOVERLAPPED_COMPLETION_ROUTINE,LPWSATHREADID,LPINT);
80		-typedef INT (WSPAPI LPWSPSETSOCKOPT)(SOCKET,INT,INT,CONST CHAR FAR,INT,LPINT);
81		-typedef INT (WSPAPI *LPWSPSHUTDOWN)(SOCKET,INT,LPINT);
82		-typedef SOCKET (WSPAPI *LPWSPSOCKET)(INT,INT,INT,LPWSAPROTOCOL_INFOW,GROUP,DWORD,LPINT);
83		-typedef INT (WSPAPI *LPWSPSTRINGTOADDRESS)(LPWSTR,INT,LPWSAPROTOCOL_INFOW,LPSOCKADDR,LPINT,LPINT);
84		-
85		-/* Service provider procedure table */
86		-typedef struct _WSPPROC_TABLE {
87		- LPWSPACCEPT lpWSPAccept;
88		- LPWSPADDRESSTOSTRING lpWSPAddressToString;
89		- LPWSPASYNCSELECT lpWSPAsyncSelect;
90		- LPWSPBIND lpWSPBind;
91		- LPWSPCANCELBLOCKINGCALL lpWSPCancelBlockingCall;
92		- LPWSPCLEANUP lpWSPCleanup;
93		- LPWSPCLOSESOCKET lpWSPCloseSocket;
94		- LPWSPCONNECT lpWSPConnect;
95		- LPWSPDUPLICATESOCKET lpWSPDuplicateSocket;
96		- LPWSPENUMNETWORKEVENTS lpWSPEnumNetworkEvents;
97		- LPWSPEVENTSELECT lpWSPEventSelect;
98		- LPWSPGETOVERLAPPEDRESULT lpWSPGetOverlappedResult;
99		- LPWSPGETPEERNAME lpWSPGetPeerName;
100		- LPWSPGETSOCKNAME lpWSPGetSockName;
101		- LPWSPGETSOCKOPT lpWSPGetSockOpt;
102		- LPWSPGETQOSBYNAME lpWSPGetQOSByName;
103		- LPWSPIOCTL lpWSPIoctl;
104		- LPWSPJOINLEAF lpWSPJoinLeaf;
105		- LPWSPLISTEN lpWSPListen;
106		- LPWSPRECV lpWSPRecv;
107		- LPWSPRECVDISCONNECT lpWSPRecvDisconnect;
108		- LPWSPRECVFROM lpWSPRecvFrom;
109		- LPWSPSELECT lpWSPSelect;
110		- LPWSPSEND lpWSPSend;
111		- LPWSPSENDDISCONNECT lpWSPSendDisconnect;
112		- LPWSPSENDTO lpWSPSendTo;
113		- LPWSPSETSOCKOPT lpWSPSetSockOpt;
114		- LPWSPSHUTDOWN lpWSPShutdown;
115		- LPWSPSOCKET lpWSPSocket;
116		- LPWSPSTRINGTOADDRESS lpWSPStringToAddress;
117		-} WSPPROC_TABLE, FAR* LPWSPPROC_TABLE;
118		-
119		-/* Prototypes for service provider upcall procedure table */
120		-typedef BOOL (WSPAPI *LPWPUCLOSEEVENT)(WSAEVENT,LPINT);
121		-typedef INT (WSPAPI *LPWPUCLOSESOCKETHANDLE)(SOCKET,LPINT);
122		-typedef INT (WSPAPI *LPWPUCLOSETHREAD)(LPWSATHREADID,LPINT);
123		-typedef WSAEVENT (WSPAPI *LPWPUCREATEEVENT)(LPINT);
124		-typedef SOCKET (WSPAPI *LPWPUCREATESOCKETHANDLE)(DWORD,DWORD,LPINT);
125		-typedef SOCKET (WSPAPI *LPWPUFDISSET)(SOCKET,LPFD_SET);
126		-typedef INT (WSPAPI *LPWPUGETPROVIDERPATH)(LPGUID,LPWSTR,LPINT,LPINT);
127		-typedef SOCKET (WSPAPI *LPWPUMODIFYIFSHANDLE)(DWORD,SOCKET,LPINT);
128		-typedef INT (WSPAPI *LPWPUOPENCURRENTTHREAD)(LPWSATHREADID,LPINT);
129		-typedef BOOL (WSPAPI *LPWPUPOSTMESSAGE)(HWND,UINT,WPARAM,LPARAM);
130		-typedef INT (WSPAPI LPWPUQUERYBLOCKINGCALLBACK)(DWORD,LPBLOCKINGCALLBACK FAR,LPDWORD,LPINT);
131		-typedef INT (WSPAPI *LPWPUQUERYSOCKETHANDLECONTEXT)(SOCKET,LPDWORD,LPINT);
132		-typedef INT (WSPAPI *LPWPUQUEUEAPC)(LPWSATHREADID,LPWSAUSERAPC,DWORD,LPINT);
133		-typedef BOOL (WSPAPI *LPWPURESETEVENT)(WSAEVENT,LPINT);
134		-typedef BOOL (WSPAPI *LPWPUSETEVENT)(WSAEVENT,LPINT);
135		-/* Available only directly from the DLL */
136		-typedef INT (WSPAPI *LPWPUCOMPLETEOVERLAPPEDREQUEST)(SOCKET,LPWSAOVERLAPPED,DWORD,DWORD,LPINT);
137		-
138		-/* Service Provider upcall table */
139		-typedef struct _WSPUPCALLTABLE {
140		- LPWPUCLOSEEVENT lpWPUCloseEvent;
141		- LPWPUCLOSESOCKETHANDLE lpWPUCloseSocketHandle;
142		- LPWPUCREATEEVENT lpWPUCreateEvent;
143		- LPWPUCREATESOCKETHANDLE lpWPUCreateSocketHandle;
144		- LPWPUFDISSET lpWPUFDIsSet;
145		- LPWPUGETPROVIDERPATH lpWPUGetProviderPath;
146		- LPWPUMODIFYIFSHANDLE lpWPUModifyIFSHandle;
147		- LPWPUPOSTMESSAGE lpWPUPostMessage;
148		- LPWPUQUERYBLOCKINGCALLBACK lpWPUQueryBlockingCallback;
149		- LPWPUQUERYSOCKETHANDLECONTEXT lpWPUQuerySocketHandleContext;
150		- LPWPUQUEUEAPC lpWPUQueueApc;
151		- LPWPURESETEVENT lpWPUResetEvent;
152		- LPWPUSETEVENT lpWPUSetEvent;
153		- LPWPUOPENCURRENTTHREAD lpWPUOpenCurrentThread;
154		- LPWPUCLOSETHREAD lpWPUCloseThread;
155		-} WSPUPCALLTABLE, FAR* LPWSPUPCALLTABLE;
156		-
157		-typedef INT (WSPAPI *LPWSPSTARTUP)(WORD,LPWSPDATA,LPWSAPROTOCOL_INFOW,WSPUPCALLTABLE,LPWSPPROC_TABLE);
158		-
159		-/* Prototypes for service provider namespace procedure table */
160		-typedef INT (WSPAPI *LPNSPCLEANUP)(LPGUID);
161		-typedef INT (WSPAPI *LPNSPGETSERVICECLASSINFO)(LPGUID,LPDWORD,LPWSASERVICECLASSINFOW);
162		-typedef INT (WSPAPI *LPNSPINSTALLSERVICECLASS)(LPGUID,LPWSASERVICECLASSINFOW);
163		-typedef INT (WSPAPI *LPNSPLOOKUPSERVICEBEGIN)(LPGUID,LPWSAQUERYSETW,LPWSASERVICECLASSINFOW,DWORD,LPHANDLE);
164		-typedef INT (WSPAPI *LPNSPLOOKUPSERVICEEND)(HANDLE);
165		-typedef INT (WSPAPI *LPNSPLOOKUPSERVICENEXT)(HANDLE,DWORD,LPDWORD,LPWSAQUERYSET);
166		-typedef INT (WSPAPI *LPNSPREMOVESERVICECLASS)(LPGUID,LPGUID);
167		-typedef INT (WSPAPI *LPNSPSETSERVICE)(LPGUID,LPWSASERVICECLASSINFOW,LPWSAQUERYSETW,WSAESETSERVICEOP,DWORD);
168		-
169		-typedef struct _NSP_ROUTINE {
170		- DWORD cbSize;
171		- DWORD dwMajorVersion;
172		- DWORD dwMinorVersion;
173		- LPNSPCLEANUP NSPCleanup;
174		- LPNSPLOOKUPSERVICEBEGIN NSPLookupServiceBegin;
175		- LPNSPLOOKUPSERVICENEXT NSPLookupServiceNext;
176		- LPNSPLOOKUPSERVICEEND NSPLookupServiceEnd;
177		- LPNSPSETSERVICE NSPSetService;
178		- LPNSPINSTALLSERVICECLASS NSPInstallServiceClass;
179		- LPNSPREMOVESERVICECLASS NSPRemoveServiceClass;
180		- LPNSPGETSERVICECLASSINFO NSPGetServiceClassInfo;
	58	+typedef BOOL (CALLBACK FAR *LPBLOCKINGCALLBACK) (DWORD);
	59	+typedef VOID (CALLBACK FAR *LPWSAUSERAPC) (DWORD);
	60	+
	61	+/* Prototypes for functions which may be invoked
	62	+ * via the Service Provider Procedure Table.
	63	+ */
	64	+typedef SOCKET (WSPAPI *LPWSPACCEPT)
	65	+ ( SOCKET, LPSOCKADDR, LPINT, LPCONDITIONPROC, DWORD, LPINT
	66	+ );
	67	+typedef INT (WSPAPI *LPWSPADDRESSTOSTRING)
	68	+ ( LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFOW, LPWSTR, LPDWORD, LPINT
	69	+ );
	70	+typedef INT (WSPAPI *LPWSPASYNCSELECT) (SOCKET, HWND, UINT, LONG, LPINT);
	71	+typedef INT (WSPAPI LPWSPBIND) (SOCKET, const struct sockaddr , INT, LPINT);
	72	+typedef INT (WSPAPI *LPWSPCANCELBLOCKINGCALL) (LPINT);
	73	+typedef INT (WSPAPI *LPWSPCLEANUP) (LPINT);
	74	+typedef INT (WSPAPI *LPWSPCLOSESOCKET) (SOCKET, LPINT);
	75	+
	76	+typedef INT (WSPAPI *LPWSPCONNECT)
	77	+ ( SOCKET, const struct sockaddr *, INT, LPWSABUF, LPWSABUF,
	78	+ LPQOS, LPQOS, LPINT
	79	+ );
	80	+typedef INT (WSPAPI *LPWSPDUPLICATESOCKET)
	81	+ ( SOCKET, DWORD, LPWSAPROTOCOL_INFOW, LPINT
	82	+ );
	83	+typedef INT (WSPAPI *LPWSPENUMNETWORKEVENTS)
	84	+ ( SOCKET, WSAEVENT, LPWSANETWORKEVENTS, LPINT
	85	+ );
	86	+typedef INT (WSPAPI *LPWSPEVENTSELECT) (SOCKET, WSAEVENT, LONG, LPINT);
	87	+
	88	+typedef BOOL (WSPAPI *LPWSPGETOVERLAPPEDRESULT)
	89	+ ( SOCKET, LPWSAOVERLAPPED, LPDWORD, BOOL, LPDWORD, LPINT
	90	+ );
	91	+typedef INT (WSPAPI *LPWSPGETPEERNAME) (SOCKET, LPSOCKADDR, LPINT, LPINT);
	92	+typedef BOOL (WSPAPI *LPWSPGETQOSBYNAME) (SOCKET, LPWSABUF, LPQOS, LPINT);
	93	+typedef INT (WSPAPI *LPWSPGETSOCKNAME) (SOCKET, LPSOCKADDR, LPINT, LPINT);
	94	+
	95	+typedef INT (WSPAPI *LPWSPGETSOCKOPT)
	96	+ ( SOCKET, INT, INT, CHAR FAR *, LPINT, LPINT
	97	+ );
	98	+typedef INT (WSPAPI *LPWSPIOCTL)
	99	+ ( SOCKET, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPWSAOVERLAPPED,
	100	+ LPWSAOVERLAPPED_COMPLETION_ROUTINE, LPWSATHREADID, LPINT
	101	+ );
	102	+typedef SOCKET (WSPAPI *LPWSPJOINLEAF)
	103	+ ( SOCKET, const struct sockaddr*, INT, LPWSABUF, LPWSABUF,
	104	+ LPQOS, LPQOS, DWORD, LPINT
	105	+ );
	106	+typedef INT (WSPAPI *LPWSPLISTEN) (SOCKET, INT, LPINT);
	107	+
	108	+typedef INT (WSPAPI *LPWSPRECV)
	109	+ ( SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, LPWSAOVERLAPPED,
	110	+ LPWSAOVERLAPPED_COMPLETION_ROUTINE, LPWSATHREADID, LPINT
	111	+ );
	112	+typedef INT (WSPAPI *LPWSPRECVDISCONNECT) (SOCKET, LPWSABUF, LPINT);
	113	+
	114	+typedef INT (WSPAPI *LPWSPRECVFROM)
	115	+ ( SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, LPSOCKADDR, LPINT,
	116	+ LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE, LPWSATHREADID,
	117	+ LPINT
	118	+ );
	119	+typedef INT (WSPAPI *LPWSPSELECT)
	120	+ ( INT, fd_set , fd_set , fd_set , CONST TIMEVAL , LPINT
	121	+ );
	122	+typedef INT (WSPAPI *LPWSPSEND)
	123	+ ( SOCKET, LPWSABUF, DWORD, LPDWORD, DWORD, LPWSAOVERLAPPED,
	124	+ LPWSAOVERLAPPED_COMPLETION_ROUTINE, LPWSATHREADID, LPINT
	125	+ );
	126	+typedef INT (WSPAPI *LPWSPSENDDISCONNECT) (SOCKET, LPWSABUF, LPINT);
	127	+
	128	+typedef INT (WSPAPI *LPWSPSENDTO)
	129	+ ( SOCKET, LPWSABUF, DWORD, LPDWORD, DWORD, const struct sockaddr *,
	130	+ INT, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE,
	131	+ LPWSATHREADID, LPINT
	132	+ );
	133	+typedef INT (WSPAPI *LPWSPSETSOCKOPT)
	134	+ ( SOCKET, INT, INT, CONST CHAR FAR *, INT, LPINT
	135	+ );
	136	+typedef INT (WSPAPI *LPWSPSHUTDOWN) (SOCKET, INT, LPINT);
	137	+
	138	+typedef SOCKET (WSPAPI *LPWSPSOCKET)
	139	+ ( INT, INT, INT, LPWSAPROTOCOL_INFOW, GROUP, DWORD, LPINT
	140	+ );
	141	+typedef INT (WSPAPI *LPWSPSTRINGTOADDRESS)
	142	+ ( LPWSTR, INT, LPWSAPROTOCOL_INFOW, LPSOCKADDR, LPINT, LPINT
	143	+ );
	144	+
	145	+typedef
	146	+struct _WSPPROC_TABLE
	147	+{ /* Service Provider Procedure Table
	148	+ */
	149	+ LPWSPACCEPT lpWSPAccept;
	150	+ LPWSPADDRESSTOSTRING lpWSPAddressToString;
	151	+ LPWSPASYNCSELECT lpWSPAsyncSelect;
	152	+ LPWSPBIND lpWSPBind;
	153	+ LPWSPCANCELBLOCKINGCALL lpWSPCancelBlockingCall;
	154	+ LPWSPCLEANUP lpWSPCleanup;
	155	+ LPWSPCLOSESOCKET lpWSPCloseSocket;
	156	+ LPWSPCONNECT lpWSPConnect;
	157	+ LPWSPDUPLICATESOCKET lpWSPDuplicateSocket;
	158	+ LPWSPENUMNETWORKEVENTS lpWSPEnumNetworkEvents;
	159	+ LPWSPEVENTSELECT lpWSPEventSelect;
	160	+ LPWSPGETOVERLAPPEDRESULT lpWSPGetOverlappedResult;
	161	+ LPWSPGETPEERNAME lpWSPGetPeerName;
	162	+ LPWSPGETSOCKNAME lpWSPGetSockName;
	163	+ LPWSPGETSOCKOPT lpWSPGetSockOpt;
	164	+ LPWSPGETQOSBYNAME lpWSPGetQOSByName;
	165	+ LPWSPIOCTL lpWSPIoctl;
	166	+ LPWSPJOINLEAF lpWSPJoinLeaf;
	167	+ LPWSPLISTEN lpWSPListen;
	168	+ LPWSPRECV lpWSPRecv;
	169	+ LPWSPRECVDISCONNECT lpWSPRecvDisconnect;
	170	+ LPWSPRECVFROM lpWSPRecvFrom;
	171	+ LPWSPSELECT lpWSPSelect;
	172	+ LPWSPSEND lpWSPSend;
	173	+ LPWSPSENDDISCONNECT lpWSPSendDisconnect;
	174	+ LPWSPSENDTO lpWSPSendTo;
	175	+ LPWSPSETSOCKOPT lpWSPSetSockOpt;
	176	+ LPWSPSHUTDOWN lpWSPShutdown;
	177	+ LPWSPSOCKET lpWSPSocket;
	178	+ LPWSPSTRINGTOADDRESS lpWSPStringToAddress;
	179	+} WSPPROC_TABLE, FAR *LPWSPPROC_TABLE;
	180	+
	181	+/* Prototypes for functions which may be invoked via
	182	+ * the Service Provider Upcall Procedure Table.
	183	+ */
	184	+typedef BOOL (WSPAPI *LPWPUCLOSEEVENT) (WSAEVENT, LPINT);
	185	+typedef INT (WSPAPI *LPWPUCLOSESOCKETHANDLE) (SOCKET, LPINT);
	186	+typedef INT (WSPAPI *LPWPUCLOSETHREAD) (LPWSATHREADID, LPINT);
	187	+typedef WSAEVENT (WSPAPI *LPWPUCREATEEVENT) (LPINT);
	188	+typedef SOCKET (WSPAPI *LPWPUCREATESOCKETHANDLE) (DWORD, DWORD, LPINT);
	189	+typedef SOCKET (WSPAPI LPWPUFDISSET) (SOCKET, fd_set );
	190	+typedef INT (WSPAPI *LPWPUGETPROVIDERPATH) (LPGUID, LPWSTR, LPINT, LPINT);
	191	+typedef SOCKET (WSPAPI *LPWPUMODIFYIFSHANDLE) (DWORD, SOCKET, LPINT);
	192	+typedef INT (WSPAPI *LPWPUOPENCURRENTTHREAD) (LPWSATHREADID, LPINT);
	193	+typedef BOOL (WSPAPI *LPWPUPOSTMESSAGE) (HWND, UINT, WPARAM, LPARAM);
	194	+
	195	+typedef INT (WSPAPI *LPWPUQUERYBLOCKINGCALLBACK)
	196	+ ( DWORD, LPBLOCKINGCALLBACK FAR *, LPDWORD, LPINT
	197	+ );
	198	+typedef INT (WSPAPI *LPWPUQUERYSOCKETHANDLECONTEXT) (SOCKET, LPDWORD, LPINT);
	199	+
	200	+typedef INT (WSPAPI *LPWPUQUEUEAPC)
	201	+ ( LPWSATHREADID, LPWSAUSERAPC, DWORD, LPINT
	202	+ );
	203	+typedef BOOL (WSPAPI *LPWPURESETEVENT) (WSAEVENT, LPINT);
	204	+typedef BOOL (WSPAPI *LPWPUSETEVENT) (WSAEVENT, LPINT);
	205	+
	206	+/* Functions matching the following prototype are available
	207	+ * only directly from the DLL
	208	+ */
	209	+typedef INT (WSPAPI *LPWPUCOMPLETEOVERLAPPEDREQUEST)
	210	+ ( SOCKET, LPWSAOVERLAPPED, DWORD, DWORD, LPINT
	211	+ );
	212	+
	213	+typedef
	214	+struct _WSPUPCALLTABLE
	215	+{ /* Service Provider Upcall Table
	216	+ */
	217	+ LPWPUCLOSEEVENT lpWPUCloseEvent;
	218	+ LPWPUCLOSESOCKETHANDLE lpWPUCloseSocketHandle;
	219	+ LPWPUCREATEEVENT lpWPUCreateEvent;
	220	+ LPWPUCREATESOCKETHANDLE lpWPUCreateSocketHandle;
	221	+ LPWPUFDISSET lpWPUFDIsSet;
	222	+ LPWPUGETPROVIDERPATH lpWPUGetProviderPath;
	223	+ LPWPUMODIFYIFSHANDLE lpWPUModifyIFSHandle;
	224	+ LPWPUPOSTMESSAGE lpWPUPostMessage;
	225	+ LPWPUQUERYBLOCKINGCALLBACK lpWPUQueryBlockingCallback;
	226	+ LPWPUQUERYSOCKETHANDLECONTEXT lpWPUQuerySocketHandleContext;
	227	+ LPWPUQUEUEAPC lpWPUQueueApc;
	228	+ LPWPURESETEVENT lpWPUResetEvent;
	229	+ LPWPUSETEVENT lpWPUSetEvent;
	230	+ LPWPUOPENCURRENTTHREAD lpWPUOpenCurrentThread;
	231	+ LPWPUCLOSETHREAD lpWPUCloseThread;
	232	+} WSPUPCALLTABLE, FAR *LPWSPUPCALLTABLE;
	233	+
	234	+typedef INT (WSPAPI *LPWSPSTARTUP)
	235	+ ( WORD, LPWSPDATA, LPWSAPROTOCOL_INFOW, WSPUPCALLTABLE, LPWSPPROC_TABLE
	236	+ );
	237	+
	238	+/* Prototypes for functions which may be invoked via
	239	+ * the Service Provider Namespace Procedure Table.
	240	+ */
	241	+typedef INT (WSPAPI *LPNSPCLEANUP) (LPGUID);
	242	+
	243	+typedef INT (WSPAPI *LPNSPGETSERVICECLASSINFO)
	244	+ ( LPGUID, LPDWORD, LPWSASERVICECLASSINFOW
	245	+ );
	246	+typedef INT (WSPAPI *LPNSPINSTALLSERVICECLASS)
	247	+ ( LPGUID, LPWSASERVICECLASSINFOW
	248	+ );
	249	+typedef INT (WSPAPI *LPNSPLOOKUPSERVICEBEGIN)
	250	+ ( LPGUID, LPWSAQUERYSETW, LPWSASERVICECLASSINFOW, DWORD, LPHANDLE
	251	+ );
	252	+typedef INT (WSPAPI *LPNSPLOOKUPSERVICEEND) (HANDLE);
	253	+typedef INT (WSPAPI *LPNSPLOOKUPSERVICENEXT)
	254	+ ( HANDLE, DWORD, LPDWORD, LPWSAQUERYSET
	255	+ );
	256	+typedef INT (WSPAPI *LPNSPREMOVESERVICECLASS) (LPGUID, LPGUID);
	257	+
	258	+typedef INT (WSPAPI *LPNSPSETSERVICE)
	259	+ ( LPGUID, LPWSASERVICECLASSINFOW, LPWSAQUERYSETW, WSAESETSERVICEOP, DWORD
	260	+ );
	261	+
	262	+typedef
	263	+struct _NSP_ROUTINE
	264	+{ /* Service Provider Namespace Procedure Table
	265	+ */
	266	+ DWORD cbSize;
	267	+ DWORD dwMajorVersion;
	268	+ DWORD dwMinorVersion;
	269	+ LPNSPCLEANUP NSPCleanup;
	270	+ LPNSPLOOKUPSERVICEBEGIN NSPLookupServiceBegin;
	271	+ LPNSPLOOKUPSERVICENEXT NSPLookupServiceNext;
	272	+ LPNSPLOOKUPSERVICEEND NSPLookupServiceEnd;
	273	+ LPNSPSETSERVICE NSPSetService;
	274	+ LPNSPINSTALLSERVICECLASS NSPInstallServiceClass;
	275	+ LPNSPREMOVESERVICECLASS NSPRemoveServiceClass;
	276	+ LPNSPGETSERVICECLASSINFO NSPGetServiceClassInfo;
181	277	} NSP_ROUTINE, PNSP_ROUTINE, LPNSP_ROUTINE;
182	278
183		-INT WSPAPI NSPStartup(LPGUID,LPNSP_ROUTINE);
184		-
185		-/* WinSock 2 DLL function prototypes */
186		-INT WSPAPI WPUCompleteOverlappedRequest(SOCKET,LPWSAOVERLAPPED,DWORD,DWORD,LPINT);
187		-INT WSPAPI WSPStartup(WORD,LPWSPDATA,LPWSAPROTOCOL_INFOW,WSPUPCALLTABLE,LPWSPPROC_TABLE);
188		-INT WSPAPI WSCDeinstallProvider(LPGUID,LPINT);
189		-INT WSPAPI WSCEnumProtocols(LPINT,LPWSAPROTOCOL_INFOW,LPDWORD,LPINT);
190		-INT WSPAPI WSCGetProviderPath(LPGUID,LPWSTR,LPINT,LPINT);
191		-INT WSPAPI WSCInstallProvider(CONST LPGUID,CONST LPWSTR,CONST LPWSAPROTOCOL_INFOW,DWORD,LPINT);
192		-INT WSPAPI WSCEnableNSProvider(LPGUID,BOOL);
193		-INT WSPAPI WSCInstallNameSpace(LPWSTR,LPWSTR,DWORD,DWORD,LPGUID);
194		-INT WSPAPI WSCUnInstallNameSpace(LPGUID);
195		-INT WSPAPI WSCWriteProviderOrder(LPDWORD,DWORD);
196		-
197		-#endif /* RC_INVOKED */
198		-
199		-#ifdef __cplusplus
200		-}
201		-#endif /* __cplusplus */
202		-#endif
	279	+INT WSPAPI NSPStartup (LPGUID, LPNSP_ROUTINE);
	280	+
	281	+/* WinSock v2 DLL function prototypes
	282	+ */
	283	+INT WSPAPI WPUCompleteOverlappedRequest
	284	+ ( SOCKET, LPWSAOVERLAPPED, DWORD, DWORD, LPINT
	285	+ );
	286	+INT WSPAPI WSPStartup
	287	+ ( WORD, LPWSPDATA, LPWSAPROTOCOL_INFOW, WSPUPCALLTABLE, LPWSPPROC_TABLE
	288	+ );
	289	+INT WSPAPI WSCDeinstallProvider (LPGUID, LPINT);
	290	+INT WSPAPI WSCEnumProtocols (LPINT, LPWSAPROTOCOL_INFOW, LPDWORD, LPINT);
	291	+INT WSPAPI WSCGetProviderPath (LPGUID, LPWSTR, LPINT, LPINT);
	292	+
	293	+INT WSPAPI WSCInstallProvider
	294	+ ( CONST LPGUID, CONST LPWSTR, CONST LPWSAPROTOCOL_INFOW, DWORD, LPINT
	295	+ );
	296	+INT WSPAPI WSCEnableNSProvider (LPGUID, BOOL);
	297	+INT WSPAPI WSCInstallNameSpace (LPWSTR, LPWSTR, DWORD, DWORD, LPGUID);
	298	+INT WSPAPI WSCUnInstallNameSpace (LPGUID);
	299	+INT WSPAPI WSCWriteProviderOrder (LPDWORD, DWORD);
	300	+
	301	+#endif /* ! RC_INVOKED */
	302	+
	303	+_END_C_DECLS
	304	+
	305	+#endif /* !_WS2SPI_H: $RCSfile$: end of file */

Show on old repository browser