Mercurial > projects > ddbg_continued

comparison win32/winsock2.d @ 1:4a9dcbd9e54f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
-files of 0.13 beta -fixes so that it now compiles with the current dmd version
author marton@basel.hu
date Tue, 05 Apr 2011 20:44:01 +0200
parents
children
comparison
equal deleted inserted replaced
0:586e4a649642 1:4a9dcbd9e54f
1 /***********************************************************************\
2 * winsock2.d *
3 * *
4 * Windows API header module *
5 * *
6 * Translated from MinGW Windows headers *
7 * by Daniel Keep *
8 \***********************************************************************/
9 module win32.winsock2;
10 pragma(lib, "Ws2_32.lib");
11
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 win32.winsock2 with Win32_Winsock1 defined.");
32 static assert(false);
33 }
34
35 import win32.winbase;
36 import win32.windef;
37 import win32.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(inout 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 private template _IO(char x, ubyte y) {
168 const DWORD _IO = IOC_VOID | (cast(ubyte)x<<8) | y;
169 }
170
171 private 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 private 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, SOCKADDR*, int);
614 int closesocket(SOCKET);
615 int connect(SOCKET, 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(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, ubyte*, int, int);
625 int sendto(SOCKET, ubyte*, int, int, SOCKADDR*, int);
626 int setsockopt(SOCKET, int, int, 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(char*, int, int);
652 HOSTENT* gethostbyname(char*);
653 SERVENT* getservbyport(int, char*);
654 SERVENT* getservbyname(char*, char*);
655 PROTOENT* getprotobynumber(int);
656 PROTOENT* getprotobyname(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, char*, char*, char*, int);
701 HANDLE WSAAsyncGetServByPort(HWND, u_int, int, char*, char*, int);
702 HANDLE WSAAsyncGetProtoByName(HWND, u_int, char*, char*, int);
703 HANDLE WSAAsyncGetProtoByNumber(HWND, u_int, int, char*, int);
704 HANDLE WSAAsyncGetHostByName(HWND, u_int, char*, char*, int);
705 HANDLE WSAAsyncGetHostByAddr(HWND, u_int, 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*, 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 alias HANDLE WSAEVENT;
773 alias LPHANDLE LPWSAEVENT;
774 alias OVERLAPPED WSAOVERLAPPED;
775 alias OVERLAPPED* LPWSAOVERLAPPED;
776
777 private import win32.winerror;
778 private import win32.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)null;
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 win32.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, 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, 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, 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, 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 }