1 /***********************************************************************\
2 *                              winsock2.d                               *
3 *                                                                       *
4 *                       Windows API header module                       *
5 *                                                                       *
6 *                 Translated from MinGW Windows headers                 *
7 *                             by Daniel Keep                            *
8 \***********************************************************************/
9 module windows.winsock2;
10 pragma(lib, "Ws2_32");
11 nothrow:
12 /*
13   Definitions for winsock 2
14 
15   Contributed by the WINE project.
16 
17   Portions Copyright (c) 1980, 1983, 1988, 1993
18   The Regents of the University of California.  All rights reserved.
19 
20   Portions Copyright (c) 1993 by Digital Equipment Corporation.
21  */
22 
23 /*	DRK: This module should not be included if -version=Win32_Winsock2 has
24  *	not been set.  If it has, assert.  I think it's better this way than
25  *	letting the user believe that it's worked.
26  *
27  *	SG: It has now been changed so that winsock2 is the default, and
28  *	-version=Win32_Winsock1 must be set to use winsock.
29  */
30 version(Win32_Winsock1) {
31 	pragma(msg, "Cannot use windows.winsock2 with Win32_Winsock1 defined.");
32 	static assert(false);
33 }
34 
35 import windows.winbase;
36 import windows.windef;
37 import windows.basetyps;
38 
39 alias char u_char;
40 alias ushort u_short;
41 alias uint u_int, u_long, SOCKET;
42 
43 const size_t FD_SETSIZE = 64;
44 
45 /* shutdown() how types */
46 enum : int {
47 	SD_RECEIVE,
48 	SD_SEND,
49 	SD_BOTH
50 }
51 
52 /* Good grief this is stupid... is it a struct?  A preprocessor macro?  A
53    struct tag?  Who the hell knows!? */
54 struct FD_SET {
55 	u_int               fd_count;
56 	SOCKET[FD_SETSIZE]  fd_array;
57 
58 	/* this differs from the define in winsock.h and in cygwin sys/types.h */
59 	static void opCall(SOCKET fd, FD_SET set) {
60 		u_int i;
61 		for (i = 0; i < set.fd_count; i++)
62 			if (set.fd_array[i] == fd)
63 				break;
64 		if (i == set.fd_count)
65 			if (set.fd_count < FD_SETSIZE) {
66 				set.fd_array[i] = fd;
67 				set.fd_count++;
68 			}
69 	}
70 }
71 alias FD_SET* PFD_SET, LPFD_SET;
72 
73 // Keep this alias, since fd_set isn't a tag name in the original header.
74 alias FD_SET fd_set;
75 
76 extern(Windows) int __WSAFDIsSet(SOCKET, FD_SET*);
77 alias __WSAFDIsSet FD_ISSET;
78 
79 void FD_CLR(SOCKET fd, FD_SET* set) {
80 	for (u_int i = 0; i < set.fd_count; i++) {
81 		if (set.fd_array[i] == fd) {
82 			while (i < set.fd_count - 1) {
83 				set.fd_array[i] = set.fd_array[i+1];
84 				i++;
85 			}
86 			set.fd_count--;
87 			break;
88 		}
89 	}
90 }
91 
92 void FD_ZERO(FD_SET* set) {
93 	set.fd_count = 0;
94 }
95 
96 
97 struct TIMEVAL {
98 	int tv_sec;
99 	int tv_usec;
100 
101 	int opCmp(TIMEVAL tv) {
102 		if (tv_sec < tv.tv_sec)   return -1;
103 		if (tv_sec > tv.tv_sec)   return  1;
104 		if (tv_usec < tv.tv_usec) return -1;
105 		if (tv_usec > tv.tv_usec) return  1;
106 		return 0;
107 	}
108 }
109 alias TIMEVAL* PTIMEVAL, LPTIMEVAL;
110 
111 bool timerisset(TIMEVAL* tvp) {
112 	return tvp.tv_sec || tvp.tv_usec;
113 }
114 
115 /+
116 /* DRK: These have been commented out because it was felt that using
117  * omCmp on the TIMEVAL struct was cleaner.  Still, perhaps these should
118  * be enabled under a version tag for compatibility's sake?
119  * If it is decided that it's just ugly and unwanted, then feel free to
120  * delete this section :)
121  */
122 int timercmp(TIMEVAL* tvp, TIMEVAL* uvp) {
123 	return tvp.tv_sec != uvp.tv_sec ?
124 	    (tvp.tv_sec < uvp.tv_sec ? -1 :
125             (tvp.tv_sec > uvp.tv_sec ? 1 : 0)) :
126 	    (tvp.tv_usec < uvp.tv_usec ? -1 :
127 	        (tvp.tv_usec > uvp.tv_usec ? 1 : 0));
128 }
129 
130 int timercmp(TIMEVAL* tvp, TIMEVAL* uvp, int function(long,long) cmp) {
131 	return tvp.tv_sec != uvp.tv_sec ?
132 	    cmp(tvp.tv_sec, uvp.tv_sec) :
133 	    cmp(tvp.tv_usec, uvp.tv_usec);
134 }+/
135 
136 void timerclear(ref TIMEVAL tvp) {
137 	tvp.tv_sec = tvp.tv_usec = 0;
138 }
139 
140 struct HOSTENT {
141 	char*  h_name;
142 	char** h_aliases;
143 	short  h_addrtype;
144 	short  h_length;
145 	char** h_addr_list;
146 
147 	char* h_addr() { return h_addr_list[0]; }
148 	char* h_addr(char* h) { return h_addr_list[0] = h; }
149 }
150 alias HOSTENT* PHOSTENT, LPHOSTENT;
151 
152 struct LINGER {
153 	u_short l_onoff;
154 	u_short l_linger;
155 }
156 alias LINGER* PLINGER, LPLINGER;
157 
158 enum : DWORD {
159 	IOCPARAM_MASK = 0x7f,
160 	IOC_VOID      = 0x20000000,
161 	IOC_OUT       = 0x40000000,
162 	IOC_IN        = 0x80000000,
163 	IOC_INOUT     = IOC_IN|IOC_OUT
164 }
165 
166 // NOTE: This isn't even used anywhere...
167 template _IO(char x, ubyte y) {
168 	const DWORD _IO = IOC_VOID | (cast(ubyte)x<<8) | y;
169 }
170 
171 template _IOR(char x, ubyte y, t) {
172 	const DWORD _IOR = IOC_OUT | ((t.sizeof & IOCPARAM_MASK)<<16)
173 		| (cast(ubyte)x<<8) | y;
174 }
175 
176 template _IOW(char x, ubyte y, t) {
177 	const DWORD _IOW = IOC_IN | ((t.sizeof & IOCPARAM_MASK)<<16)
178 		| (cast(ubyte)x<<8) | y;
179 }
180 
181 enum : DWORD {
182 	FIONBIO    = _IOW!('f', 126, u_long),
183 	FIONREAD   = _IOR!('f', 127, u_long),
184 	FIOASYNC   = _IOW!('f', 125, u_long),
185 	SIOCSHIWAT = _IOW!('s',   0, u_long),
186 	SIOCGHIWAT = _IOR!('s',   1, u_long),
187 	SIOCSLOWAT = _IOW!('s',   2, u_long),
188 	SIOCGLOWAT = _IOR!('s',   3, u_long),
189 	SIOCATMARK = _IOR!('s',   7, u_long)
190 }
191 
192 struct netent {
193 	char*  n_name;
194 	char** n_aliases;
195 	short  n_addrtype;
196 	u_long n_net;
197 }
198 
199 struct SERVENT {
200 	char*  s_name;
201 	char** s_aliases;
202 	short  s_port;
203 	char*  s_proto;
204 }
205 alias SERVENT* PSERVENT, LPSERVENT;
206 
207 struct PROTOENT {
208 	char*  p_name;
209 	char** p_aliases;
210 	short  p_proto;
211 }
212 alias PROTOENT* PPROTOENT, LPPROTOENT;
213 
214 enum : int {
215 	IPPROTO_IP   =   0,
216 	IPPROTO_ICMP =   1,
217 	IPPROTO_IGMP =   2,
218 	IPPROTO_GGP  =   3,
219 	IPPROTO_TCP  =   6,
220 	IPPROTO_PUP  =  12,
221 	IPPROTO_UDP  =  17,
222 	IPPROTO_IDP  =  22,
223 	IPPROTO_ND   =  77,
224 	IPPROTO_RAW  = 255,
225 	IPPROTO_MAX  = 256,
226 
227 	// IPv6 options
228 	IPPROTO_HOPOPTS  =  0, // IPv6 Hop-by-Hop options
229 	IPPROTO_IPV6     = 41, // IPv6 header
230 	IPPROTO_ROUTING  = 43, // IPv6 Routing header
231 	IPPROTO_FRAGMENT = 44, // IPv6 fragmentation header
232 	IPPROTO_ESP      = 50, // encapsulating security payload
233 	IPPROTO_AH       = 51, // authentication header
234 	IPPROTO_ICMPV6   = 58, // ICMPv6
235 	IPPROTO_NONE     = 59, // IPv6 no next header
236 	IPPROTO_DSTOPTS  = 60  // IPv6 Destination options
237 }
238 
239 enum {
240 	IPPORT_ECHO        =    7,
241 	IPPORT_DISCARD     =    9,
242 	IPPORT_SYSTAT      =   11,
243 	IPPORT_DAYTIME     =   13,
244 	IPPORT_NETSTAT     =   15,
245 	IPPORT_FTP         =   21,
246 	IPPORT_TELNET      =   23,
247 	IPPORT_SMTP        =   25,
248 	IPPORT_TIMESERVER  =   37,
249 	IPPORT_NAMESERVER  =   42,
250 	IPPORT_WHOIS       =   43,
251 	IPPORT_MTP         =   57,
252 	IPPORT_TFTP        =   69,
253 	IPPORT_RJE         =   77,
254 	IPPORT_FINGER      =   79,
255 	IPPORT_TTYLINK     =   87,
256 	IPPORT_SUPDUP      =   95,
257 	IPPORT_EXECSERVER  =  512,
258 	IPPORT_LOGINSERVER =  513,
259 	IPPORT_CMDSERVER   =  514,
260 	IPPORT_EFSSERVER   =  520,
261 	IPPORT_BIFFUDP     =  512,
262 	IPPORT_WHOSERVER   =  513,
263 	IPPORT_ROUTESERVER =  520,
264 	IPPORT_RESERVED    = 1024
265 }
266 
267 enum {
268 	IMPLINK_IP         =  155,
269 	IMPLINK_LOWEXPER   =  156,
270 	IMPLINK_HIGHEXPER  =  158
271 }
272 
273 struct IN_ADDR {
274 	union {
275 		struct { u_char  s_b1, s_b2, s_b3, s_b4; }
276 		struct { u_char  s_net, s_host, s_lh, s_impno; }
277 		struct { u_short s_w1, s_w2; }
278 		struct { u_short s_w_, s_imp; } // Can I get rid of s_w_ using alignment tricks?
279 		u_long S_addr;
280 		u_long s_addr;
281 	}
282 }
283 alias IN_ADDR* PIN_ADDR, LPIN_ADDR;
284 
285 // IN_CLASSx are not used anywhere or documented on MSDN.
286 bool IN_CLASSA(int i) { return (i & 0x80000000) == 0; }
287 
288 const IN_CLASSA_NET    = 0xff000000;
289 const IN_CLASSA_NSHIFT =         24;
290 const IN_CLASSA_HOST   = 0x00ffffff;
291 const IN_CLASSA_MAX    =        128;
292 
293 bool IN_CLASSB(int i) { return (i & 0xc0000000) == 0x80000000; }
294 
295 const IN_CLASSB_NET    = 0xffff0000;
296 const IN_CLASSB_NSHIFT =         16;
297 const IN_CLASSB_HOST   = 0x0000ffff;
298 const IN_CLASSB_MAX    =      65536;
299 
300 bool IN_CLASSC(int i) { return (i & 0xe0000000) == 0xc0000000; }
301 
302 const IN_CLASSC_NET    = 0xffffff00;
303 const IN_CLASSC_NSHIFT =          8;
304 const IN_CLASSC_HOST   = 0x000000ff;
305 
306 const u_long
307 	INADDR_ANY       = 0,
308 	INADDR_LOOPBACK  = 0x7F000001,
309 	INADDR_BROADCAST = 0xFFFFFFFF,
310 	INADDR_NONE      = 0xFFFFFFFF;
311 
312 struct SOCKADDR_IN {
313 	short   sin_family;
314 	u_short sin_port;
315 	IN_ADDR sin_addr;
316 	char[8] sin_zero;
317 }
318 alias SOCKADDR_IN* PSOCKADDR_IN, LPSOCKADDR_IN;
319 
320 const size_t
321 	WSADESCRIPTION_LEN = 256,
322 	WSASYS_STATUS_LEN  = 128;
323 
324 struct WSADATA {
325 	WORD   wVersion;
326 	WORD   wHighVersion;
327 	char[WSADESCRIPTION_LEN+1] szDescription;
328 	char[WSASYS_STATUS_LEN+1]  szSystemStatus;
329 	ushort iMaxSockets;
330 	ushort iMaxUdpDg;
331 	char*  lpVendorInfo;
332 }
333 alias WSADATA* LPWSADATA;
334 
335 // This is not documented on the MSDN site
336 const IP_OPTIONS = 1;
337 
338 const int
339 	SO_OPTIONS     =   1,
340 	SO_DEBUG       =   1,
341 	SO_ACCEPTCONN  =   2,
342 	SO_REUSEADDR   =   4,
343 	SO_KEEPALIVE   =   8,
344 	SO_DONTROUTE   =  16,
345 	SO_BROADCAST   =  32,
346 	SO_USELOOPBACK =  64,
347 	SO_LINGER      = 128,
348 	SO_OOBINLINE   = 256,
349 	SO_DONTLINGER  = ~SO_LINGER,
350 	SO_EXCLUSIVEADDRUSE= ~SO_REUSEADDR;
351 
352 enum : int {
353 	SO_SNDBUF = 0x1001,
354 	SO_RCVBUF,
355 	SO_SNDLOWAT,
356 	SO_RCVLOWAT,
357 	SO_SNDTIMEO,
358 	SO_RCVTIMEO,
359 	SO_ERROR,
360 	SO_TYPE // = 0x1008
361 }
362 
363 const SOCKET INVALID_SOCKET = cast(SOCKET)(~0);
364 const int SOCKET_ERROR = -1;
365 
366 enum : int {
367 	SOCK_STREAM = 1,
368 	SOCK_DGRAM,
369 	SOCK_RAW,
370 	SOCK_RDM,
371 	SOCK_SEQPACKET
372 }
373 
374 const int TCP_NODELAY = 0x0001;
375 
376 enum : int {
377 	AF_UNSPEC,
378 	AF_UNIX,
379 	AF_INET,
380 	AF_IMPLINK,
381 	AF_PUP,
382 	AF_CHAOS,
383 	AF_IPX,  // =  6
384 	AF_NS       =  6,
385 	AF_ISO,
386 	AF_OSI      = AF_ISO,
387 	AF_ECMA,
388 	AF_DATAKIT,
389 	AF_CCITT,
390 	AF_SNA,
391 	AF_DECnet,
392 	AF_DLI,
393 	AF_LAT,
394 	AF_HYLINK,
395 	AF_APPLETALK,
396 	AF_NETBIOS,
397 	AF_VOICEVIEW,
398 	AF_FIREFOX,
399 	AF_UNKNOWN1,
400 	AF_BAN,
401 	AF_ATM,
402 	AF_INET6,
403 	// AF_CLUSTER, AF_12844 nad AF_NETDES are not documented on MSDN
404 	AF_CLUSTER,
405 	AF_12844,
406 	AF_IRDA, // = 26
407 	AF_NETDES   = 28,
408 	AF_MAX   // = 29
409 }
410 
411 struct SOCKADDR {
412 	u_short  sa_family;
413 	char[14] sa_data;
414 }
415 alias SOCKADDR* PSOCKADDR, LPSOCKADDR;
416 
417 /* Portable IPv6/IPv4 version of sockaddr.
418    Uses padding to force 8 byte alignment
419    and maximum size of 128 bytes */
420 struct SOCKADDR_STORAGE {
421     short     ss_family;
422     char[6]   __ss_pad1;   // pad to 8
423     long      __ss_align;  // force alignment
424     char[112] __ss_pad2;   // pad to 128
425 }
426 alias SOCKADDR_STORAGE* PSOCKADDR_STORAGE;
427 
428 struct sockproto {
429 	u_short sp_family;
430 	u_short sp_protocol;
431 }
432 
433 enum : int {
434 	PF_UNSPEC    = AF_UNSPEC,
435 	PF_UNIX      = AF_UNIX,
436 	PF_INET      = AF_INET,
437 	PF_IMPLINK   = AF_IMPLINK,
438 	PF_PUP       = AF_PUP,
439 	PF_CHAOS     = AF_CHAOS,
440 	PF_NS        = AF_NS,
441 	PF_IPX       = AF_IPX,
442 	PF_ISO       = AF_ISO,
443 	PF_OSI       = AF_OSI,
444 	PF_ECMA      = AF_ECMA,
445 	PF_DATAKIT   = AF_DATAKIT,
446 	PF_CCITT     = AF_CCITT,
447 	PF_SNA       = AF_SNA,
448 	PF_DECnet    = AF_DECnet,
449 	PF_DLI       = AF_DLI,
450 	PF_LAT       = AF_LAT,
451 	PF_HYLINK    = AF_HYLINK,
452 	PF_APPLETALK = AF_APPLETALK,
453 	PF_VOICEVIEW = AF_VOICEVIEW,
454 	PF_FIREFOX   = AF_FIREFOX,
455 	PF_UNKNOWN1  = AF_UNKNOWN1,
456 	PF_BAN       = AF_BAN,
457 	PF_ATM       = AF_ATM,
458 	PF_INET6     = AF_INET6,
459 	PF_MAX       = AF_MAX
460 }
461 
462 const int SOL_SOCKET = 0xFFFF;
463 
464 const int SOMAXCONN = 5;
465 
466 const int
467 	MSG_OOB       = 1,
468 	MSG_PEEK      = 2,
469 	MSG_DONTROUTE = 4,
470 	MSG_MAXIOVLEN = 16,
471 	MSG_PARTIAL   = 0x8000;
472 
473 const size_t MAXGETHOSTSTRUCT = 1024;
474 
475 // Not documented on MSDN
476 enum {
477 	FD_READ_BIT,
478 	FD_WRITE_BIT,
479 	FD_OOB_BIT,
480 	FD_ACCEPT_BIT,
481 	FD_CONNECT_BIT,
482 	FD_CLOSE_BIT,
483 	FD_QOS_BIT,
484 	FD_GROUP_QOS_BIT,
485 	FD_ROUTING_INTERFACE_CHANGE_BIT,
486 	FD_ADDRESS_LIST_CHANGE_BIT,
487 	FD_MAX_EVENTS // = 10
488 }
489 
490 const int
491 	FD_READ                     = 1 << FD_READ_BIT,
492 	FD_WRITE                    = 1 << FD_WRITE_BIT,
493 	FD_OOB                      = 1 << FD_OOB_BIT,
494 	FD_ACCEPT                   = 1 << FD_ACCEPT_BIT,
495 	FD_CONNECT                  = 1 << FD_CONNECT_BIT,
496 	FD_CLOSE                    = 1 << FD_CLOSE_BIT,
497 	FD_QOS                      = 1 << FD_QOS_BIT,
498 	FD_GROUP_QOS                = 1 << FD_GROUP_QOS_BIT,
499 	FD_ROUTING_INTERFACE_CHANGE = 1 << FD_ROUTING_INTERFACE_CHANGE_BIT,
500 	FD_ADDRESS_LIST_CHANGE      = 1 << FD_ADDRESS_LIST_CHANGE_BIT,
501 	FD_ALL_EVENTS               = (1 << FD_MAX_EVENTS) - 1;
502 
503 enum : int {
504 	WSABASEERR         = 10000,
505 	WSAEINTR           = WSABASEERR + 4,
506 	WSAEBADF           = WSABASEERR + 9,
507 	WSAEACCES          = WSABASEERR + 13,
508 	WSAEFAULT          = WSABASEERR + 14,
509 	WSAEINVAL          = WSABASEERR + 22,
510 	WSAEMFILE          = WSABASEERR + 24,
511 	WSAEWOULDBLOCK     = WSABASEERR + 35,
512 	WSAEINPROGRESS     = WSABASEERR + 36, // deprecated on WinSock2
513 	WSAEALREADY        = WSABASEERR + 37,
514 	WSAENOTSOCK        = WSABASEERR + 38,
515 	WSAEDESTADDRREQ    = WSABASEERR + 39,
516 	WSAEMSGSIZE        = WSABASEERR + 40,
517 	WSAEPROTOTYPE      = WSABASEERR + 41,
518 	WSAENOPROTOOPT     = WSABASEERR + 42,
519 	WSAEPROTONOSUPPORT = WSABASEERR + 43,
520 	WSAESOCKTNOSUPPORT = WSABASEERR + 44,
521 	WSAEOPNOTSUPP      = WSABASEERR + 45,
522 	WSAEPFNOSUPPORT    = WSABASEERR + 46,
523 	WSAEAFNOSUPPORT    = WSABASEERR + 47,
524 	WSAEADDRINUSE      = WSABASEERR + 48,
525 	WSAEADDRNOTAVAIL   = WSABASEERR + 49,
526 	WSAENETDOWN        = WSABASEERR + 50,
527 	WSAENETUNREACH     = WSABASEERR + 51,
528 	WSAENETRESET       = WSABASEERR + 52,
529 	WSAECONNABORTED    = WSABASEERR + 53,
530 	WSAECONNRESET      = WSABASEERR + 54,
531 	WSAENOBUFS         = WSABASEERR + 55,
532 	WSAEISCONN         = WSABASEERR + 56,
533 	WSAENOTCONN        = WSABASEERR + 57,
534 	WSAESHUTDOWN       = WSABASEERR + 58,
535 	WSAETOOMANYREFS    = WSABASEERR + 59,
536 	WSAETIMEDOUT       = WSABASEERR + 60,
537 	WSAECONNREFUSED    = WSABASEERR + 61,
538 	WSAELOOP           = WSABASEERR + 62,
539 	WSAENAMETOOLONG    = WSABASEERR + 63,
540 	WSAEHOSTDOWN       = WSABASEERR + 64,
541 	WSAEHOSTUNREACH    = WSABASEERR + 65,
542 	WSAENOTEMPTY       = WSABASEERR + 66,
543 	WSAEPROCLIM        = WSABASEERR + 67,
544 	WSAEUSERS          = WSABASEERR + 68,
545 	WSAEDQUOT          = WSABASEERR + 69,
546 	WSAESTALE          = WSABASEERR + 70,
547 	WSAEREMOTE         = WSABASEERR + 71,
548 	WSAEDISCON         = WSABASEERR + 101,
549 	WSASYSNOTREADY     = WSABASEERR + 91,
550 	WSAVERNOTSUPPORTED = WSABASEERR + 92,
551 	WSANOTINITIALISED  = WSABASEERR + 93,
552 	WSAHOST_NOT_FOUND  = WSABASEERR + 1001,
553 	WSATRY_AGAIN       = WSABASEERR + 1002,
554 	WSANO_RECOVERY     = WSABASEERR + 1003,
555 	WSANO_DATA         = WSABASEERR + 1004,
556 	WSANO_ADDRESS      = WSANO_DATA,
557 
558 	// WinSock2 specific error codes
559 	WSAENOMORE             = WSABASEERR + 102,
560 	WSAECANCELLED          = WSABASEERR + 103,
561 	WSAEINVALIDPROCTABLE   = WSABASEERR + 104,
562 	WSAEINVALIDPROVIDER    = WSABASEERR + 105,
563 	WSAEPROVIDERFAILEDINIT = WSABASEERR + 106,
564 	WSASYSCALLFAILURE      = WSABASEERR + 107,
565 	WSASERVICE_NOT_FOUND   = WSABASEERR + 108,
566 	WSATYPE_NOT_FOUND      = WSABASEERR + 109,
567 	WSA_E_NO_MORE          = WSABASEERR + 110,
568 	WSA_E_CANCELLED        = WSABASEERR + 111,
569 	WSAEREFUSED            = WSABASEERR + 112,
570 
571 	// WS QualityofService errors
572 	WSA_QOS_RECEIVERS          = WSABASEERR + 1005,
573 	WSA_QOS_SENDERS            = WSABASEERR + 1006,
574 	WSA_QOS_NO_SENDERS         = WSABASEERR + 1007,
575 	WSA_QOS_NO_RECEIVERS       = WSABASEERR + 1008,
576 	WSA_QOS_REQUEST_CONFIRMED  = WSABASEERR + 1009,
577 	WSA_QOS_ADMISSION_FAILURE  = WSABASEERR + 1010,
578 	WSA_QOS_POLICY_FAILURE     = WSABASEERR + 1011,
579 	WSA_QOS_BAD_STYLE          = WSABASEERR + 1012,
580 	WSA_QOS_BAD_OBJECT         = WSABASEERR + 1013,
581 	WSA_QOS_TRAFFIC_CTRL_ERROR = WSABASEERR + 1014,
582 	WSA_QOS_GENERIC_ERROR      = WSABASEERR + 1015,
583 	WSA_QOS_ESERVICETYPE       = WSABASEERR + 1016,
584 	WSA_QOS_EFLOWSPEC          = WSABASEERR + 1017,
585 	WSA_QOS_EPROVSPECBUF       = WSABASEERR + 1018,
586 	WSA_QOS_EFILTERSTYLE       = WSABASEERR + 1019,
587 	WSA_QOS_EFILTERTYPE        = WSABASEERR + 1020,
588 	WSA_QOS_EFILTERCOUNT       = WSABASEERR + 1021,
589 	WSA_QOS_EOBJLENGTH         = WSABASEERR + 1022,
590 	WSA_QOS_EFLOWCOUNT         = WSABASEERR + 1023,
591 	WSA_QOS_EUNKOWNPSOBJ       = WSABASEERR + 1024,
592 	WSA_QOS_EPOLICYOBJ         = WSABASEERR + 1025,
593 	WSA_QOS_EFLOWDESC          = WSABASEERR + 1026,
594 	WSA_QOS_EPSFLOWSPEC        = WSABASEERR + 1027,
595 	WSA_QOS_EPSFILTERSPEC      = WSABASEERR + 1028,
596 	WSA_QOS_ESDMODEOBJ         = WSABASEERR + 1029,
597 	WSA_QOS_ESHAPERATEOBJ      = WSABASEERR + 1030,
598 	WSA_QOS_RESERVED_PETYPE    = WSABASEERR + 1031
599 }
600 
601 alias WSAGetLastError h_errno;
602 
603 enum : int {
604 	HOST_NOT_FOUND = WSAHOST_NOT_FOUND,
605 	TRY_AGAIN      = WSATRY_AGAIN,
606 	NO_RECOVERY    = WSANO_RECOVERY,
607 	NO_DATA        = WSANO_DATA,
608 	NO_ADDRESS     = WSANO_ADDRESS
609 }
610 
611 extern (Windows) {
612 	SOCKET accept(SOCKET, SOCKADDR*, int*);
613 	int bind(SOCKET, const(SOCKADDR)*, int);
614 	int closesocket(SOCKET);
615 	int connect(SOCKET, const(SOCKADDR)*, int);
616 	int ioctlsocket(SOCKET, int, u_long*);
617 	int getpeername(SOCKET, SOCKADDR*, int*);
618 	int getsockname(SOCKET, SOCKADDR*, int*);
619 	int getsockopt(SOCKET, int, int, void*, int*);
620 	uint inet_addr(const(char)*);
621 	int listen(SOCKET, int);
622 	int recv(SOCKET, ubyte*, int, int);
623 	int recvfrom(SOCKET, ubyte*, int, int, SOCKADDR*, int*);
624 	int send(SOCKET, const(ubyte)*, int, int);
625 	int sendto(SOCKET, const(ubyte)*, int, int, const(SOCKADDR)*, int);
626 	int setsockopt(SOCKET, int, int, const(void)*, int);
627 	int shutdown(SOCKET, int);
628 	SOCKET socket(int, int, int);
629 
630 	alias typeof(&accept) LPFN_ACCEPT;
631 	alias typeof(&bind) LPFN_BIND;
632 	alias typeof(&closesocket) LPFN_CLOSESOCKET;
633 	alias typeof(&connect) LPFN_CONNECT;
634 	alias typeof(&ioctlsocket) LPFN_IOCTLSOCKET;
635 	alias typeof(&getpeername) LPFN_GETPEERNAME;
636 	alias typeof(&getsockname) LPFN_GETSOCKNAME;
637 	alias typeof(&getsockopt) LPFN_GETSOCKOPT;
638 	alias typeof(&inet_addr) LPFN_INET_ADDR;
639 	alias typeof(&listen) LPFN_LISTEN;
640 	alias typeof(&recv) LPFN_RECV;
641 	alias typeof(&recvfrom) LPFN_RECVFROM;
642 	alias typeof(&send) LPFN_SEND;
643 	alias typeof(&sendto) LPFN_SENDTO;
644 	alias typeof(&setsockopt) LPFN_SETSOCKOPT;
645 	alias typeof(&shutdown) LPFN_SHUTDOWN;
646 	alias typeof(&socket) LPFN_SOCKET;
647 }
648 
649 extern(Windows) {
650 	char* inet_ntoa(IN_ADDR);
651 	HOSTENT* gethostbyaddr(const(char)*, int, int);
652 	HOSTENT* gethostbyname(const(char)*);
653 	SERVENT* getservbyport(int, const(char)*);
654 	SERVENT* getservbyname(const(char)*, const(char)*);
655 	PROTOENT* getprotobynumber(int);
656 	PROTOENT* getprotobyname(const(char)*);
657 
658 	/* NOTE: DK: in the original headers, these were declared with
659 	   PASCAL linkage.  Since this is at odds with the definition
660 	   of the functions themselves, and also since MinGW seems to
661 	   treat the two interchangably, I have moved them here. */
662 	alias typeof(&inet_ntoa) LPFN_INET_NTOA;
663 	alias typeof(&gethostbyaddr) LPFN_GETHOSTBYADDR;
664 	alias typeof(&gethostbyname) LPFN_GETHOSTBYNAME;
665 	alias typeof(&getservbyport) LPFN_GETSERVBYPORT;
666 	alias typeof(&getservbyname) LPFN_GETSERVBYNAME;
667 	alias typeof(&getprotobynumber) LPFN_GETPROTOBYNUMBER;
668 	alias typeof(&getprotobyname) LPFN_GETPROTOBYNAME;
669 }
670 
671 extern(Windows) {
672 	int WSAStartup(WORD, LPWSADATA);
673 	int WSACleanup();
674 	void WSASetLastError(int);
675 	int WSAGetLastError();
676 
677 	alias typeof(&WSAStartup) LPFN_WSASTARTUP;
678 	alias typeof(&WSACleanup) LPFN_WSACLEANUP;
679 	alias typeof(&WSASetLastError) LPFN_WSASETLASTERROR;
680 	alias typeof(&WSAGetLastError) LPFN_WSAGETLASTERROR;
681 }
682 
683 /*
684  * Pseudo-blocking functions are deprecated in WinSock2
685  * spec. Use threads instead.
686  */
687 deprecated extern(Windows) {
688 	BOOL WSAIsBlocking();
689 	int WSAUnhookBlockingHook();
690 	FARPROC WSASetBlockingHook(FARPROC);
691 	int WSACancelBlockingCall();
692 
693 	alias typeof(&WSAIsBlocking) LPFN_WSAISBLOCKING;
694 	alias typeof(&WSAUnhookBlockingHook) LPFN_WSAUNHOOKBLOCKINGHOOK;
695 	alias typeof(&WSASetBlockingHook) LPFN_WSASETBLOCKINGHOOK;
696 	alias typeof(&WSACancelBlockingCall) LPFN_WSACANCELBLOCKINGCALL;
697 }
698 
699 extern(Windows) {
700 	HANDLE WSAAsyncGetServByName(HWND, u_int, const(char)*, const(char)*, char*, int);
701 	HANDLE WSAAsyncGetServByPort(HWND, u_int, int, const(char)*, char*, int);
702 	HANDLE WSAAsyncGetProtoByName(HWND, u_int, const(char)*, char*, int);
703 	HANDLE WSAAsyncGetProtoByNumber(HWND, u_int, int, char*, int);
704 	HANDLE WSAAsyncGetHostByName(HWND, u_int, const(char)*, char*, int);
705 	HANDLE WSAAsyncGetHostByAddr(HWND, u_int, const(char)*, int, int, char*, int);
706 	int WSACancelAsyncRequest(HANDLE);
707 	int WSAAsyncSelect(SOCKET, HWND, u_int, long);
708 
709 	alias typeof(&WSAAsyncGetServByName) LPFN_WSAAsyncGetServByName;
710 	alias typeof(&WSAAsyncGetServByPort) LPFN_WSAASYNCGETSERVBYPORT;
711 	alias typeof(&WSAAsyncGetProtoByName) LPFN_WSAASYNCGETPROTOBYNAME;
712 	alias typeof(&WSAAsyncGetProtoByNumber) LPFN_WSAASYNCGETPROTOBYNUMBER;
713 	alias typeof(&WSAAsyncGetHostByName) LPFN_WSAASYNCGETHOSTBYNAME;
714 	alias typeof(&WSAAsyncGetHostByAddr) LPFN_WSAASYNCGETHOSTBYADDR;
715 	alias typeof(&WSACancelAsyncRequest) LPFN_WSACANCELASYNCREQUEST;
716 	alias typeof(&WSAAsyncSelect) LPFN_WSAASYNCSELECT;
717 }
718 
719 extern(Windows) {
720 	u_long htonl(u_long);
721 	u_long ntohl(u_long);
722 	u_short htons(u_short);
723 	u_short ntohs(u_short);
724 	int select(int nfds, fd_set*, fd_set*, fd_set*, const(TIMEVAL)*);
725 
726 	alias typeof(&htonl) LPFN_HTONL;
727 	alias typeof(&ntohl) LPFN_NTOHL;
728 	alias typeof(&htons) LPFN_HTONS;
729 	alias typeof(&ntohs) LPFN_NTOHS;
730 	alias typeof(&select) LPFN_SELECT;
731 
732 	int gethostname(char*, int);
733 	alias typeof(&gethostname) LPFN_GETHOSTNAME;
734 }
735 
736 alias MAKELONG WSAMAKEASYNCREPLY, WSAMAKESELECTREPLY;
737 alias LOWORD WSAGETASYNCBUFLEN, WSAGETSELECTEVENT;
738 alias HIWORD WSAGETASYNCERROR, WSAGETSELECTERROR;
739 
740 
741 alias INADDR_ANY ADDR_ANY;
742 
743 bool IN_CLASSD(int i) { return (i & 0xf0000000) == 0xe0000000; }
744 
745 const IN_CLASSD_NET    = 0xf0000000;
746 const IN_CLASSD_NSHIFT =         28;
747 const IN_CLASSD_HOST   = 0x0fffffff;
748 
749 alias IN_CLASSD IN_MULTICAST;
750 
751 const FROM_PROTOCOL_INFO = -1;
752 
753 enum : int {
754 	SO_GROUP_ID = 0x2001,
755 	SO_GROUP_PRIORITY,
756 	SO_MAX_MSG_SIZE,
757 	SO_PROTOCOL_INFOA,
758 	SO_PROTOCOL_INFOW
759 }
760 // NOTE: These are logically part of the previous enum, but you can't
761 // have version statements in an enum body...
762 version(Unicode)
763 	const int SO_PROTOCOL_INFO = SO_PROTOCOL_INFOW;
764 else
765 	const int SO_PROTOCOL_INFO = SO_PROTOCOL_INFOA;
766 
767 const PVD_CONFIG = 0x3001;
768 
769 const MSG_INTERRUPT = 0x10;
770 //const MSG_MAXIOVLEN = 16; // Already declared above
771 
772 mixin DECLARE_HANDLE!("WSAEVENT");
773 alias WSAEVENT* LPWSAEVENT;
774 alias OVERLAPPED WSAOVERLAPPED;
775 alias OVERLAPPED* LPWSAOVERLAPPED;
776 
777 private import windows.winerror;
778 private import windows.winbase;
779 
780 enum {
781 	WSA_IO_PENDING        = ERROR_IO_PENDING,
782 	WSA_IO_INCOMPLETE     = ERROR_IO_INCOMPLETE,
783 	WSA_INVALID_HANDLE    = ERROR_INVALID_HANDLE,
784 	WSA_INVALID_PARAMETER = ERROR_INVALID_PARAMETER,
785 	WSA_NOT_ENOUGH_MEMORY = ERROR_NOT_ENOUGH_MEMORY,
786 	WSA_OPERATION_ABORTED = ERROR_OPERATION_ABORTED
787 }
788 
789 const WSA_INVALID_EVENT = cast(WSAEVENT)HANDLE.init;
790 const WSA_MAXIMUM_WAIT_EVENTS = MAXIMUM_WAIT_OBJECTS;
791 const WSA_WAIT_FAILED = cast(DWORD)-1;
792 const WSA_WAIT_EVENT_0 = WAIT_OBJECT_0;
793 const WSA_WAIT_IO_COMPLETION = WAIT_IO_COMPLETION;
794 const WSA_WAIT_TIMEOUT = WAIT_TIMEOUT;
795 const WSA_INFINITE = INFINITE;
796 
797 struct WSABUF {
798 	uint  len;
799 	char* buf;
800 }
801 
802 alias WSABUF* LPWSABUF;
803 
804 enum GUARANTEE {
805 	BestEffortService,
806 	ControlledLoadService,
807 	PredictiveService,
808 	GuaranteedDelayService,
809 	GuaranteedService
810 }
811 
812 /* TODO: FLOWSPEC and related definitions belong in qos.h */
813 
814 /*
815    Windows Sockets 2 Application Programming Interface,
816    revision 2.2.2 (1997) uses the type uint32 for SERVICETYPE
817    and the elements of _flowspec, but the type uint32 is not defined
818    or used anywhere else in the w32api. For now, just use
819    unsigned int, which is 32 bits on _WIN32 and _WIN64.
820 */
821 
822 alias uint SERVICETYPE;
823 
824 struct FLOWSPEC {
825 	uint        TokenRate;
826 	uint        TokenBucketSize;
827 	uint        PeakBandwidth;
828 	uint        Latency;
829 	uint        DelayVariation;
830 	SERVICETYPE ServiceType;
831 	uint        MaxSduSize;
832 	uint        MinimumPolicedSize;
833 }
834 
835 alias FLOWSPEC* PFLOWSPEC, LPFLOWSPEC;
836 
837 struct QOS
838 {
839 	FLOWSPEC SendingFlowspec;
840 	FLOWSPEC ReceivingFlowspec;
841 	WSABUF   ProviderSpecific;
842 }
843 
844 alias QOS* LPQOS;
845 
846 enum {
847 	CF_ACCEPT,
848 	CF_REJECT,
849 	CF_DEFER
850 }
851 
852 // REM: Already defined above
853 /*enum {
854 	SD_RECEIVE,
855 	SD_SEND,
856 	SD_BOTH
857 }*/
858 
859 alias uint GROUP;
860 
861 enum {
862 	SG_UNCONSTRAINED_GROUP = 0x01,
863 	SG_CONSTRAINED_GROUP
864 }
865 
866 struct WSANETWORKEVENTS {
867 	int lNetworkEvents;
868 	int[FD_MAX_EVENTS] iErrorCode;
869 }
870 
871 alias WSANETWORKEVENTS* LPWSANETWORKEVENTS;
872 
873 const MAX_PROTOCOL_CHAIN = 7;
874 
875 const BASE_PROTOCOL    = 1;
876 const LAYERED_PROTOCOL = 0;
877 
878 enum WSAESETSERVICEOP
879 {
880 	RNRSERVICE_REGISTER = 0,
881 	RNRSERVICE_DEREGISTER,
882 	RNRSERVICE_DELETE
883 }
884 
885 alias WSAESETSERVICEOP* PWSAESETSERVICEOP, LPWSAESETSERVICEOP;
886 
887 struct AFPROTOCOLS {
888 	INT iAddressFamily;
889 	INT iProtocol;
890 }
891 
892 alias AFPROTOCOLS* PAFPROTOCOLS, LPAFPROTOCOLS;
893 
894 enum WSAECOMPARATOR
895 {
896 	COMP_EQUAL = 0,
897 	COMP_NOTLESS
898 }
899 
900 alias WSAECOMPARATOR* PWSAECOMPARATOR, LPWSAECOMPARATOR;
901 
902 struct WSAVERSION
903 {
904 	DWORD          dwVersion;
905 	WSAECOMPARATOR ecHow;
906 }
907 
908 alias WSAVERSION* PWSAVERSION, LPWSAVERSION;
909 
910 // Import for SOCKET_ADDRESS, CSADDR_INFO
911 // import windows.nspapi;
912 //#ifndef __CSADDR_T_DEFINED /* also in nspapi.h */
913 //#define __CSADDR_T_DEFINED
914 
915 struct SOCKET_ADDRESS {
916 	LPSOCKADDR lpSockaddr;
917 	INT        iSockaddrLength;
918 }
919 
920 alias SOCKET_ADDRESS* PSOCKET_ADDRESS, LPSOCKET_ADDRESS;
921 
922 struct CSADDR_INFO {
923 	SOCKET_ADDRESS LocalAddr;
924 	SOCKET_ADDRESS RemoteAddr;
925 	INT            iSocketType;
926 	INT            iProtocol;
927 }
928 
929 alias CSADDR_INFO* PCSADDR_INFO, LPCSADDR_INFO;
930 
931 //#endif
932 
933 struct SOCKET_ADDRESS_LIST {
934     INT               iAddressCount;
935     SOCKET_ADDRESS[1] _Address;
936     SOCKET_ADDRESS* Address() { return _Address.ptr; }
937 }
938 
939 alias SOCKET_ADDRESS_LIST* LPSOCKET_ADDRESS_LIST;
940 
941 // TODO: Import wtypes/nspapi?
942 //#ifndef __BLOB_T_DEFINED /* also in wtypes.h and nspapi.h */
943 //#define __BLOB_T_DEFINED
944 struct BLOB {
945 	ULONG cbSize;
946 	BYTE* pBlobData;
947 }
948 
949 alias BLOB* PBLOB, LPBLOB;
950 //#endif
951 
952 struct WSAQUERYSETA
953 {
954 	DWORD         dwSize;
955 	LPSTR         lpszServiceInstanceName;
956 	LPGUID        lpServiceClassId;
957 	LPWSAVERSION  lpVersion;
958 	LPSTR         lpszComment;
959 	DWORD         dwNameSpace;
960 	LPGUID        lpNSProviderId;
961 	LPSTR         lpszContext;
962 	DWORD         dwNumberOfProtocols;
963 	LPAFPROTOCOLS lpafpProtocols;
964 	LPSTR         lpszQueryString;
965 	DWORD         dwNumberOfCsAddrs;
966 	LPCSADDR_INFO lpcsaBuffer;
967 	DWORD         dwOutputFlags;
968 	LPBLOB        lpBlob;
969 }
970 
971 alias WSAQUERYSETA* PWSAQUERYSETA, LPWSAQUERYSETA;
972 
973 struct WSAQUERYSETW
974 {
975 	DWORD         dwSize;
976 	LPWSTR        lpszServiceInstanceName;
977 	LPGUID        lpServiceClassId;
978 	LPWSAVERSION  lpVersion;
979 	LPWSTR        lpszComment;
980 	DWORD         dwNameSpace;
981 	LPGUID        lpNSProviderId;
982 	LPWSTR        lpszContext;
983 	DWORD         dwNumberOfProtocols;
984 	LPAFPROTOCOLS lpafpProtocols;
985 	LPWSTR        lpszQueryString;
986 	DWORD         dwNumberOfCsAddrs;
987 	LPCSADDR_INFO lpcsaBuffer;
988 	DWORD         dwOutputFlags;
989 	LPBLOB        lpBlob;
990 }
991 
992 
993 alias WSAQUERYSETW* PWSAQUERYSETW, LPWSAQUERYSETW;
994 
995 version(Unicode) {
996 	alias WSAQUERYSETW WSAQUERYSET;
997 	alias PWSAQUERYSETW PWSAQUERYSET;
998 	alias LPWSAQUERYSETW LPWSAQUERYSET;
999 } else {
1000 	alias WSAQUERYSETA WSAQUERYSET;
1001 	alias PWSAQUERYSETA PWSAQUERYSET;
1002 	alias LPWSAQUERYSETA LPWSAQUERYSET;
1003 }
1004 
1005 const int
1006 	LUP_DEEP                = 0x0001,
1007 	LUP_CONTAINERS          = 0x0002,
1008 	LUP_NOCONTAINERS        = 0x0004,
1009 	LUP_NEAREST             = 0x0008,
1010 	LUP_RETURN_NAME         = 0x0010,
1011 	LUP_RETURN_TYPE         = 0x0020,
1012 	LUP_RETURN_VERSION      = 0x0040,
1013 	LUP_RETURN_COMMENT      = 0x0080,
1014 	LUP_RETURN_ADDR         = 0x0100,
1015 	LUP_RETURN_BLOB         = 0x0200,
1016 	LUP_RETURN_ALIASES      = 0x0400,
1017 	LUP_RETURN_QUERY_STRING = 0x0800,
1018 	LUP_RETURN_ALL          = 0x0FF0,
1019 	LUP_RES_SERVICE         = 0x8000,
1020 	LUP_FLUSHCACHE          = 0x1000,
1021 	LUP_FLUSHPREVIOUS       = 0x2000;
1022 
1023 struct WSANSCLASSINFOA
1024 {
1025 	LPSTR  lpszName;
1026 	DWORD  dwNameSpace;
1027 	DWORD  dwValueType;
1028 	DWORD  dwValueSize;
1029 	LPVOID lpValue;
1030 }
1031 
1032 alias WSANSCLASSINFOA* PWSANSCLASSINFOA, LPWSANSCLASSINFOA;
1033 
1034 struct WSANSCLASSINFOW
1035 {
1036 	LPWSTR lpszName;
1037 	DWORD  dwNameSpace;
1038 	DWORD  dwValueType;
1039 	DWORD  dwValueSize;
1040 	LPVOID lpValue;
1041 }
1042 
1043 alias WSANSCLASSINFOW* PWSANSCLASSINFOW, LPWSANSCLASSINFOW;
1044 
1045 version(Unicode) {
1046 	alias WSANSCLASSINFOW WSANSCLASSINFO;
1047 	alias PWSANSCLASSINFOW PWSANSCLASSINFO;
1048 	alias LPWSANSCLASSINFOW LPWSANSCLASSINFO;
1049 } else {
1050 	alias WSANSCLASSINFOA WSANSCLASSINFO;
1051 	alias PWSANSCLASSINFOA PWSANSCLASSINFO;
1052 	alias LPWSANSCLASSINFOA LPWSANSCLASSINFO;
1053 }
1054 
1055 struct WSASERVICECLASSINFOA
1056 {
1057 	LPGUID            lpServiceClassId;
1058 	LPSTR             lpszServiceClassName;
1059 	DWORD             dwCount;
1060 	LPWSANSCLASSINFOA lpClassInfos;
1061 }
1062 
1063 alias WSASERVICECLASSINFOA* PWSASERVICECLASSINFOA, LPWSASERVICECLASSINFOA;
1064 
1065 struct WSASERVICECLASSINFOW
1066 {
1067 	LPGUID            lpServiceClassId;
1068 	LPWSTR            lpszServiceClassName;
1069 	DWORD             dwCount;
1070 	LPWSANSCLASSINFOW lpClassInfos;
1071 }
1072 
1073 alias WSASERVICECLASSINFOW* PWSASERVICECLASSINFOW, LPWSASERVICECLASSINFOW;
1074 
1075 version(Unicode) {
1076 	alias WSASERVICECLASSINFOW WSASERVICECLASSINFO;
1077 	alias PWSASERVICECLASSINFOW PWSASERVICECLASSINFO;
1078 	alias LPWSASERVICECLASSINFOW LPWSASERVICECLASSINFO;
1079 } else {
1080 	alias WSASERVICECLASSINFOA WSASERVICECLASSINFO;
1081 	alias PWSASERVICECLASSINFOA PWSASERVICECLASSINFO;
1082 	alias LPWSASERVICECLASSINFOA LPWSASERVICECLASSINFO;
1083 }
1084 
1085 struct WSANAMESPACE_INFOA {
1086 	GUID  NSProviderId;
1087 	DWORD dwNameSpace;
1088 	BOOL  fActive;
1089 	DWORD dwVersion;
1090 	LPSTR lpszIdentifier;
1091 }
1092 
1093 alias WSANAMESPACE_INFOA* PWSANAMESPACE_INFOA, LPWSANAMESPACE_INFOA;
1094 
1095 struct WSANAMESPACE_INFOW {
1096 	GUID   NSProviderId;
1097 	DWORD  dwNameSpace;
1098 	BOOL   fActive;
1099 	DWORD  dwVersion;
1100 	LPWSTR lpszIdentifier;
1101 }
1102 
1103 alias WSANAMESPACE_INFOW* PWSANAMESPACE_INFOW, LPWSANAMESPACE_INFOW;
1104 
1105 version(Unicode) {
1106 	alias WSANAMESPACE_INFOW WSANAMESPACE_INFO;
1107 	alias PWSANAMESPACE_INFOW PWSANAMESPACE_INFO;
1108 	alias LPWSANAMESPACE_INFOW LPWSANAMESPACE_INFO;
1109 } else {
1110 	alias WSANAMESPACE_INFOA WSANAMESPACE_INFO;
1111 	alias PWSANAMESPACE_INFOA PWSANAMESPACE_INFO;
1112 	alias LPWSANAMESPACE_INFOA LPWSANAMESPACE_INFO;
1113 }
1114 
1115 struct WSAPROTOCOLCHAIN {
1116 	int                       ChainLen;
1117 	DWORD[MAX_PROTOCOL_CHAIN] ChainEntries;
1118 }
1119 
1120 alias WSAPROTOCOLCHAIN* LPWSAPROTOCOLCHAIN;
1121 
1122 const WSAPROTOCOL_LEN = 255;
1123 
1124 struct WSAPROTOCOL_INFOA {
1125 	DWORD dwServiceFlags1;
1126 	DWORD dwServiceFlags2;
1127 	DWORD dwServiceFlags3;
1128 	DWORD dwServiceFlags4;
1129 	DWORD dwProviderFlags;
1130 	GUID ProviderId;
1131 	DWORD dwCatalogEntryId;
1132 	WSAPROTOCOLCHAIN ProtocolChain;
1133 	int iVersion;
1134 	int iAddressFamily;
1135 	int iMaxSockAddr;
1136 	int iMinSockAddr;
1137 	int iSocketType;
1138 	int iProtocol;
1139 	int iProtocolMaxOffset;
1140 	int iNetworkByteOrder;
1141 	int iSecurityScheme;
1142 	DWORD dwMessageSize;
1143 	DWORD dwProviderReserved;
1144 	CHAR[WSAPROTOCOL_LEN+1] szProtocol;
1145 }
1146 
1147 alias WSAPROTOCOL_INFOA* LPWSAPROTOCOL_INFOA;
1148 
1149 struct WSAPROTOCOL_INFOW {
1150 	DWORD dwServiceFlags1;
1151 	DWORD dwServiceFlags2;
1152 	DWORD dwServiceFlags3;
1153 	DWORD dwServiceFlags4;
1154 	DWORD dwProviderFlags;
1155 	GUID ProviderId;
1156 	DWORD dwCatalogEntryId;
1157 	WSAPROTOCOLCHAIN ProtocolChain;
1158 	int iVersion;
1159 	int iAddressFamily;
1160 	int iMaxSockAddr;
1161 	int iMinSockAddr;
1162 	int iSocketType;
1163 	int iProtocol;
1164 	int iProtocolMaxOffset;
1165 	int iNetworkByteOrder;
1166 	int iSecurityScheme;
1167 	DWORD dwMessageSize;
1168 	DWORD dwProviderReserved;
1169 	WCHAR[WSAPROTOCOL_LEN+1] szProtocol;
1170 }
1171 
1172 alias WSAPROTOCOL_INFOW* LPWSAPROTOCOL_INFOW;
1173 
1174 // TODO: Below fptr was defined as "CALLBACK" for linkage; is this right?
1175 extern(C) {
1176 	alias int function(LPWSABUF, LPWSABUF, LPQOS, LPQOS, LPWSABUF, LPWSABUF, GROUP *, DWORD) LPCONDITIONPROC;
1177 }
1178 
1179 extern(Windows) {
1180 	alias void function(DWORD, DWORD, LPWSAOVERLAPPED, DWORD) LPWSAOVERLAPPED_COMPLETION_ROUTINE;
1181 }
1182 
1183 version(Unicode) {
1184 	alias WSAPROTOCOL_INFOW WSAPROTOCOL_INFO;
1185 	alias LPWSAPROTOCOL_INFOW LPWSAPROTOCOL_INFO;
1186 } else {
1187 	alias WSAPROTOCOL_INFOA WSAPROTOCOL_INFO;
1188 	alias LPWSAPROTOCOL_INFOA LPWSAPROTOCOL_INFO;
1189 }
1190 
1191 /* Needed for XP & .NET Server function WSANSPIoctl.  */
1192 enum WSACOMPLETIONTYPE {
1193     NSP_NOTIFY_IMMEDIATELY = 0,
1194     NSP_NOTIFY_HWND,
1195     NSP_NOTIFY_EVENT,
1196     NSP_NOTIFY_PORT,
1197     NSP_NOTIFY_APC
1198 }
1199 
1200 alias WSACOMPLETIONTYPE* PWSACOMPLETIONTYPE, LPWSACOMPLETIONTYPE;
1201 
1202 struct WSACOMPLETION {
1203     WSACOMPLETIONTYPE Type;
1204     union WSACOMPLETION_PARAMETERS {
1205         struct WSACOMPLETION_WINDOWMESSAGE {
1206             HWND hWnd;
1207             UINT uMsg;
1208             WPARAM context;
1209         }
1210 		WSACOMPLETION_WINDOWMESSAGE WindowMessage;
1211         struct WSACOMPLETION_EVENT {
1212             LPWSAOVERLAPPED lpOverlapped;
1213         }
1214 		WSACOMPLETION_EVENT Event;
1215         struct WSACOMPLETION_APC {
1216             LPWSAOVERLAPPED lpOverlapped;
1217             LPWSAOVERLAPPED_COMPLETION_ROUTINE lpfnCompletionProc;
1218         }
1219 		WSACOMPLETION_APC Apc;
1220         struct WSACOMPLETION_PORT {
1221             LPWSAOVERLAPPED lpOverlapped;
1222             HANDLE hPort;
1223             ULONG_PTR Key;
1224         }
1225 		WSACOMPLETION_PORT Port;
1226     }
1227 	WSACOMPLETION_PARAMETERS Parameters;
1228 }
1229 
1230 alias WSACOMPLETION* PWSACOMPLETION, LPWSACOMPLETION;
1231 
1232 const int
1233 	PFL_MULTIPLE_PROTO_ENTRIES  = 0x00000001,
1234 	PFL_RECOMMENDED_PROTO_ENTRY = 0x00000002,
1235 	PFL_HIDDEN                  = 0x00000004,
1236 	PFL_MATCHES_PROTOCOL_ZERO   = 0x00000008;
1237 
1238 const int
1239 	XP1_CONNECTIONLESS           = 0x00000001,
1240 	XP1_GUARANTEED_DELIVERY      = 0x00000002,
1241 	XP1_GUARANTEED_ORDER         = 0x00000004,
1242 	XP1_MESSAGE_ORIENTED         = 0x00000008,
1243 	XP1_PSEUDO_STREAM            = 0x00000010,
1244 	XP1_GRACEFUL_CLOSE           = 0x00000020,
1245 	XP1_EXPEDITED_DATA           = 0x00000040,
1246 	XP1_CONNECT_DATA             = 0x00000080,
1247 	XP1_DISCONNECT_DATA          = 0x00000100,
1248 	XP1_SUPPORT_BROADCAST        = 0x00000200,
1249 	XP1_SUPPORT_MULTIPOINT       = 0x00000400,
1250 	XP1_MULTIPOINT_CONTROL_PLANE = 0x00000800,
1251 	XP1_MULTIPOINT_DATA_PLANE    = 0x00001000,
1252 	XP1_QOS_SUPPORTED            = 0x00002000,
1253 	XP1_INTERRUPT                = 0x00004000,
1254 	XP1_UNI_SEND                 = 0x00008000,
1255 	XP1_UNI_RECV                 = 0x00010000,
1256 	XP1_IFS_HANDLES              = 0x00020000,
1257 	XP1_PARTIAL_MESSAGE          = 0x00040000;
1258 
1259 enum : int {
1260 	BIGENDIAN    = 0x0000,
1261 	LITTLEENDIAN = 0x0001
1262 }
1263 
1264 const SECURITY_PROTOCOL_NONE = 0x0000;
1265 
1266 const JL_SENDER_ONLY = 0x01;
1267 const JL_RECEIVER_ONLY = 0x02;
1268 const JL_BOTH = 0x04;
1269 
1270 const WSA_FLAG_OVERLAPPED = 0x01;
1271 const WSA_FLAG_MULTIPOINT_C_ROOT = 0x02;
1272 const WSA_FLAG_MULTIPOINT_C_LEAF = 0x04;
1273 const WSA_FLAG_MULTIPOINT_D_ROOT = 0x08;
1274 const WSA_FLAG_MULTIPOINT_D_LEAF = 0x10;
1275 
1276 const int IOC_UNIX = 0x00000000;
1277 const int IOC_WS2 = 0x08000000;
1278 const int IOC_PROTOCOL = 0x10000000;
1279 const int IOC_VENDOR = 0x18000000;
1280 
1281 template _WSAIO(int x, int y) { const int _WSAIO = IOC_VOID | x | y; }
1282 template _WSAIOR(int x, int y) { const int _WSAIOR = IOC_OUT | x | y; }
1283 template _WSAIOW(int x, int y) { const int _WSAIOW = IOC_IN | x | y; }
1284 template _WSAIORW(int x, int y) { const int _WSAIORW = IOC_INOUT | x | y; }
1285 
1286 const int SIO_ASSOCIATE_HANDLE               = _WSAIOW!(IOC_WS2,1);
1287 const int SIO_ENABLE_CIRCULAR_QUEUEING       = _WSAIO!(IOC_WS2,2);
1288 const int SIO_FIND_ROUTE                     = _WSAIOR!(IOC_WS2,3);
1289 const int SIO_FLUSH                          = _WSAIO!(IOC_WS2,4);
1290 const int SIO_GET_BROADCAST_ADDRESS          = _WSAIOR!(IOC_WS2,5);
1291 const int SIO_GET_EXTENSION_FUNCTION_POINTER = _WSAIORW!(IOC_WS2,6);
1292 const int SIO_GET_QOS                        = _WSAIORW!(IOC_WS2,7);
1293 const int SIO_GET_GROUP_QOS                  = _WSAIORW!(IOC_WS2,8);
1294 const int SIO_MULTIPOINT_LOOPBACK            = _WSAIOW!(IOC_WS2,9);
1295 const int SIO_MULTICAST_SCOPE                = _WSAIOW!(IOC_WS2,10);
1296 const int SIO_SET_QOS                        = _WSAIOW!(IOC_WS2,11);
1297 const int SIO_SET_GROUP_QOS                  = _WSAIOW!(IOC_WS2,12);
1298 const int SIO_TRANSLATE_HANDLE               = _WSAIORW!(IOC_WS2,13);
1299 const int SIO_ROUTING_INTERFACE_QUERY        = _WSAIORW!(IOC_WS2,20);
1300 const int SIO_ROUTING_INTERFACE_CHANGE       = _WSAIOW!(IOC_WS2,21);
1301 const int SIO_ADDRESS_LIST_QUERY             = _WSAIOR!(IOC_WS2,22);
1302 const int SIO_ADDRESS_LIST_CHANGE            = _WSAIO!(IOC_WS2,23);
1303 const int SIO_QUERY_TARGET_PNP_HANDLE        = _WSAIOR!(IOC_WS2,24);
1304 const int SIO_NSP_NOTIFY_CHANGE              = _WSAIOW!(IOC_WS2,25);
1305 
1306 const int TH_NETDEV = 1;
1307 const int TH_TAPI   = 2;
1308 
1309 
1310 extern(Windows) {
1311 	SOCKET WSAAccept(SOCKET, SOCKADDR*, LPINT, LPCONDITIONPROC, DWORD);
1312 	INT WSAAddressToStringA(LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFOA, LPSTR, LPDWORD);
1313 	INT WSAAddressToStringW(LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFOW, LPWSTR, LPDWORD);
1314 	BOOL WSACloseEvent(WSAEVENT);
1315 	int WSAConnect(SOCKET, const(SOCKADDR)*, int, LPWSABUF, LPWSABUF, LPQOS, LPQOS);
1316 	WSAEVENT WSACreateEvent();
1317 	int WSADuplicateSocketA(SOCKET, DWORD, LPWSAPROTOCOL_INFOA);
1318 	int WSADuplicateSocketW(SOCKET, DWORD, LPWSAPROTOCOL_INFOW);
1319 	INT WSAEnumNameSpaceProvidersA(LPDWORD, LPWSANAMESPACE_INFOA);
1320 	INT WSAEnumNameSpaceProvidersW(LPDWORD, LPWSANAMESPACE_INFOW);
1321 	int WSAEnumNetworkEvents(SOCKET, WSAEVENT, LPWSANETWORKEVENTS);
1322 	int WSAEnumProtocolsA(LPINT, LPWSAPROTOCOL_INFOA, LPDWORD);
1323 	int WSAEnumProtocolsW(LPINT, LPWSAPROTOCOL_INFOW, LPDWORD);
1324 	int WSAEventSelect(SOCKET, WSAEVENT, int);
1325 	BOOL WSAGetOverlappedResult(SOCKET, LPWSAOVERLAPPED, LPDWORD, BOOL, LPDWORD);
1326 	BOOL WSAGetQOSByName(SOCKET, LPWSABUF, LPQOS);
1327 	INT WSAGetServiceClassInfoA(LPGUID, LPGUID, LPDWORD, LPWSASERVICECLASSINFOA);
1328 	INT WSAGetServiceClassInfoW(LPGUID, LPGUID, LPDWORD, LPWSASERVICECLASSINFOW);
1329 	INT WSAGetServiceClassNameByClassIdA(LPGUID, LPSTR, LPDWORD);
1330 	INT WSAGetServiceClassNameByClassIdW(LPGUID, LPWSTR, LPDWORD);
1331 	int WSAHtonl(SOCKET, uint, uint*);
1332 	int WSAHtons(SOCKET, ushort, ushort*);
1333 	INT WSAInstallServiceClassA(LPWSASERVICECLASSINFOA);
1334 	INT WSAInstallServiceClassW(LPWSASERVICECLASSINFOW);
1335 	int WSAIoctl(SOCKET, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
1336 	SOCKET WSAJoinLeaf(SOCKET, const(SOCKADDR)*, int, LPWSABUF, LPWSABUF, LPQOS, LPQOS, DWORD);
1337 	INT WSALookupServiceBeginA(LPWSAQUERYSETA, DWORD, LPHANDLE);
1338 	INT WSALookupServiceBeginW(LPWSAQUERYSETW lpqsRestrictions, DWORD, LPHANDLE);
1339 	INT WSALookupServiceNextA(HANDLE, DWORD, LPDWORD, LPWSAQUERYSETA);
1340 	INT WSALookupServiceNextW(HANDLE, DWORD, LPDWORD, LPWSAQUERYSETW);
1341 	INT WSALookupServiceEnd(HANDLE);
1342 	int WSANSPIoctl(HANDLE,DWORD,LPVOID,DWORD,LPVOID,DWORD,LPDWORD,LPWSACOMPLETION); /* XP or .NET Server */
1343 	int WSANtohl(SOCKET, uint, uint*);
1344 	int WSANtohs(SOCKET, ushort, ushort*);
1345 	int WSARecv(SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
1346 	int WSARecvDisconnect(SOCKET, LPWSABUF);
1347 	int WSARecvFrom(SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, SOCKADDR*, LPINT, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
1348 	INT WSARemoveServiceClass(LPGUID);
1349 	BOOL WSAResetEvent(WSAEVENT);
1350 	int WSASend(SOCKET, LPWSABUF, DWORD, LPDWORD, DWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
1351 	int WSASendDisconnect(SOCKET, LPWSABUF);
1352 	int WSASendTo(SOCKET, LPWSABUF, DWORD, LPDWORD, DWORD, const(SOCKADDR)*, int, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
1353 	BOOL WSASetEvent(WSAEVENT);
1354 	INT WSASetServiceA(LPWSAQUERYSETA, WSAESETSERVICEOP, DWORD); // NB: was declared with "WSAAPI" linkage
1355 	INT WSASetServiceW(LPWSAQUERYSETW, WSAESETSERVICEOP, DWORD);
1356 	SOCKET WSASocketA(int, int, int, LPWSAPROTOCOL_INFOA, GROUP, DWORD);
1357 	SOCKET WSASocketW(int, int, int, LPWSAPROTOCOL_INFOW, GROUP, DWORD);
1358 	INT WSAStringToAddressA(LPSTR, INT, LPWSAPROTOCOL_INFOA, LPSOCKADDR, LPINT);
1359 	INT WSAStringToAddressW(LPWSTR, INT, LPWSAPROTOCOL_INFOW, LPSOCKADDR, LPINT);
1360 	DWORD WSAWaitForMultipleEvents(DWORD, const(WSAEVENT)*, BOOL, DWORD, BOOL);
1361 
1362 	alias typeof(&WSAAccept) LPFN_WSAACCEPT;
1363 	alias typeof(&WSAAddressToStringA) LPFN_WSAADDRESSTOSTRINGA;
1364 	alias typeof(&WSAAddressToStringW) LPFN_WSAADDRESSTOSTRINGW;
1365 	alias typeof(&WSACloseEvent) LPFN_WSACLOSEEVENT;
1366 	alias typeof(&WSAConnect) LPFN_WSACONNECT;
1367 	alias typeof(&WSACreateEvent) LPFN_WSACREATEEVENT;
1368 	alias typeof(&WSADuplicateSocketA) LPFN_WSADUPLICATESOCKETA;
1369 	alias typeof(&WSADuplicateSocketW) LPFN_WSADUPLICATESOCKETW;
1370 	alias typeof(&WSAEnumNameSpaceProvidersA) LPFN_WSAENUMNAMESPACEPROVIDERSA;
1371 	alias typeof(&WSAEnumNameSpaceProvidersW) LPFN_WSAENUMNAMESPACEPROVIDERSW;
1372 	alias typeof(&WSAEnumNetworkEvents) LPFN_WSAENUMNETWORKEVENTS;
1373 	alias typeof(&WSAEnumProtocolsA) LPFN_WSAENUMPROTOCOLSA;
1374 	alias typeof(&WSAEnumProtocolsW) LPFN_WSAENUMPROTOCOLSW;
1375 	alias typeof(&WSAEventSelect) LPFN_WSAEVENTSELECT;
1376 	alias typeof(&WSAGetOverlappedResult) LPFN_WSAGETOVERLAPPEDRESULT;
1377 	alias typeof(&WSAGetQOSByName) LPFN_WSAGETQOSBYNAME;
1378 	alias typeof(&WSAGetServiceClassInfoA) LPFN_WSAGETSERVICECLASSINFOA;
1379 	alias typeof(&WSAGetServiceClassInfoW) LPFN_WSAGETSERVICECLASSINFOW;
1380 	alias typeof(&WSAGetServiceClassNameByClassIdA) LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDA;
1381 	alias typeof(&WSAGetServiceClassNameByClassIdW) LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDW;
1382 	alias typeof(&WSAHtonl) LPFN_WSAHTONL;
1383 	alias typeof(&WSAHtons) LPFN_WSAHTONS;
1384 	alias typeof(&WSAInstallServiceClassA) LPFN_WSAINSTALLSERVICECLASSA;
1385 	alias typeof(&WSAInstallServiceClassW) LPFN_WSAINSTALLSERVICECLASSW;
1386 	alias typeof(&WSAIoctl) LPFN_WSAIOCTL;
1387 	alias typeof(&WSAJoinLeaf) LPFN_WSAJOINLEAF;
1388 	alias typeof(&WSALookupServiceBeginA) LPFN_WSALOOKUPSERVICEBEGINA;
1389 	alias typeof(&WSALookupServiceBeginW) LPFN_WSALOOKUPSERVICEBEGINW;
1390 	alias typeof(&WSALookupServiceNextA) LPFN_WSALOOKUPSERVICENEXTA;
1391 	alias typeof(&WSALookupServiceNextW) LPFN_WSALOOKUPSERVICENEXTW;
1392 	alias typeof(&WSALookupServiceEnd) LPFN_WSALOOKUPSERVICEEND;
1393 	alias typeof(&WSANSPIoctl) LPFN_WSANSPIoctl;
1394 	alias typeof(&WSANtohl) LPFN_WSANTOHL;
1395 	alias typeof(&WSANtohs) LPFN_WSANTOHS;
1396 	alias typeof(&WSARecv) LPFN_WSARECV;
1397 	alias typeof(&WSARecvDisconnect) LPFN_WSARECVDISCONNECT;
1398 	alias typeof(&WSARecvFrom) LPFN_WSARECVFROM;
1399 	alias typeof(&WSARemoveServiceClass) LPFN_WSAREMOVESERVICECLASS;
1400 	alias typeof(&WSAResetEvent) LPFN_WSARESETEVENT;
1401 	alias typeof(&WSASend) LPFN_WSASEND;
1402 	alias typeof(&WSASendDisconnect) LPFN_WSASENDDISCONNECT;
1403 	alias typeof(&WSASendTo) LPFN_WSASENDTO;
1404 	alias typeof(&WSASetEvent) LPFN_WSASETEVENT;
1405 	alias typeof(&WSASetServiceA) LPFN_WSASETSERVICEA;
1406 	alias typeof(&WSASetServiceW) LPFN_WSASETSERVICEW;
1407 	alias typeof(&WSASocketA) LPFN_WSASOCKETA;
1408 	alias typeof(&WSASocketW) LPFN_WSASOCKETW;
1409 	alias typeof(&WSAStringToAddressA) LPFN_WSASTRINGTOADDRESSA;
1410 	alias typeof(&WSAStringToAddressW) LPFN_WSASTRINGTOADDRESSW;
1411 	alias typeof(&WSAWaitForMultipleEvents) LPFN_WSAWAITFORMULTIPLEEVENTS;
1412 }
1413 
1414 version(Unicode) {
1415 	alias LPFN_WSAADDRESSTOSTRINGW LPFN_WSAADDRESSTOSTRING;
1416 	alias LPFN_WSADUPLICATESOCKETW LPFN_WSADUPLICATESOCKET;
1417 	alias LPFN_WSAENUMNAMESPACEPROVIDERSW LPFN_WSAENUMNAMESPACEPROVIDERS;
1418 	alias LPFN_WSAENUMPROTOCOLSW LPFN_WSAENUMPROTOCOLS;
1419 	alias LPFN_WSAGETSERVICECLASSINFOW LPFN_WSAGETSERVICECLASSINFO;
1420 	alias LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDW LPFN_WSAGETSERVICECLASSNAMEBYCLASSID;
1421 	alias LPFN_WSAINSTALLSERVICECLASSW LPFN_WSAINSTALLSERVICECLASS;
1422 	alias LPFN_WSALOOKUPSERVICEBEGINW LPFN_WSALOOKUPSERVICEBEGIN;
1423 	alias LPFN_WSALOOKUPSERVICENEXTW LPFN_WSALOOKUPSERVICENEXT;
1424 	alias LPFN_WSASETSERVICEW LPFN_WSASETSERVICE;
1425 	alias LPFN_WSASOCKETW LPFN_WSASOCKET;
1426 	alias LPFN_WSASTRINGTOADDRESSW LPFN_WSASTRINGTOADDRESS;
1427 	alias WSAAddressToStringW WSAAddressToString;
1428 	alias WSADuplicateSocketW WSADuplicateSocket;
1429 	alias WSAEnumNameSpaceProvidersW WSAEnumNameSpaceProviders;
1430 	alias WSAEnumProtocolsW WSAEnumProtocols;
1431 	alias WSAGetServiceClassInfoW WSAGetServiceClassInfo;
1432 	alias WSAGetServiceClassNameByClassIdW WSAGetServiceClassNameByClassId;
1433 	alias WSASetServiceW WSASetService;
1434 	alias WSASocketW WSASocket;
1435 	alias WSAStringToAddressW WSAStringToAddress;
1436 	alias WSALookupServiceBeginW WSALookupServiceBegin;
1437 	alias WSALookupServiceNextW WSALookupServiceNext;
1438 	alias WSAInstallServiceClassW WSAInstallServiceClass;
1439 } else {
1440 	alias LPFN_WSAADDRESSTOSTRINGA LPFN_WSAADDRESSTOSTRING;
1441 	alias LPFN_WSADUPLICATESOCKETW LPFN_WSADUPLICATESOCKET;
1442 	alias LPFN_WSAENUMNAMESPACEPROVIDERSA LPFN_WSAENUMNAMESPACEPROVIDERS;
1443 	alias LPFN_WSAENUMPROTOCOLSA LPFN_WSAENUMPROTOCOLS;
1444 	alias LPFN_WSAGETSERVICECLASSINFOA LPFN_WSAGETSERVICECLASSINFO;
1445 	alias LPFN_WSAGETSERVICECLASSNAMEBYCLASSIDA LPFN_WSAGETSERVICECLASSNAMEBYCLASSID;
1446 	alias LPFN_WSAINSTALLSERVICECLASSA LPFN_WSAINSTALLSERVICECLASS;
1447 	alias LPFN_WSALOOKUPSERVICEBEGINA LPFN_WSALOOKUPSERVICEBEGIN;
1448 	alias LPFN_WSALOOKUPSERVICENEXTA LPFN_WSALOOKUPSERVICENEXT;
1449 	alias LPFN_WSASETSERVICEA LPFN_WSASETSERVICE;
1450 	alias LPFN_WSASOCKETA LPFN_WSASOCKET;
1451 	alias LPFN_WSASTRINGTOADDRESSA LPFN_WSASTRINGTOADDRESS;
1452 	alias WSAAddressToStringA WSAAddressToString;
1453 	alias WSADuplicateSocketA WSADuplicateSocket;
1454 	alias WSAEnumNameSpaceProvidersA WSAEnumNameSpaceProviders;
1455 	alias WSAEnumProtocolsA WSAEnumProtocols;
1456 	alias WSAGetServiceClassInfoA WSAGetServiceClassInfo;
1457 	alias WSAGetServiceClassNameByClassIdA WSAGetServiceClassNameByClassId;
1458 	alias WSAInstallServiceClassA WSAInstallServiceClass;
1459 	alias WSALookupServiceBeginA WSALookupServiceBegin;
1460 	alias WSALookupServiceNextA WSALookupServiceNext;
1461 	alias WSASocketA WSASocket;
1462 	alias WSAStringToAddressA WSAStringToAddress;
1463 	alias WSASetServiceA WSASetService;
1464 }