![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to net_wins.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / win32|
Return to net_wins.c CVS log | Up to [Quake II] / quake2 / win32 |
1.1 root 1: // net_wins.c
2:
3: #include "winsock.h"
4: #include "wsipx.h"
5: #include "../qcommon/qcommon.h"
6:
7: #define MAX_LOOPBACK 4
8:
9: typedef struct
10: {
11: byte data[MAX_MSGLEN];
12: int datalen;
13: } loopmsg_t;
14:
15: typedef struct
16: {
17: loopmsg_t msgs[MAX_LOOPBACK];
18: int get, send;
19: } loopback_t;
20:
21:
22: cvar_t *net_shownet;
23: static cvar_t *noudp;
24: static cvar_t *noipx;
25:
26: loopback_t loopbacks[2];
27: int ip_sockets[2];
28: int ipx_sockets[2];
29:
30: char *NET_ErrorString (void);
31:
32: //=============================================================================
33:
34: void NetadrToSockadr (netadr_t *a, struct sockaddr *s)
35: {
36: memset (s, 0, sizeof(*s));
37:
38: if (a->type == NA_BROADCAST)
39: {
40: ((struct sockaddr_in *)s)->sin_family = AF_INET;
41: ((struct sockaddr_in *)s)->sin_port = a->port;
42: ((struct sockaddr_in *)s)->sin_addr.s_addr = INADDR_BROADCAST;
43: }
44: else if (a->type == NA_IP)
45: {
46: ((struct sockaddr_in *)s)->sin_family = AF_INET;
47: ((struct sockaddr_in *)s)->sin_addr.s_addr = *(int *)&a->ip;
48: ((struct sockaddr_in *)s)->sin_port = a->port;
49: }
50: else if (a->type == NA_IPX)
51: {
52: ((struct sockaddr_ipx *)s)->sa_family = AF_IPX;
53: memcpy(((struct sockaddr_ipx *)s)->sa_netnum, &a->ipx[0], 4);
54: memcpy(((struct sockaddr_ipx *)s)->sa_nodenum, &a->ipx[4], 6);
55: ((struct sockaddr_ipx *)s)->sa_socket = a->port;
56: }
57: else if (a->type == NA_BROADCAST_IPX)
58: {
59: ((struct sockaddr_ipx *)s)->sa_family = AF_IPX;
60: memset(((struct sockaddr_ipx *)s)->sa_netnum, 0, 4);
61: memset(((struct sockaddr_ipx *)s)->sa_nodenum, 0xff, 6);
62: ((struct sockaddr_ipx *)s)->sa_socket = a->port;
63: }
64: }
65:
66: void SockadrToNetadr (struct sockaddr *s, netadr_t *a)
67: {
68: if (s->sa_family == AF_INET)
69: {
70: a->type = NA_IP;
71: *(int *)&a->ip = ((struct sockaddr_in *)s)->sin_addr.s_addr;
72: a->port = ((struct sockaddr_in *)s)->sin_port;
73: }
74: else if (s->sa_family == AF_IPX)
75: {
76: a->type = NA_IPX;
77: memcpy(&a->ipx[0], ((struct sockaddr_ipx *)s)->sa_netnum, 4);
78: memcpy(&a->ipx[4], ((struct sockaddr_ipx *)s)->sa_nodenum, 6);
79: a->port = ((struct sockaddr_ipx *)s)->sa_socket;
80: }
81: }
82:
83:
84: qboolean NET_CompareAdr (netadr_t a, netadr_t b)
85: {
86: if (a.type != b.type)
87: return false;
88:
89: if (a.type == NA_LOOPBACK)
90: return TRUE;
91:
92: if (a.type == NA_IP)
93: {
94: if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3] && a.port == b.port)
95: return true;
96: return false;
97: }
98:
99: if (a.type == NA_IPX)
100: {
101: if ((memcmp(a.ipx, b.ipx, 10) == 0) && a.port == b.port)
102: return true;
103: return false;
104: }
105: }
106:
107: /*
108: ===================
109: NET_CompareBaseAdr
110:
111: Compares without the port
112: ===================
113: */
114: qboolean NET_CompareBaseAdr (netadr_t a, netadr_t b)
115: {
116: if (a.type != b.type)
117: return false;
118:
119: if (a.type == NA_LOOPBACK)
120: return TRUE;
121:
122: if (a.type == NA_IP)
123: {
124: if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3])
125: return true;
126: return false;
127: }
128:
129: if (a.type == NA_IPX)
130: {
131: if ((memcmp(a.ipx, b.ipx, 10) == 0))
132: return true;
133: return false;
134: }
135: }
136:
137: char *NET_AdrToString (netadr_t a)
138: {
139: static char s[64];
140:
141: if (a.type == NA_LOOPBACK)
142: Com_sprintf (s, sizeof(s), "loopback");
143: else if (a.type == NA_IP)
144: Com_sprintf (s, sizeof(s), "%i.%i.%i.%i:%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3], ntohs(a.port));
145: else
146: Com_sprintf (s, sizeof(s), "%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x:%i", a.ipx[0], a.ipx[1], a.ipx[2], a.ipx[3], a.ipx[4], a.ipx[5], a.ipx[6], a.ipx[7], a.ipx[8], a.ipx[9], ntohs(a.port));
147:
148: return s;
149: }
150:
151:
152: /*
153: =============
154: NET_StringToAdr
155:
156: localhost
157: idnewt
158: idnewt:28000
159: 192.246.40.70
160: 192.246.40.70:28000
161: =============
162: */
163: #define DO(src,dest) \
164: copy[0] = s[src]; \
165: copy[1] = s[src + 1]; \
166: sscanf (copy, "%x", &val); \
167: ((struct sockaddr_ipx *)sadr)->dest = val
168:
169: qboolean NET_StringToSockaddr (char *s, struct sockaddr *sadr)
170: {
171: struct hostent *h;
172: char *colon;
173: int val;
174: char copy[128];
175:
176: memset (sadr, 0, sizeof(*sadr));
177:
178: if ((strlen(s) >= 23) && (s[8] == ':') && (s[21] == ':')) // check for an IPX address
179: {
180: ((struct sockaddr_ipx *)sadr)->sa_family = AF_IPX;
181: copy[2] = 0;
182: DO(0, sa_netnum[0]);
183: DO(2, sa_netnum[1]);
184: DO(4, sa_netnum[2]);
185: DO(6, sa_netnum[3]);
186: DO(9, sa_nodenum[0]);
187: DO(11, sa_nodenum[1]);
188: DO(13, sa_nodenum[2]);
189: DO(15, sa_nodenum[3]);
190: DO(17, sa_nodenum[4]);
191: DO(19, sa_nodenum[5]);
192: sscanf (&s[22], "%u", &val);
193: ((struct sockaddr_ipx *)sadr)->sa_socket = htons((unsigned short)val);
194: }
195: else
196: {
197: ((struct sockaddr_in *)sadr)->sin_family = AF_INET;
198:
199: ((struct sockaddr_in *)sadr)->sin_port = 0;
200:
201: strcpy (copy, s);
202: // strip off a trailing :port if present
203: for (colon = copy ; *colon ; colon++)
204: if (*colon == ':')
205: {
206: *colon = 0;
207: ((struct sockaddr_in *)sadr)->sin_port = htons((short)atoi(colon+1));
208: }
209:
210: if (copy[0] >= '0' && copy[0] <= '9')
211: {
212: *(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(copy);
213: }
214: else
215: {
216: if (! (h = gethostbyname(copy)) )
217: return 0;
218: *(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0];
219: }
220: }
221:
222: return true;
223: }
224:
225: #undef DO
226:
227: /*
228: =============
229: NET_StringToAdr
230:
231: localhost
232: idnewt
233: idnewt:28000
234: 192.246.40.70
235: 192.246.40.70:28000
236: =============
237: */
238: qboolean NET_StringToAdr (char *s, netadr_t *a)
239: {
240: struct sockaddr sadr;
241:
242: if (!strcmp (s, "localhost"))
243: {
244: memset (a, 0, sizeof(*a));
245: a->type = NA_LOOPBACK;
246: return true;
247: }
248:
249: if (!NET_StringToSockaddr (s, &sadr))
250: return false;
251:
252: SockadrToNetadr (&sadr, a);
253:
254: return true;
255: }
256:
257:
258: qboolean NET_IsLocalAddress (netadr_t adr)
259: {
260: return adr.type == NA_LOOPBACK;
261: }
262:
263: /*
264: =============================================================================
265:
266: LOOPBACK BUFFERS FOR LOCAL PLAYER
267:
268: =============================================================================
269: */
270:
271: qboolean NET_GetLoopPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
272: {
273: int i;
274: loopback_t *loop;
275:
276: loop = &loopbacks[sock];
277:
278: if (loop->send - loop->get > MAX_LOOPBACK)
279: loop->get = loop->send - MAX_LOOPBACK;
280:
281: if (loop->get >= loop->send)
282: return false;
283:
284: i = loop->get & (MAX_LOOPBACK-1);
285: loop->get++;
286:
287: memcpy (net_message->data, loop->msgs[i].data, loop->msgs[i].datalen);
288: net_message->cursize = loop->msgs[i].datalen;
289: memset (net_from, 0, sizeof(*net_from));
290: net_from->type = NA_LOOPBACK;
291: return true;
292:
293: }
294:
295:
296: void NET_SendLoopPacket (netsrc_t sock, int length, void *data, netadr_t to)
297: {
298: int i;
299: loopback_t *loop;
300:
301: loop = &loopbacks[sock^1];
302:
303: i = loop->send & (MAX_LOOPBACK-1);
304: loop->send++;
305:
306: memcpy (loop->msgs[i].data, data, length);
307: loop->msgs[i].datalen = length;
308: }
309:
310: //=============================================================================
311:
312: qboolean NET_GetPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
313: {
314: int ret;
315: struct sockaddr from;
316: int fromlen;
317: int net_socket;
318: int protocol;
319: int err;
320:
321: if (NET_GetLoopPacket (sock, net_from, net_message))
322: return true;
323:
324: for (protocol = 0 ; protocol < 2 ; protocol++)
325: {
326: if (protocol == 0)
327: net_socket = ip_sockets[sock];
328: else
329: net_socket = ipx_sockets[sock];
330:
331: if (!net_socket)
332: continue;
333:
334: fromlen = sizeof(from);
335: ret = recvfrom (net_socket, net_message->data, net_message->maxsize
336: , 0, (struct sockaddr *)&from, &fromlen);
337: if (ret == -1)
338: {
339: err = WSAGetLastError();
340:
341: if (err == WSAEWOULDBLOCK)
342: continue;
343: if (dedicated->value) // let dedicated servers continue after errors
344: Com_Printf ("NET_GetPacket: %s", NET_ErrorString());
345: else
346: Com_Error (ERR_DROP, "NET_GetPacket: %s", NET_ErrorString());
347: continue;
348: }
349:
350: SockadrToNetadr (&from, net_from);
351:
352: if (ret == net_message->maxsize)
353: {
354: Com_Printf ("Oversize packet from %s\n", NET_AdrToString (*net_from));
355: continue;
356: }
357:
358: net_message->cursize = ret;
359: return true;
360: }
361:
362: return false;
363: }
364:
365: //=============================================================================
366:
367: void NET_SendPacket (netsrc_t sock, int length, void *data, netadr_t to)
368: {
369: int ret;
370: struct sockaddr addr;
371: int net_socket;
372:
373: if ( to.type == NA_LOOPBACK )
374: {
375: NET_SendLoopPacket (sock, length, data, to);
376: return;
377: }
378:
379: if (to.type == NA_BROADCAST)
380: {
381: net_socket = ip_sockets[sock];
382: if (!net_socket)
383: return;
384: }
385: else if (to.type == NA_IP)
386: {
387: net_socket = ip_sockets[sock];
388: if (!net_socket)
389: return;
390: }
391: else if (to.type == NA_IPX)
392: {
393: net_socket = ipx_sockets[sock];
394: if (!net_socket)
395: return;
396: }
397: else if (to.type == NA_BROADCAST_IPX)
398: {
399: net_socket = ipx_sockets[sock];
400: if (!net_socket)
401: return;
402: }
403: else
404: Com_Error (ERR_FATAL, "NET_SendPacket: bad address type");
405:
406: NetadrToSockadr (&to, &addr);
407:
408: ret = sendto (net_socket, data, length, 0, &addr, sizeof(addr) );
409: if (ret == -1)
410: {
411: int err = WSAGetLastError();
412:
413: // wouldblock is silent
414: if (err == WSAEWOULDBLOCK)
415: return;
416:
417: // some PPP links dont allow broadcasts
418: if ((err == WSAEADDRNOTAVAIL) && ((to.type == NA_BROADCAST) || (to.type == NA_BROADCAST_IPX)))
419: return;
420:
421: if (dedicated->value) // let dedicated servers continue after errors
422: {
423: Com_Printf ("NET_SendPacket ERROR: %s\n", NET_ErrorString());
424: }
425: else
426: {
427: if (err == WSAEADDRNOTAVAIL)
428: {
429: Com_DPrintf ("NET_SendPacket Warning: %s : %s\n", NET_ErrorString(), NET_AdrToString (to));
430: }
431: else
432: {
433: Com_Error (ERR_DROP, "NET_SendPacket ERROR: %s\n", NET_ErrorString());
434: }
435: }
436: }
437: }
438:
439:
440: //=============================================================================
441:
442:
443: /*
444: ====================
445: NET_Socket
446: ====================
447: */
448: int NET_IPSocket (char *net_interface, int port)
449: {
450: int newsocket;
451: struct sockaddr_in address;
452: qboolean _true = true;
453: int i = 1;
454: int err;
455:
456: if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
457: {
458: err = WSAGetLastError();
459: if (err != WSAEAFNOSUPPORT)
460: Com_Printf ("WARNING: UDP_OpenSocket: socket: %s", NET_ErrorString());
461: return 0;
462: }
463:
464: // make it non-blocking
465: if (ioctlsocket (newsocket, FIONBIO, &_true) == -1)
466: {
467: Com_Printf ("WARNING: UDP_OpenSocket: ioctl FIONBIO: %s\n", NET_ErrorString());
468: return 0;
469: }
470:
471: // make it broadcast capable
472: if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1)
473: {
474: Com_Printf ("WARNING: UDP_OpenSocket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString());
475: return 0;
476: }
477:
478: if (!net_interface || !net_interface[0] || !stricmp(net_interface, "localhost"))
479: address.sin_addr.s_addr = INADDR_ANY;
480: else
481: NET_StringToSockaddr (net_interface, (struct sockaddr *)&address);
482:
483: if (port == PORT_ANY)
484: address.sin_port = 0;
485: else
486: address.sin_port = htons((short)port);
487:
488: address.sin_family = AF_INET;
489:
490: if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
491: {
492: Com_Printf ("WARNING: UDP_OpenSocket: bind: %s\n", NET_ErrorString());
493: closesocket (newsocket);
494: return 0;
495: }
496:
497: return newsocket;
498: }
499:
500:
501: /*
502: ====================
503: NET_OpenIP
504: ====================
505: */
506: void NET_OpenIP (void)
507: {
508: cvar_t *ip;
509: int port;
510: int dedicated;
511:
512: ip = Cvar_Get ("ip", "localhost", CVAR_NOSET);
513:
514: dedicated = Cvar_VariableValue ("dedicated");
515:
516: if (!ip_sockets[NS_SERVER])
517: {
518: port = Cvar_Get("ip_hostport", "0", CVAR_NOSET)->value;
519: if (!port)
520: {
521: port = Cvar_Get("hostport", "0", CVAR_NOSET)->value;
522: if (!port)
523: {
524: port = Cvar_Get("port", va("%i", PORT_SERVER), CVAR_NOSET)->value;
525: }
526: }
527: ip_sockets[NS_SERVER] = NET_IPSocket (ip->string, port);
528: if (!ip_sockets[NS_SERVER] && dedicated)
529: Com_Error (ERR_FATAL, "Couldn't allocate dedicated server IP port");
530: }
531:
532:
533: // dedicated servers don't need client ports
534: if (dedicated)
535: return;
536:
537: if (!ip_sockets[NS_CLIENT])
538: {
539: port = Cvar_Get("ip_clientport", "0", CVAR_NOSET)->value;
540: if (!port)
541: {
542: port = Cvar_Get("clientport", va("%i", PORT_CLIENT), CVAR_NOSET)->value;
543: if (!port)
544: port = PORT_ANY;
545: }
546: ip_sockets[NS_CLIENT] = NET_IPSocket (ip->string, port);
547: if (!ip_sockets[NS_CLIENT])
548: ip_sockets[NS_CLIENT] = NET_IPSocket (ip->string, PORT_ANY);
549: }
550: }
551:
552:
553: /*
554: ====================
555: IPX_Socket
556: ====================
557: */
558: int NET_IPXSocket (int port)
559: {
560: int newsocket;
561: struct sockaddr_ipx address;
562: int _true = 1;
563: int err;
564:
565: if ((newsocket = socket (PF_IPX, SOCK_DGRAM, NSPROTO_IPX)) == -1)
566: {
567: err = WSAGetLastError();
568: if (err != WSAEAFNOSUPPORT)
569: Com_Printf ("WARNING: IPX_Socket: socket: %s\n", NET_ErrorString());
570: return 0;
571: }
572:
573: // make it non-blocking
574: if (ioctlsocket (newsocket, FIONBIO, &_true) == -1)
575: {
576: Com_Printf ("WARNING: IPX_Socket: ioctl FIONBIO: %s\n", NET_ErrorString());
577: return 0;
578: }
579:
580: // make it broadcast capable
581: if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&_true, sizeof(_true)) == -1)
582: {
583: Com_Printf ("WARNING: IPX_Socket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString());
584: return 0;
585: }
586:
587: address.sa_family = AF_IPX;
588: memset (address.sa_netnum, 0, 4);
589: memset (address.sa_nodenum, 0, 6);
590: if (port == PORT_ANY)
591: address.sa_socket = 0;
592: else
593: address.sa_socket = htons((short)port);
594:
595: if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
596: {
597: Com_Printf ("WARNING: IPX_Socket: bind: %s\n", NET_ErrorString());
598: closesocket (newsocket);
599: return 0;
600: }
601:
602: return newsocket;
603: }
604:
605:
606: /*
607: ====================
608: NET_OpenIPX
609: ====================
610: */
611: void NET_OpenIPX (void)
612: {
613: int port;
614: int dedicated;
615:
616: dedicated = Cvar_VariableValue ("dedicated");
617:
618: if (!ipx_sockets[NS_SERVER])
619: {
620: port = Cvar_Get("ipx_hostport", "0", CVAR_NOSET)->value;
621: if (!port)
622: {
623: port = Cvar_Get("hostport", "0", CVAR_NOSET)->value;
624: if (!port)
625: {
626: port = Cvar_Get("port", va("%i", PORT_SERVER), CVAR_NOSET)->value;
627: }
628: }
629: ipx_sockets[NS_SERVER] = NET_IPXSocket (port);
630: }
631:
632: // dedicated servers don't need client ports
633: if (dedicated)
634: return;
635:
636: if (!ipx_sockets[NS_CLIENT])
637: {
638: port = Cvar_Get("ipx_clientport", "0", CVAR_NOSET)->value;
639: if (!port)
640: {
641: port = Cvar_Get("clientport", va("%i", PORT_CLIENT), CVAR_NOSET)->value;
642: if (!port)
643: port = PORT_ANY;
644: }
645: ipx_sockets[NS_CLIENT] = NET_IPXSocket (port);
646: if (!ipx_sockets[NS_CLIENT])
647: ipx_sockets[NS_CLIENT] = NET_IPXSocket (PORT_ANY);
648: }
649: }
650:
651:
652: /*
653: ====================
654: NET_Config
655:
656: A single player game will only use the loopback code
657: ====================
658: */
659: void NET_Config (qboolean multiplayer)
660: {
661: int i;
662: static qboolean old_config;
663:
664: if (old_config == multiplayer)
665: return;
666:
667: old_config = multiplayer;
668:
669: if (!multiplayer)
670: { // shut down any existing sockets
671: for (i=0 ; i<2 ; i++)
672: {
673: if (ip_sockets[i])
674: {
675: closesocket (ip_sockets[i]);
676: ip_sockets[i] = 0;
677: }
678: if (ipx_sockets[i])
679: {
680: closesocket (ipx_sockets[i]);
681: ipx_sockets[i] = 0;
682: }
683: }
684: }
685: else
686: { // open sockets
687: if (! noudp->value)
688: NET_OpenIP ();
689: if (! noipx->value)
690: NET_OpenIPX ();
691: }
692: }
693:
1.1.1.2 ! root 694: // sleeps msec or until net socket is ready
! 695: void NET_Sleep(int msec)
! 696: {
! 697: struct timeval timeout;
! 698: fd_set fdset;
! 699: extern cvar_t *dedicated;
! 700: int i;
! 701:
! 702: if (!dedicated || !dedicated->value)
! 703: return; // we're not a server, just run full speed
! 704:
! 705: FD_ZERO(&fdset);
! 706: i = 0;
! 707: if (ip_sockets[NS_SERVER]) {
! 708: FD_SET(ip_sockets[NS_SERVER], &fdset); // network socket
! 709: i = ip_sockets[NS_SERVER];
! 710: }
! 711: if (ipx_sockets[NS_SERVER]) {
! 712: FD_SET(ipx_sockets[NS_SERVER], &fdset); // network socket
! 713: if (ipx_sockets[NS_SERVER] > i)
! 714: i = ipx_sockets[NS_SERVER];
! 715: }
! 716: timeout.tv_sec = msec/1000;
! 717: timeout.tv_usec = (msec%1000)*1000;
! 718: select(i+1, &fdset, NULL, NULL, &timeout);
! 719: }
1.1 root 720:
721: //===================================================================
722:
723:
724: static WSADATA winsockdata;
725:
726: /*
727: ====================
728: NET_Init
729: ====================
730: */
731: void NET_Init (void)
732: {
733: WORD wVersionRequested;
734: int r;
735:
736: wVersionRequested = MAKEWORD(1, 1);
737:
738: r = WSAStartup (MAKEWORD(1, 1), &winsockdata);
739:
740: if (r)
741: Com_Error (ERR_FATAL,"Winsock initialization failed.");
742:
743: Com_Printf("Winsock Initialized\n");
744:
745: noudp = Cvar_Get ("noudp", "0", CVAR_NOSET);
746: noipx = Cvar_Get ("noipx", "0", CVAR_NOSET);
747:
748: net_shownet = Cvar_Get ("net_shownet", "0", 0);
749: }
750:
751:
752: /*
753: ====================
754: NET_Shutdown
755: ====================
756: */
757: void NET_Shutdown (void)
758: {
759: NET_Config (false); // close sockets
760:
761: WSACleanup ();
762: }
763:
764:
765: /*
766: ====================
767: NET_ErrorString
768: ====================
769: */
770: char *NET_ErrorString (void)
771: {
772: int code;
773:
774: code = WSAGetLastError ();
775: switch (code)
776: {
777: case WSAEINTR: return "WSAEINTR";
778: case WSAEBADF: return "WSAEBADF";
779: case WSAEACCES: return "WSAEACCES";
780: case WSAEDISCON: return "WSAEDISCON";
781: case WSAEFAULT: return "WSAEFAULT";
782: case WSAEINVAL: return "WSAEINVAL";
783: case WSAEMFILE: return "WSAEMFILE";
784: case WSAEWOULDBLOCK: return "WSAEWOULDBLOCK";
785: case WSAEINPROGRESS: return "WSAEINPROGRESS";
786: case WSAEALREADY: return "WSAEALREADY";
787: case WSAENOTSOCK: return "WSAENOTSOCK";
788: case WSAEDESTADDRREQ: return "WSAEDESTADDRREQ";
789: case WSAEMSGSIZE: return "WSAEMSGSIZE";
790: case WSAEPROTOTYPE: return "WSAEPROTOTYPE";
791: case WSAENOPROTOOPT: return "WSAENOPROTOOPT";
792: case WSAEPROTONOSUPPORT: return "WSAEPROTONOSUPPORT";
793: case WSAESOCKTNOSUPPORT: return "WSAESOCKTNOSUPPORT";
794: case WSAEOPNOTSUPP: return "WSAEOPNOTSUPP";
795: case WSAEPFNOSUPPORT: return "WSAEPFNOSUPPORT";
796: case WSAEAFNOSUPPORT: return "WSAEAFNOSUPPORT";
797: case WSAEADDRINUSE: return "WSAEADDRINUSE";
798: case WSAEADDRNOTAVAIL: return "WSAEADDRNOTAVAIL";
799: case WSAENETDOWN: return "WSAENETDOWN";
800: case WSAENETUNREACH: return "WSAENETUNREACH";
801: case WSAENETRESET: return "WSAENETRESET";
802: case WSAECONNABORTED: return "WSWSAECONNABORTEDAEINTR";
803: case WSAECONNRESET: return "WSAECONNRESET";
804: case WSAENOBUFS: return "WSAENOBUFS";
805: case WSAEISCONN: return "WSAEISCONN";
806: case WSAENOTCONN: return "WSAENOTCONN";
807: case WSAESHUTDOWN: return "WSAESHUTDOWN";
808: case WSAETOOMANYREFS: return "WSAETOOMANYREFS";
809: case WSAETIMEDOUT: return "WSAETIMEDOUT";
810: case WSAECONNREFUSED: return "WSAECONNREFUSED";
811: case WSAELOOP: return "WSAELOOP";
812: case WSAENAMETOOLONG: return "WSAENAMETOOLONG";
813: case WSAEHOSTDOWN: return "WSAEHOSTDOWN";
814: case WSASYSNOTREADY: return "WSASYSNOTREADY";
815: case WSAVERNOTSUPPORTED: return "WSAVERNOTSUPPORTED";
816: case WSANOTINITIALISED: return "WSANOTINITIALISED";
817: case WSAHOST_NOT_FOUND: return "WSAHOST_NOT_FOUND";
818: case WSATRY_AGAIN: return "WSATRY_AGAIN";
819: case WSANO_RECOVERY: return "WSANO_RECOVERY";
820: case WSANO_DATA: return "WSANO_DATA";
821: default: return "NO ERROR";
822: }
823: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.