Add GL_ExtensionSupported in vid_null.c because vid_shared.c relies on
[xonotic/darkplaces.git] / lhnet.c
1
2 // Written by Forest Hale 2003-06-15 and placed into public domain.
3
4 #ifdef WIN32
5 #ifdef _MSC_VER
6 #pragma comment(lib, "ws2_32.lib")
7 #endif
8 # ifndef NOSUPPORTIPV6
9 // Windows XP or higher is required for getaddrinfo, but the inclusion of wspiapi provides fallbacks for older versions
10 # define _WIN32_WINNT 0x0501
11 # endif
12 # include <winsock2.h>
13 # include <ws2tcpip.h>
14 # ifdef USE_WSPIAPI_H
15 #  include <wspiapi.h>
16 # endif
17 #endif
18
19 #ifndef STANDALONETEST
20 #include "quakedef.h"
21 #endif
22
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <time.h>
26 #include <string.h>
27 #ifndef WIN32
28 #include <unistd.h>
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #include <sys/ioctl.h>
32 #include <errno.h>
33 #include <netdb.h>
34 #include <netinet/in.h>
35 #include <arpa/inet.h>
36 #ifndef NOSUPPORTIPV6
37 #include <net/if.h>
38 #endif
39 #endif
40
41 #ifdef __MORPHOS__
42 #include <proto/socket.h>
43 #endif
44
45 // for Z_Malloc/Z_Free in quake
46 #ifndef STANDALONETEST
47 #include "zone.h"
48 #include "sys.h"
49 #include "netconn.h"
50 #else
51 #define Con_Print printf
52 #define Con_Printf printf
53 #define Z_Malloc malloc
54 #define Z_Free free
55 #endif
56
57 #include "lhnet.h"
58
59 #if defined(WIN32)
60 // as of Visual Studio 2015, EWOULDBLOCK and ECONNREFUSED are real things, with different values than we want when talking to WinSock, so we have to undef them here or change the rest of the code.
61 #undef EWOULDBLOCK
62 #undef ECONNREFUSED
63 #define EWOULDBLOCK WSAEWOULDBLOCK
64 #define ECONNREFUSED WSAECONNREFUSED
65
66 #define SOCKETERRNO WSAGetLastError()
67
68 #define IOC_VENDOR 0x18000000
69 #define _WSAIOW(x,y) (IOC_IN|(x)|(y))
70 #define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR,12)
71
72 #define SOCKLEN_T int
73 #elif defined(__MORPHOS__)
74 #define ioctlsocket IoctlSocket
75 #define closesocket CloseSocket
76 #define SOCKETERRNO Errno()
77
78 #define SOCKLEN_T int
79 #else
80 #define ioctlsocket ioctl
81 #define closesocket close
82 #define SOCKETERRNO errno
83
84 #define SOCKLEN_T socklen_t
85 #endif
86
87 #ifdef MSG_DONTWAIT
88 #define LHNET_RECVFROM_FLAGS MSG_DONTWAIT
89 #define LHNET_SENDTO_FLAGS 0
90 #else
91 #define LHNET_RECVFROM_FLAGS 0
92 #define LHNET_SENDTO_FLAGS 0
93 #endif
94
95 typedef struct lhnetaddressnative_s
96 {
97         lhnetaddresstype_t addresstype;
98         int port;
99         union
100         {
101                 struct sockaddr sock;
102                 struct sockaddr_in in;
103 #ifndef NOSUPPORTIPV6
104                 struct sockaddr_in6 in6;
105 #endif
106         }
107         addr;
108 }
109 lhnetaddressnative_t;
110
111 // to make LHNETADDRESS_FromString resolve repeated hostnames faster, cache them
112 #define MAX_NAMECACHE 64
113 static struct namecache_s
114 {
115         lhnetaddressnative_t address;
116         double expirationtime;
117         char name[64];
118 }
119 namecache[MAX_NAMECACHE];
120 static int namecacheposition = 0;
121
122 int LHNETADDRESS_FromPort(lhnetaddress_t *vaddress, lhnetaddresstype_t addresstype, int port)
123 {
124         lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
125         if (!address)
126                 return 0;
127         switch(addresstype)
128         {
129         default:
130                 break;
131         case LHNETADDRESSTYPE_LOOP:
132                 // local:port  (loopback)
133                 memset(address, 0, sizeof(*address));
134                 address->addresstype = LHNETADDRESSTYPE_LOOP;
135                 address->port = port;
136                 return 1;
137         case LHNETADDRESSTYPE_INET4:
138                 // 0.0.0.0:port  (INADDR_ANY, binds to all interfaces)
139                 memset(address, 0, sizeof(*address));
140                 address->addresstype = LHNETADDRESSTYPE_INET4;
141                 address->port = port;
142                 address->addr.in.sin_family = AF_INET;
143                 address->addr.in.sin_port = htons((unsigned short)port);
144                 return 1;
145 #ifndef NOSUPPORTIPV6
146         case LHNETADDRESSTYPE_INET6:
147                 // [0:0:0:0:0:0:0:0]:port  (IN6ADDR_ANY, binds to all interfaces)
148                 memset(address, 0, sizeof(*address));
149                 address->addresstype = LHNETADDRESSTYPE_INET6;
150                 address->port = port;
151                 address->addr.in6.sin6_family = AF_INET6;
152                 address->addr.in6.sin6_port = htons((unsigned short)port);
153                 return 1;
154 #endif
155         }
156         return 0;
157 }
158
159 #ifndef NOSUPPORTIPV6
160 static int LHNETADDRESS_Resolve(lhnetaddressnative_t *address, const char *name, int port)
161 {
162         char port_buff [16];
163         struct addrinfo hints;
164         struct addrinfo* addrinf;
165         int err;
166
167         dpsnprintf (port_buff, sizeof (port_buff), "%d", port);
168         port_buff[sizeof (port_buff) - 1] = '\0';
169
170         memset(&hints, 0, sizeof (hints));
171         hints.ai_family = AF_UNSPEC;
172         hints.ai_socktype = SOCK_DGRAM;
173         //hints.ai_flags = AI_PASSIVE;
174
175         err = getaddrinfo(name, port_buff, &hints, &addrinf);
176         if (err != 0 || addrinf == NULL)
177                 return 0;
178         if (addrinf->ai_addr->sa_family != AF_INET6 && addrinf->ai_addr->sa_family != AF_INET)
179         {
180                 freeaddrinfo (addrinf);
181                 return 0;
182         }
183
184         // great it worked
185         if (addrinf->ai_addr->sa_family == AF_INET6)
186         {
187                 address->addresstype = LHNETADDRESSTYPE_INET6;
188                 memcpy(&address->addr.in6, addrinf->ai_addr, sizeof(address->addr.in6));
189         }
190         else
191         {
192                 address->addresstype = LHNETADDRESSTYPE_INET4;
193                 memcpy(&address->addr.in, addrinf->ai_addr, sizeof(address->addr.in));
194         }
195         address->port = port;
196         
197         freeaddrinfo (addrinf);
198         return 1;
199 }
200
201 int LHNETADDRESS_FromString(lhnetaddress_t *vaddress, const char *string, int defaultport)
202 {
203         lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
204         int i, port, d1, d2, d3, d4, resolved;
205         size_t namelen;
206         unsigned char *a;
207         char name[128];
208 #ifdef STANDALONETEST
209         char string2[128];
210 #endif
211         const char* addr_start;
212         const char* addr_end = NULL;
213         const char* port_name = NULL;
214         int addr_family = AF_UNSPEC;
215
216         if (!address || !string || !*string)
217                 return 0;
218         memset(address, 0, sizeof(*address));
219         address->addresstype = LHNETADDRESSTYPE_NONE;
220         port = 0;
221
222         // If it's a bracketed IPv6 address
223         if (string[0] == '[')
224         {
225                 const char* end_bracket = strchr(string, ']');
226
227                 if (end_bracket == NULL)
228                         return 0;
229
230                 if (end_bracket[1] == ':')
231                         port_name = end_bracket + 2;
232                 else if (end_bracket[1] != '\0')
233                         return 0;
234
235                 addr_family = AF_INET6;
236                 addr_start = &string[1];
237                 addr_end = end_bracket;
238         }
239         else
240         {
241                 const char* first_colon;
242
243                 addr_start = string;
244
245                 // If it's a numeric non-bracket IPv6 address (-> no port),
246                 // or it's a numeric IPv4 address, or a name, with a port
247                 first_colon = strchr(string, ':');
248                 if (first_colon != NULL)
249                 {
250                         const char* last_colon = strrchr(first_colon + 1, ':');
251
252                         // If it's an numeric IPv4 address, or a name, with a port
253                         if (last_colon == NULL)
254                         {
255                                 addr_end = first_colon;
256                                 port_name = first_colon + 1;
257                         }
258                         else
259                                 addr_family = AF_INET6;
260                 }
261         }
262
263         if (addr_end != NULL)
264                 namelen = addr_end - addr_start;
265         else
266                 namelen = strlen (addr_start);
267
268         if (namelen >= sizeof(name))
269                 namelen = sizeof(name) - 1;
270         memcpy (name, addr_start, namelen);
271         name[namelen] = 0;
272
273         if (port_name)
274                 port = atoi(port_name);
275
276         if (port == 0)
277                 port = defaultport;
278
279         // handle loopback
280         if (!strcmp(name, "local"))
281         {
282                 address->addresstype = LHNETADDRESSTYPE_LOOP;
283                 address->port = port;
284                 return 1;
285         }
286         // try to parse as dotted decimal ipv4 address first
287         // note this supports partial ip addresses
288         d1 = d2 = d3 = d4 = 0;
289 #if _MSC_VER >= 1400
290 #define sscanf sscanf_s
291 #endif
292         if (addr_family != AF_INET6 &&
293                 sscanf(name, "%d.%d.%d.%d", &d1, &d2, &d3, &d4) >= 1 && (unsigned int)d1 < 256 && (unsigned int)d2 < 256 && (unsigned int)d3 < 256 && (unsigned int)d4 < 256)
294         {
295                 // parsed a valid ipv4 address
296                 address->addresstype = LHNETADDRESSTYPE_INET4;
297                 address->port = port;
298                 address->addr.in.sin_family = AF_INET;
299                 address->addr.in.sin_port = htons((unsigned short)port);
300                 a = (unsigned char *)&address->addr.in.sin_addr;
301                 a[0] = d1;
302                 a[1] = d2;
303                 a[2] = d3;
304                 a[3] = d4;
305 #ifdef STANDALONETEST
306                 LHNETADDRESS_ToString(address, string2, sizeof(string2), 1);
307                 printf("manual parsing of ipv4 dotted decimal address \"%s\" successful: %s\n", string, string2);
308 #endif
309                 return 1;
310         }
311         for (i = 0;i < MAX_NAMECACHE;i++)
312                 if (!strcmp(namecache[i].name, name))
313                         break;
314 #ifdef STANDALONETEST
315         if (i < MAX_NAMECACHE)
316 #else
317         if (i < MAX_NAMECACHE && realtime < namecache[i].expirationtime)
318 #endif
319         {
320                 *address = namecache[i].address;
321                 address->port = port;
322                 if (address->addresstype == LHNETADDRESSTYPE_INET6)
323                 {
324                         address->addr.in6.sin6_port = htons((unsigned short)port);
325                         return 1;
326                 }
327                 else if (address->addresstype == LHNETADDRESSTYPE_INET4)
328                 {
329                         address->addr.in.sin_port = htons((unsigned short)port);
330                         return 1;
331                 }
332                 return 0;
333         }
334
335         for (i = 0;i < (int)sizeof(namecache[namecacheposition].name)-1 && name[i];i++)
336                 namecache[namecacheposition].name[i] = name[i];
337         namecache[namecacheposition].name[i] = 0;
338 #ifndef STANDALONETEST
339         namecache[namecacheposition].expirationtime = realtime + 12 * 3600; // 12 hours
340 #endif
341
342         // try resolving the address (handles dns and other ip formats)
343         resolved = LHNETADDRESS_Resolve(address, name, port);
344         if (resolved)
345         {
346 #ifdef STANDALONETEST
347                 const char *protoname;
348
349                 switch (address->addresstype)
350                 {
351                         case LHNETADDRESSTYPE_INET6:
352                                 protoname = "ipv6";
353                                 break;
354                         case LHNETADDRESSTYPE_INET4:
355                                 protoname = "ipv4";
356                                 break;
357                         default:
358                                 protoname = "UNKNOWN";
359                                 break;
360                 }
361                 LHNETADDRESS_ToString(vaddress, string2, sizeof(string2), 1);
362                 Con_Printf("LHNETADDRESS_Resolve(\"%s\") returned %s address %s\n", string, protoname, string2);
363 #endif
364                 namecache[namecacheposition].address = *address;
365         }
366         else
367         {
368 #ifdef STANDALONETEST
369                 printf("name resolution failed on address \"%s\"\n", name);
370 #endif
371                 namecache[namecacheposition].address.addresstype = LHNETADDRESSTYPE_NONE;
372         }
373         
374         namecacheposition = (namecacheposition + 1) % MAX_NAMECACHE;
375         return resolved;
376 }
377 #else
378 int LHNETADDRESS_FromString(lhnetaddress_t *vaddress, const char *string, int defaultport)
379 {
380         lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
381         int i, port, namelen, d1, d2, d3, d4;
382         struct hostent *hostentry;
383         unsigned char *a;
384         const char *colon;
385         char name[128];
386 #ifdef STANDALONETEST
387         char string2[128];
388 #endif
389         if (!address || !string || !*string)
390                 return 0;
391         memset(address, 0, sizeof(*address));
392         address->addresstype = LHNETADDRESSTYPE_NONE;
393         port = 0;
394         colon = strrchr(string, ':');
395         if (colon && (colon == strchr(string, ':') || (string[0] == '[' && colon - string > 0 && colon[-1] == ']')))
396         //           EITHER: colon is the ONLY colon  OR: colon comes after [...] delimited IPv6 address
397         //           fixes misparsing of IPv6 addresses without port
398         {
399                 port = atoi(colon + 1);
400         }
401         else
402                 colon = string + strlen(string);
403         if (port == 0)
404                 port = defaultport;
405         namelen = colon - string;
406         if (namelen > 127)
407                 namelen = 127;
408         if (string[0] == '[' && namelen > 0 && string[namelen-1] == ']') // ipv6
409         {
410                 string++;
411                 namelen -= 2;
412         }
413         memcpy(name, string, namelen);
414         name[namelen] = 0;
415         // handle loopback
416         if (!strcmp(name, "local"))
417         {
418                 address->addresstype = LHNETADDRESSTYPE_LOOP;
419                 address->port = port;
420                 return 1;
421         }
422         // try to parse as dotted decimal ipv4 address first
423         // note this supports partial ip addresses
424         d1 = d2 = d3 = d4 = 0;
425 #if _MSC_VER >= 1400
426 #define sscanf sscanf_s
427 #endif
428         if (sscanf(name, "%d.%d.%d.%d", &d1, &d2, &d3, &d4) >= 1 && (unsigned int)d1 < 256 && (unsigned int)d2 < 256 && (unsigned int)d3 < 256 && (unsigned int)d4 < 256)
429         {
430                 // parsed a valid ipv4 address
431                 address->addresstype = LHNETADDRESSTYPE_INET4;
432                 address->port = port;
433                 address->addr.in.sin_family = AF_INET;
434                 address->addr.in.sin_port = htons((unsigned short)port);
435                 a = (unsigned char *)&address->addr.in.sin_addr;
436                 a[0] = d1;
437                 a[1] = d2;
438                 a[2] = d3;
439                 a[3] = d4;
440 #ifdef STANDALONETEST
441                 LHNETADDRESS_ToString(address, string2, sizeof(string2), 1);
442                 printf("manual parsing of ipv4 dotted decimal address \"%s\" successful: %s\n", string, string2);
443 #endif
444                 return 1;
445         }
446         for (i = 0;i < MAX_NAMECACHE;i++)
447                 if (!strcmp(namecache[i].name, name))
448                         break;
449 #ifdef STANDALONETEST
450         if (i < MAX_NAMECACHE)
451 #else
452         if (i < MAX_NAMECACHE && realtime < namecache[i].expirationtime)
453 #endif
454         {
455                 *address = namecache[i].address;
456                 address->port = port;
457                 if (address->addresstype == LHNETADDRESSTYPE_INET6)
458                 {
459 #ifndef NOSUPPORTIPV6
460                         address->addr.in6.sin6_port = htons((unsigned short)port);
461                         return 1;
462 #endif
463                 }
464                 else if (address->addresstype == LHNETADDRESSTYPE_INET4)
465                 {
466                         address->addr.in.sin_port = htons((unsigned short)port);
467                         return 1;
468                 }
469                 return 0;
470         }
471         // try gethostbyname (handles dns and other ip formats)
472         hostentry = gethostbyname(name);
473         if (hostentry)
474         {
475                 if (hostentry->h_addrtype == AF_INET6)
476                 {
477 #ifndef NOSUPPORTIPV6
478                         // great it worked
479                         address->addresstype = LHNETADDRESSTYPE_INET6;
480                         address->port = port;
481                         address->addr.in6.sin6_family = hostentry->h_addrtype;
482                         address->addr.in6.sin6_port = htons((unsigned short)port);
483                         memcpy(&address->addr.in6.sin6_addr, hostentry->h_addr_list[0], sizeof(address->addr.in6.sin6_addr));
484                         for (i = 0;i < (int)sizeof(namecache[namecacheposition].name)-1 && name[i];i++)
485                                 namecache[namecacheposition].name[i] = name[i];
486                         namecache[namecacheposition].name[i] = 0;
487 #ifndef STANDALONETEST
488                         namecache[namecacheposition].expirationtime = realtime + 12 * 3600; // 12 hours
489 #endif
490                         namecache[namecacheposition].address = *address;
491                         namecacheposition = (namecacheposition + 1) % MAX_NAMECACHE;
492 #ifdef STANDALONETEST
493                         LHNETADDRESS_ToString(address, string2, sizeof(string2), 1);
494                         printf("gethostbyname(\"%s\") returned ipv6 address %s\n", string, string2);
495 #endif
496                         return 1;
497 #endif
498                 }
499                 else if (hostentry->h_addrtype == AF_INET)
500                 {
501                         // great it worked
502                         address->addresstype = LHNETADDRESSTYPE_INET4;
503                         address->port = port;
504                         address->addr.in.sin_family = hostentry->h_addrtype;
505                         address->addr.in.sin_port = htons((unsigned short)port);
506                         memcpy(&address->addr.in.sin_addr, hostentry->h_addr_list[0], sizeof(address->addr.in.sin_addr));
507                         for (i = 0;i < (int)sizeof(namecache[namecacheposition].name)-1 && name[i];i++)
508                                 namecache[namecacheposition].name[i] = name[i];
509                         namecache[namecacheposition].name[i] = 0;
510 #ifndef STANDALONETEST
511                         namecache[namecacheposition].expirationtime = realtime + 12 * 3600; // 12 hours
512 #endif
513                         namecache[namecacheposition].address = *address;
514                         namecacheposition = (namecacheposition + 1) % MAX_NAMECACHE;
515 #ifdef STANDALONETEST
516                         LHNETADDRESS_ToString(address, string2, sizeof(string2), 1);
517                         printf("gethostbyname(\"%s\") returned ipv4 address %s\n", string, string2);
518 #endif
519                         return 1;
520                 }
521         }
522 #ifdef STANDALONETEST
523         printf("gethostbyname failed on address \"%s\"\n", name);
524 #endif
525         for (i = 0;i < (int)sizeof(namecache[namecacheposition].name)-1 && name[i];i++)
526                 namecache[namecacheposition].name[i] = name[i];
527         namecache[namecacheposition].name[i] = 0;
528 #ifndef STANDALONETEST
529         namecache[namecacheposition].expirationtime = realtime + 12 * 3600; // 12 hours
530 #endif
531         namecache[namecacheposition].address.addresstype = LHNETADDRESSTYPE_NONE;
532         namecacheposition = (namecacheposition + 1) % MAX_NAMECACHE;
533         return 0;
534 }
535 #endif
536
537 int LHNETADDRESS_ToString(const lhnetaddress_t *vaddress, char *string, int stringbuffersize, int includeport)
538 {
539         lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
540         const unsigned char *a;
541         if (!address || !string || stringbuffersize < 1)
542                 return 0;
543         *string = 0;
544         switch(address->addresstype)
545         {
546         default:
547                 break;
548         case LHNETADDRESSTYPE_LOOP:
549                 if (includeport)
550                 {
551                         if (stringbuffersize >= 12)
552                         {
553                                 dpsnprintf(string, stringbuffersize, "local:%d", address->port);
554                                 return 1;
555                         }
556                 }
557                 else
558                 {
559                         if (stringbuffersize >= 6)
560                         {
561                                 memcpy(string, "local", 6);
562                                 return 1;
563                         }
564                 }
565                 break;
566         case LHNETADDRESSTYPE_INET4:
567                 a = (const unsigned char *)(&address->addr.in.sin_addr);
568                 if (includeport)
569                 {
570                         if (stringbuffersize >= 22)
571                         {
572                                 dpsnprintf(string, stringbuffersize, "%d.%d.%d.%d:%d", a[0], a[1], a[2], a[3], address->port);
573                                 return 1;
574                         }
575                 }
576                 else
577                 {
578                         if (stringbuffersize >= 16)
579                         {
580                                 dpsnprintf(string, stringbuffersize, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
581                                 return 1;
582                         }
583                 }
584                 break;
585 #ifndef NOSUPPORTIPV6
586         case LHNETADDRESSTYPE_INET6:
587                 a = (const unsigned char *)(&address->addr.in6.sin6_addr);
588                 if (includeport)
589                 {
590                         if (stringbuffersize >= 88)
591                         {
592                                 dpsnprintf(string, stringbuffersize, "[%x:%x:%x:%x:%x:%x:%x:%x]:%d", a[0] * 256 + a[1], a[2] * 256 + a[3], a[4] * 256 + a[5], a[6] * 256 + a[7], a[8] * 256 + a[9], a[10] * 256 + a[11], a[12] * 256 + a[13], a[14] * 256 + a[15], address->port);
593                                 return 1;
594                         }
595                 }
596                 else
597                 {
598                         if (stringbuffersize >= 80)
599                         {
600                                 dpsnprintf(string, stringbuffersize, "%x:%x:%x:%x:%x:%x:%x:%x", a[0] * 256 + a[1], a[2] * 256 + a[3], a[4] * 256 + a[5], a[6] * 256 + a[7], a[8] * 256 + a[9], a[10] * 256 + a[11], a[12] * 256 + a[13], a[14] * 256 + a[15]);
601                                 return 1;
602                         }
603                 }
604                 break;
605 #endif
606         }
607         return 0;
608 }
609
610 int LHNETADDRESS_GetAddressType(const lhnetaddress_t *address)
611 {
612         if (address)
613                 return address->addresstype;
614         else
615                 return LHNETADDRESSTYPE_NONE;
616 }
617
618 const char *LHNETADDRESS_GetInterfaceName(const lhnetaddress_t *vaddress, char *ifname, size_t ifnamelength)
619 {
620 #ifndef NOSUPPORTIPV6
621         lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
622
623         if (address && address->addresstype == LHNETADDRESSTYPE_INET6)
624         {
625 #ifndef _WIN32
626
627                 if (if_indextoname(address->addr.in6.sin6_scope_id, ifname) == ifname)
628                         return ifname;
629
630 #else
631
632                 // The Win32 API doesn't have if_indextoname() until Windows Vista,
633                 // but luckily it just uses the interface ID as the interface name
634
635                 if (dpsnprintf(ifname, ifnamelength, "%lu", address->addr.in6.sin6_scope_id) > 0)
636                         return ifname;
637
638 #endif
639         }
640 #endif
641
642         return NULL;
643 }
644
645 int LHNETADDRESS_GetPort(const lhnetaddress_t *address)
646 {
647         if (!address)
648                 return -1;
649         return address->port;
650 }
651
652 int LHNETADDRESS_SetPort(lhnetaddress_t *vaddress, int port)
653 {
654         lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
655         if (!address)
656                 return 0;
657         address->port = port;
658         switch(address->addresstype)
659         {
660         case LHNETADDRESSTYPE_LOOP:
661                 return 1;
662         case LHNETADDRESSTYPE_INET4:
663                 address->addr.in.sin_port = htons((unsigned short)port);
664                 return 1;
665 #ifndef NOSUPPORTIPV6
666         case LHNETADDRESSTYPE_INET6:
667                 address->addr.in6.sin6_port = htons((unsigned short)port);
668                 return 1;
669 #endif
670         default:
671                 return 0;
672         }
673 }
674
675 int LHNETADDRESS_Compare(const lhnetaddress_t *vaddress1, const lhnetaddress_t *vaddress2)
676 {
677         lhnetaddressnative_t *address1 = (lhnetaddressnative_t *)vaddress1;
678         lhnetaddressnative_t *address2 = (lhnetaddressnative_t *)vaddress2;
679         if (!address1 || !address2)
680                 return 1;
681         if (address1->addresstype != address2->addresstype)
682                 return 1;
683         switch(address1->addresstype)
684         {
685         case LHNETADDRESSTYPE_LOOP:
686                 if (address1->port != address2->port)
687                         return -1;
688                 return 0;
689         case LHNETADDRESSTYPE_INET4:
690                 if (address1->addr.in.sin_family != address2->addr.in.sin_family)
691                         return 1;
692                 if (memcmp(&address1->addr.in.sin_addr, &address2->addr.in.sin_addr, sizeof(address1->addr.in.sin_addr)))
693                         return 1;
694                 if (address1->port != address2->port)
695                         return -1;
696                 return 0;
697 #ifndef NOSUPPORTIPV6
698         case LHNETADDRESSTYPE_INET6:
699                 if (address1->addr.in6.sin6_family != address2->addr.in6.sin6_family)
700                         return 1;
701                 if (memcmp(&address1->addr.in6.sin6_addr, &address2->addr.in6.sin6_addr, sizeof(address1->addr.in6.sin6_addr)))
702                         return 1;
703                 if (address1->port != address2->port)
704                         return -1;
705                 return 0;
706 #endif
707         default:
708                 return 1;
709         }
710 }
711
712 typedef struct lhnetpacket_s
713 {
714         void *data;
715         int length;
716         int sourceport;
717         int destinationport;
718         time_t timeout;
719 #ifndef STANDALONETEST
720         double sentdoubletime;
721 #endif
722         struct lhnetpacket_s *next, *prev;
723 }
724 lhnetpacket_t;
725
726 static int lhnet_active;
727 static lhnetsocket_t lhnet_socketlist;
728 static lhnetpacket_t lhnet_packetlist;
729 static int lhnet_default_dscp = 0;
730 #ifdef WIN32
731 static int lhnet_didWSAStartup = 0;
732 static WSADATA lhnet_winsockdata;
733 #endif
734
735 void LHNET_Init(void)
736 {
737         if (lhnet_active)
738                 return;
739         lhnet_socketlist.next = lhnet_socketlist.prev = &lhnet_socketlist;
740         lhnet_packetlist.next = lhnet_packetlist.prev = &lhnet_packetlist;
741         lhnet_active = 1;
742 #ifdef WIN32
743         lhnet_didWSAStartup = !WSAStartup(MAKEWORD(1, 1), &lhnet_winsockdata);
744         if (!lhnet_didWSAStartup)
745                 Con_Print("LHNET_Init: WSAStartup failed, networking disabled\n");
746 #endif
747 }
748
749 int LHNET_DefaultDSCP(int dscp)
750 {
751 #ifdef IP_TOS
752         int prev = lhnet_default_dscp;
753         if(dscp >= 0)
754                 lhnet_default_dscp = dscp;
755         return prev;
756 #else
757         return -1;
758 #endif
759 }
760
761 void LHNET_Shutdown(void)
762 {
763         lhnetpacket_t *p;
764         if (!lhnet_active)
765                 return;
766         while (lhnet_socketlist.next != &lhnet_socketlist)
767                 LHNET_CloseSocket(lhnet_socketlist.next);
768         while (lhnet_packetlist.next != &lhnet_packetlist)
769         {
770                 p = lhnet_packetlist.next;
771                 p->prev->next = p->next;
772                 p->next->prev = p->prev;
773                 Z_Free(p);
774         }
775 #ifdef WIN32
776         if (lhnet_didWSAStartup)
777         {
778                 lhnet_didWSAStartup = 0;
779                 WSACleanup();
780         }
781 #endif
782         lhnet_active = 0;
783 }
784
785 static const char *LHNETPRIVATE_StrError(void)
786 {
787 #ifdef WIN32
788         int i = WSAGetLastError();
789         switch (i)
790         {
791                 case WSAEINTR:           return "WSAEINTR";
792                 case WSAEBADF:           return "WSAEBADF";
793                 case WSAEACCES:          return "WSAEACCES";
794                 case WSAEFAULT:          return "WSAEFAULT";
795                 case WSAEINVAL:          return "WSAEINVAL";
796                 case WSAEMFILE:          return "WSAEMFILE";
797                 case WSAEWOULDBLOCK:     return "WSAEWOULDBLOCK";
798                 case WSAEINPROGRESS:     return "WSAEINPROGRESS";
799                 case WSAEALREADY:        return "WSAEALREADY";
800                 case WSAENOTSOCK:        return "WSAENOTSOCK";
801                 case WSAEDESTADDRREQ:    return "WSAEDESTADDRREQ";
802                 case WSAEMSGSIZE:        return "WSAEMSGSIZE";
803                 case WSAEPROTOTYPE:      return "WSAEPROTOTYPE";
804                 case WSAENOPROTOOPT:     return "WSAENOPROTOOPT";
805                 case WSAEPROTONOSUPPORT: return "WSAEPROTONOSUPPORT";
806                 case WSAESOCKTNOSUPPORT: return "WSAESOCKTNOSUPPORT";
807                 case WSAEOPNOTSUPP:      return "WSAEOPNOTSUPP";
808                 case WSAEPFNOSUPPORT:    return "WSAEPFNOSUPPORT";
809                 case WSAEAFNOSUPPORT:    return "WSAEAFNOSUPPORT";
810                 case WSAEADDRINUSE:      return "WSAEADDRINUSE";
811                 case WSAEADDRNOTAVAIL:   return "WSAEADDRNOTAVAIL";
812                 case WSAENETDOWN:        return "WSAENETDOWN";
813                 case WSAENETUNREACH:     return "WSAENETUNREACH";
814                 case WSAENETRESET:       return "WSAENETRESET";
815                 case WSAECONNABORTED:    return "WSAECONNABORTED";
816                 case WSAECONNRESET:      return "WSAECONNRESET";
817                 case WSAENOBUFS:         return "WSAENOBUFS";
818                 case WSAEISCONN:         return "WSAEISCONN";
819                 case WSAENOTCONN:        return "WSAENOTCONN";
820                 case WSAESHUTDOWN:       return "WSAESHUTDOWN";
821                 case WSAETOOMANYREFS:    return "WSAETOOMANYREFS";
822                 case WSAETIMEDOUT:       return "WSAETIMEDOUT";
823                 case WSAECONNREFUSED:    return "WSAECONNREFUSED";
824                 case WSAELOOP:           return "WSAELOOP";
825                 case WSAENAMETOOLONG:    return "WSAENAMETOOLONG";
826                 case WSAEHOSTDOWN:       return "WSAEHOSTDOWN";
827                 case WSAEHOSTUNREACH:    return "WSAEHOSTUNREACH";
828                 case WSAENOTEMPTY:       return "WSAENOTEMPTY";
829                 case WSAEPROCLIM:        return "WSAEPROCLIM";
830                 case WSAEUSERS:          return "WSAEUSERS";
831                 case WSAEDQUOT:          return "WSAEDQUOT";
832                 case WSAESTALE:          return "WSAESTALE";
833                 case WSAEREMOTE:         return "WSAEREMOTE";
834                 case WSAEDISCON:         return "WSAEDISCON";
835                 case 0:                  return "no error";
836                 default:                 return "unknown WSAE error";
837         }
838 #else
839         return strerror(errno);
840 #endif
841 }
842
843 void LHNET_SleepUntilPacket_Microseconds(int microseconds)
844 {
845 #ifdef FD_SET
846         fd_set fdreadset;
847         struct timeval tv;
848         int lastfd;
849         lhnetsocket_t *s;
850         FD_ZERO(&fdreadset);
851         lastfd = 0;
852         for (s = lhnet_socketlist.next;s != &lhnet_socketlist;s = s->next)
853         {
854                 if (s->address.addresstype == LHNETADDRESSTYPE_INET4 || s->address.addresstype == LHNETADDRESSTYPE_INET6)
855                 {
856                         if (lastfd < s->inetsocket)
857                                 lastfd = s->inetsocket;
858 #if defined(WIN32) && !defined(_MSC_VER)
859                         FD_SET((int)s->inetsocket, &fdreadset);
860 #else
861                         FD_SET((unsigned int)s->inetsocket, &fdreadset);
862 #endif
863                 }
864         }
865         tv.tv_sec = microseconds / 1000000;
866         tv.tv_usec = microseconds % 1000000;
867         select(lastfd + 1, &fdreadset, NULL, NULL, &tv);
868 #else
869         Sys_Sleep(microseconds);
870 #endif
871 }
872
873 lhnetsocket_t *LHNET_OpenSocket_Connectionless(lhnetaddress_t *address)
874 {
875         lhnetsocket_t *lhnetsocket, *s;
876         if (!address)
877                 return NULL;
878         lhnetsocket = (lhnetsocket_t *)Z_Malloc(sizeof(*lhnetsocket));
879         if (lhnetsocket)
880         {
881                 memset(lhnetsocket, 0, sizeof(*lhnetsocket));
882                 lhnetsocket->address = *address;
883                 switch(lhnetsocket->address.addresstype)
884                 {
885                 case LHNETADDRESSTYPE_LOOP:
886                         if (lhnetsocket->address.port == 0)
887                         {
888                                 // allocate a port dynamically
889                                 // this search will always terminate because there is never
890                                 // an allocated socket with port 0, so if the number wraps it
891                                 // will find the port is unused, and then refuse to use port
892                                 // 0, causing an intentional failure condition
893                                 lhnetsocket->address.port = 1024;
894                                 for (;;)
895                                 {
896                                         for (s = lhnet_socketlist.next;s != &lhnet_socketlist;s = s->next)
897                                                 if (s->address.addresstype == lhnetsocket->address.addresstype && s->address.port == lhnetsocket->address.port)
898                                                         break;
899                                         if (s == &lhnet_socketlist)
900                                                 break;
901                                         lhnetsocket->address.port++;
902                                 }
903                         }
904                         // check if the port is available
905                         for (s = lhnet_socketlist.next;s != &lhnet_socketlist;s = s->next)
906                                 if (s->address.addresstype == lhnetsocket->address.addresstype && s->address.port == lhnetsocket->address.port)
907                                         break;
908                         if (s == &lhnet_socketlist && lhnetsocket->address.port != 0)
909                         {
910                                 lhnetsocket->next = &lhnet_socketlist;
911                                 lhnetsocket->prev = lhnetsocket->next->prev;
912                                 lhnetsocket->next->prev = lhnetsocket;
913                                 lhnetsocket->prev->next = lhnetsocket;
914                                 return lhnetsocket;
915                         }
916                         break;
917                 case LHNETADDRESSTYPE_INET4:
918 #ifndef NOSUPPORTIPV6
919                 case LHNETADDRESSTYPE_INET6:
920 #endif
921 #ifdef WIN32
922                         if (lhnet_didWSAStartup)
923                         {
924 #endif
925 #ifndef NOSUPPORTIPV6
926                                 if ((lhnetsocket->inetsocket = socket(address->addresstype == LHNETADDRESSTYPE_INET6 ? PF_INET6 : PF_INET, SOCK_DGRAM, IPPROTO_UDP)) != -1)
927 #else
928                                 if ((lhnetsocket->inetsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) != -1)
929 #endif
930                                 {
931 #ifdef WIN32
932                                         u_long _false = 0;
933 #endif
934 #ifdef MSG_DONTWAIT
935                                         if (1)
936 #else
937 #ifdef WIN32
938                                         u_long _true = 1;
939 #else
940                                         char _true = 1;
941 #endif
942                                         if (ioctlsocket(lhnetsocket->inetsocket, FIONBIO, &_true) != -1)
943 #endif
944                                         {
945 #ifdef IPV6_V6ONLY
946                                                 // We need to set this flag to tell the OS that we only listen on IPv6. If we don't
947                                                 // most OSes will create a dual-protocol socket that also listens on IPv4. In this case
948                                                 // if an IPv4 socket is already bound to the port we want, our bind() call will fail.
949                                                 int ipv6_only = 1;
950                                                 if (address->addresstype != LHNETADDRESSTYPE_INET6
951                                                         || setsockopt (lhnetsocket->inetsocket, IPPROTO_IPV6, IPV6_V6ONLY,
952                                                                                    (const char *)&ipv6_only, sizeof(ipv6_only)) == 0
953 #ifdef WIN32
954                                                         // The Win32 API only supports IPV6_V6ONLY since Windows Vista, but fortunately
955                                                         // the default value is what we want on Win32 anyway (IPV6_V6ONLY = true)
956                                                         || SOCKETERRNO == WSAENOPROTOOPT
957 #endif
958                                                         )
959 #endif
960                                                 {
961                                                         lhnetaddressnative_t *localaddress = (lhnetaddressnative_t *)&lhnetsocket->address;
962                                                         SOCKLEN_T namelen;
963                                                         int bindresult;
964
965 #if defined(SOL_RFC1149) && defined(RFC1149_1149ONLY)
966                                                         // we got reports of massive lags when this protocol was chosen as transport
967                                                         // so better turn it off
968                                                         {
969                                                                 int rfc1149only = 0;
970                                                                 int rfc1149enabled = 0;
971                                                                 if(setsockopt(lhnetsocket->inetsocket, SOL_RFC1149, RFC1149_1149ONLY, &rfc1149only))
972                                                                         Con_Printf("LHNET_OpenSocket_Connectionless: warning: setsockopt(RFC1149_1149ONLY) returned error: %s\n", LHNETPRIVATE_StrError());
973                                                                 if(setsockopt(lhnetsocket->inetsocket, SOL_RFC1149, RFC1149_ENABLED, &rfc1149enabled))
974                                                                         Con_Printf("LHNET_OpenSocket_Connectionless: warning: setsockopt(RFC1149_ENABLED) returned error: %s\n", LHNETPRIVATE_StrError());
975                                                         }
976 #endif
977
978 #ifndef NOSUPPORTIPV6
979                                                         if (address->addresstype == LHNETADDRESSTYPE_INET6)
980                                                         {
981                                                                 namelen = sizeof(localaddress->addr.in6);
982                                                                 bindresult = bind(lhnetsocket->inetsocket, &localaddress->addr.sock, namelen);
983                                                                 if (bindresult != -1)
984                                                                 {
985                                                                         if (getsockname(lhnetsocket->inetsocket, &localaddress->addr.sock, &namelen))
986                                                                         {
987                                                                                 // If getsockname failed, we can assume the bound socket is useless.
988                                                                                 bindresult = -1;
989                                                                         }
990                                                                 }
991                                                         }
992                                                         else
993 #endif
994                                                         {
995                                                                 namelen = sizeof(localaddress->addr.in);
996                                                                 bindresult = bind(lhnetsocket->inetsocket, &localaddress->addr.sock, namelen);
997                                                                 if (bindresult != -1)
998                                                                 {
999                                                                         if (getsockname(lhnetsocket->inetsocket, &localaddress->addr.sock, &namelen))
1000                                                                         {
1001                                                                                 // If getsockname failed, we can assume the bound socket is useless.
1002                                                                                 bindresult = -1;
1003                                                                         }
1004                                                                 }
1005                                                         }
1006                                                         if (bindresult != -1)
1007                                                         {
1008                                                                 int i = 1;
1009                                                                 // enable broadcast on this socket
1010                                                                 setsockopt(lhnetsocket->inetsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i));
1011 #ifdef IP_TOS
1012                                                                 {
1013                                                                         // enable DSCP for ToS support
1014                                                                         int tos = lhnet_default_dscp << 2;
1015                                                                         if (setsockopt(lhnetsocket->inetsocket, IPPROTO_IP, IP_TOS, (char *) &tos, sizeof(tos)))
1016                                                                         {
1017                                                                                 // Error in setsockopt - fine, we'll simply set no TOS then.
1018                                                                         }
1019                                                                 }
1020 #endif
1021                                                                 lhnetsocket->next = &lhnet_socketlist;
1022                                                                 lhnetsocket->prev = lhnetsocket->next->prev;
1023                                                                 lhnetsocket->next->prev = lhnetsocket;
1024                                                                 lhnetsocket->prev->next = lhnetsocket;
1025 #ifdef WIN32
1026                                                                 if (ioctlsocket(lhnetsocket->inetsocket, SIO_UDP_CONNRESET, &_false) == -1)
1027                                                                         Con_DPrintf("LHNET_OpenSocket_Connectionless: ioctlsocket SIO_UDP_CONNRESET returned error: %s\n", LHNETPRIVATE_StrError());
1028 #endif
1029                                                                 return lhnetsocket;
1030                                                         }
1031                                                         else
1032                                                                 Con_Printf("LHNET_OpenSocket_Connectionless: bind returned error: %s\n", LHNETPRIVATE_StrError());
1033                                                 }
1034 #ifdef IPV6_V6ONLY
1035                                                 else
1036                                                         Con_Printf("LHNET_OpenSocket_Connectionless: setsockopt(IPV6_V6ONLY) returned error: %s\n", LHNETPRIVATE_StrError());
1037 #endif
1038                                         }
1039                                         else
1040                                                 Con_Printf("LHNET_OpenSocket_Connectionless: ioctlsocket returned error: %s\n", LHNETPRIVATE_StrError());
1041                                         closesocket(lhnetsocket->inetsocket);
1042                                 }
1043                                 else
1044                                         Con_Printf("LHNET_OpenSocket_Connectionless: socket returned error: %s\n", LHNETPRIVATE_StrError());
1045 #ifdef WIN32
1046                         }
1047                         else
1048                                 Con_Print("LHNET_OpenSocket_Connectionless: can't open a socket (WSAStartup failed during LHNET_Init)\n");
1049 #endif
1050                         break;
1051                 default:
1052                         break;
1053                 }
1054                 Z_Free(lhnetsocket);
1055         }
1056         return NULL;
1057 }
1058
1059 void LHNET_CloseSocket(lhnetsocket_t *lhnetsocket)
1060 {
1061         if (lhnetsocket)
1062         {
1063                 // unlink from socket list
1064                 if (lhnetsocket->next == NULL)
1065                         return; // invalid!
1066                 lhnetsocket->next->prev = lhnetsocket->prev;
1067                 lhnetsocket->prev->next = lhnetsocket->next;
1068                 lhnetsocket->next = NULL;
1069                 lhnetsocket->prev = NULL;
1070
1071                 // no special close code for loopback, just inet
1072                 if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET4 || lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET6)
1073                 {
1074                         closesocket(lhnetsocket->inetsocket);
1075                 }
1076                 Z_Free(lhnetsocket);
1077         }
1078 }
1079
1080 lhnetaddress_t *LHNET_AddressFromSocket(lhnetsocket_t *sock)
1081 {
1082         if (sock)
1083                 return &sock->address;
1084         else
1085                 return NULL;
1086 }
1087
1088 int LHNET_Read(lhnetsocket_t *lhnetsocket, void *content, int maxcontentlength, lhnetaddress_t *vaddress)
1089 {
1090         lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
1091         int value = 0;
1092         if (!lhnetsocket || !address || !content || maxcontentlength < 1)
1093                 return -1;
1094         if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_LOOP)
1095         {
1096                 time_t currenttime;
1097                 lhnetpacket_t *p, *pnext;
1098                 // scan for any old packets to timeout while searching for a packet
1099                 // that is waiting to be delivered to this socket
1100                 currenttime = time(NULL);
1101                 for (p = lhnet_packetlist.next;p != &lhnet_packetlist;p = pnext)
1102                 {
1103                         pnext = p->next;
1104                         if (p->timeout < currenttime)
1105                         {
1106                                 // unlink and free
1107                                 p->next->prev = p->prev;
1108                                 p->prev->next = p->next;
1109                                 Z_Free(p);
1110                                 continue;
1111                         }
1112 #ifndef STANDALONETEST
1113                         if (cl_netlocalping.value && (realtime - cl_netlocalping.value * (1.0 / 2000.0)) < p->sentdoubletime)
1114                                 continue;
1115 #endif
1116                         if (value == 0 && p->destinationport == lhnetsocket->address.port)
1117                         {
1118                                 if (p->length <= maxcontentlength)
1119                                 {
1120                                         lhnetaddressnative_t *localaddress = (lhnetaddressnative_t *)&lhnetsocket->address;
1121                                         *address = *localaddress;
1122                                         address->port = p->sourceport;
1123                                         memcpy(content, p->data, p->length);
1124                                         value = p->length;
1125                                 }
1126                                 else
1127                                         value = -1;
1128                                 // unlink and free
1129                                 p->next->prev = p->prev;
1130                                 p->prev->next = p->next;
1131                                 Z_Free(p);
1132                         }
1133                 }
1134         }
1135         else if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET4)
1136         {
1137                 SOCKLEN_T inetaddresslength;
1138                 address->addresstype = LHNETADDRESSTYPE_NONE;
1139                 inetaddresslength = sizeof(address->addr.in);
1140                 value = recvfrom(lhnetsocket->inetsocket, (char *)content, maxcontentlength, LHNET_RECVFROM_FLAGS, &address->addr.sock, &inetaddresslength);
1141                 if (value > 0)
1142                 {
1143                         address->addresstype = LHNETADDRESSTYPE_INET4;
1144                         address->port = ntohs(address->addr.in.sin_port);
1145                         return value;
1146                 }
1147                 else if (value < 0)
1148                 {
1149                         int e = SOCKETERRNO;
1150                         if (e == EWOULDBLOCK)
1151                                 return 0;
1152                         switch (e)
1153                         {
1154                                 case ECONNREFUSED:
1155                                         Con_Print("Connection refused\n");
1156                                         return 0;
1157                         }
1158                         Con_DPrintf("LHNET_Read: recvfrom returned error: %s\n", LHNETPRIVATE_StrError());
1159                 }
1160         }
1161 #ifndef NOSUPPORTIPV6
1162         else if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET6)
1163         {
1164                 SOCKLEN_T inetaddresslength;
1165                 address->addresstype = LHNETADDRESSTYPE_NONE;
1166                 inetaddresslength = sizeof(address->addr.in6);
1167                 value = recvfrom(lhnetsocket->inetsocket, (char *)content, maxcontentlength, LHNET_RECVFROM_FLAGS, &address->addr.sock, &inetaddresslength);
1168                 if (value > 0)
1169                 {
1170                         address->addresstype = LHNETADDRESSTYPE_INET6;
1171                         address->port = ntohs(address->addr.in6.sin6_port);
1172                         return value;
1173                 }
1174                 else if (value == -1)
1175                 {
1176                         int e = SOCKETERRNO;
1177                         if (e == EWOULDBLOCK)
1178                                 return 0;
1179                         switch (e)
1180                         {
1181                                 case ECONNREFUSED:
1182                                         Con_Print("Connection refused\n");
1183                                         return 0;
1184                         }
1185                         Con_DPrintf("LHNET_Read: recvfrom returned error: %s\n", LHNETPRIVATE_StrError());
1186                 }
1187         }
1188 #endif
1189         return value;
1190 }
1191
1192 int LHNET_Write(lhnetsocket_t *lhnetsocket, const void *content, int contentlength, const lhnetaddress_t *vaddress)
1193 {
1194         lhnetaddressnative_t *address = (lhnetaddressnative_t *)vaddress;
1195         int value = -1;
1196         if (!lhnetsocket || !address || !content || contentlength < 1)
1197                 return -1;
1198         if (lhnetsocket->address.addresstype != address->addresstype)
1199                 return -1;
1200         if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_LOOP)
1201         {
1202                 lhnetpacket_t *p;
1203                 p = (lhnetpacket_t *)Z_Malloc(sizeof(*p) + contentlength);
1204                 p->data = (void *)(p + 1);
1205                 memcpy(p->data, content, contentlength);
1206                 p->length = contentlength;
1207                 p->sourceport = lhnetsocket->address.port;
1208                 p->destinationport = address->port;
1209                 p->timeout = time(NULL) + 10;
1210                 p->next = &lhnet_packetlist;
1211                 p->prev = p->next->prev;
1212                 p->next->prev = p;
1213                 p->prev->next = p;
1214 #ifndef STANDALONETEST
1215                 p->sentdoubletime = realtime;
1216 #endif
1217                 value = contentlength;
1218         }
1219         else if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET4)
1220         {
1221                 value = sendto(lhnetsocket->inetsocket, (char *)content, contentlength, LHNET_SENDTO_FLAGS, (struct sockaddr *)&address->addr.in, sizeof(struct sockaddr_in));
1222                 if (value == -1)
1223                 {
1224                         if (SOCKETERRNO == EWOULDBLOCK)
1225                                 return 0;
1226                         Con_DPrintf("LHNET_Write: sendto returned error: %s\n", LHNETPRIVATE_StrError());
1227                 }
1228         }
1229 #ifndef NOSUPPORTIPV6
1230         else if (lhnetsocket->address.addresstype == LHNETADDRESSTYPE_INET6)
1231         {
1232                 value = sendto(lhnetsocket->inetsocket, (char *)content, contentlength, 0, (struct sockaddr *)&address->addr.in6, sizeof(struct sockaddr_in6));
1233                 if (value == -1)
1234                 {
1235                         if (SOCKETERRNO == EWOULDBLOCK)
1236                                 return 0;
1237                         Con_DPrintf("LHNET_Write: sendto returned error: %s\n", LHNETPRIVATE_StrError());
1238                 }
1239         }
1240 #endif
1241         return value;
1242 }
1243
1244 #ifdef STANDALONETEST
1245 int main(int argc, char **argv)
1246 {
1247 #if 1
1248         char *buffer = "test", buffer2[1024];
1249         int blen = strlen(buffer);
1250         int b2len = 1024;
1251         lhnetsocket_t *sock1;
1252         lhnetsocket_t *sock2;
1253         lhnetaddress_t myaddy1;
1254         lhnetaddress_t myaddy2;
1255         lhnetaddress_t myaddy3;
1256         lhnetaddress_t localhostaddy1;
1257         lhnetaddress_t localhostaddy2;
1258         int test1;
1259         int test2;
1260
1261         printf("calling LHNET_Init\n");
1262         LHNET_Init();
1263
1264         printf("calling LHNET_FromPort twice to create two local addresses\n");
1265         LHNETADDRESS_FromPort(&myaddy1, LHNETADDRESSTYPE_INET4, 4000);
1266         LHNETADDRESS_FromPort(&myaddy2, LHNETADDRESSTYPE_INET4, 4001);
1267         LHNETADDRESS_FromString(&localhostaddy1, "127.0.0.1", 4000);
1268         LHNETADDRESS_FromString(&localhostaddy2, "127.0.0.1", 4001);
1269
1270         printf("calling LHNET_OpenSocket_Connectionless twice to create two local sockets\n");
1271         sock1 = LHNET_OpenSocket_Connectionless(&myaddy1);
1272         sock2 = LHNET_OpenSocket_Connectionless(&myaddy2);
1273
1274         printf("calling LHNET_Write to send a packet from the first socket to the second socket\n");
1275         test1 = LHNET_Write(sock1, buffer, blen, &localhostaddy2);
1276         printf("sleeping briefly\n");
1277 #ifdef WIN32
1278         Sleep (100);
1279 #else
1280         usleep (100000);
1281 #endif
1282         printf("calling LHNET_Read on the second socket to read the packet sent from the first socket\n");
1283         test2 = LHNET_Read(sock2, buffer2, b2len - 1, &myaddy3);
1284         if (test2 > 0)
1285                 Con_Printf("socket to socket test succeeded\n");
1286         else
1287                 Con_Printf("socket to socket test failed\n");
1288
1289 #ifdef WIN32
1290         printf("press any key to exit\n");
1291         getchar();
1292 #endif
1293
1294         printf("calling LHNET_Shutdown\n");
1295         LHNET_Shutdown();
1296         printf("exiting\n");
1297         return 0;
1298 #else
1299         lhnetsocket_t *sock[16], *sendsock;
1300         int i;
1301         int numsockets;
1302         int count;
1303         int length;
1304         int port;
1305         time_t oldtime;
1306         time_t newtime;
1307         char *sendmessage;
1308         int sendmessagelength;
1309         lhnetaddress_t destaddress;
1310         lhnetaddress_t receiveaddress;
1311         lhnetaddress_t sockaddress[16];
1312         char buffer[1536], addressstring[128], addressstring2[128];
1313         if ((argc == 2 || argc == 5) && (port = atoi(argv[1])) >= 1 && port < 65535)
1314         {
1315                 printf("calling LHNET_Init()\n");
1316                 LHNET_Init();
1317
1318                 numsockets = 0;
1319                 LHNETADDRESS_FromPort(&sockaddress[numsockets++], LHNETADDRESSTYPE_LOOP, port);
1320                 LHNETADDRESS_FromPort(&sockaddress[numsockets++], LHNETADDRESSTYPE_INET4, port);
1321                 LHNETADDRESS_FromPort(&sockaddress[numsockets++], LHNETADDRESSTYPE_INET6, port+1);
1322
1323                 sendsock = NULL;
1324                 sendmessage = NULL;
1325                 sendmessagelength = 0;
1326
1327                 for (i = 0;i < numsockets;i++)
1328                 {
1329                         LHNETADDRESS_ToString(&sockaddress[i], addressstring, sizeof(addressstring), 1);
1330                         printf("calling LHNET_OpenSocket_Connectionless(<%s>)\n", addressstring);
1331                         if ((sock[i] = LHNET_OpenSocket_Connectionless(&sockaddress[i])))
1332                         {
1333                                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(sock[i]), addressstring2, sizeof(addressstring2), 1);
1334                                 printf("opened socket successfully (address \"%s\")\n", addressstring2);
1335                         }
1336                         else
1337                         {
1338                                 printf("failed to open socket\n");
1339                                 if (i == 0)
1340                                 {
1341                                         LHNET_Shutdown();
1342                                         return -1;
1343                                 }
1344                         }
1345                 }
1346                 count = 0;
1347                 if (argc == 5)
1348                 {
1349                         count = atoi(argv[2]);
1350                         if (LHNETADDRESS_FromString(&destaddress, argv[3], -1))
1351                         {
1352                                 sendmessage = argv[4];
1353                                 sendmessagelength = strlen(sendmessage);
1354                                 sendsock = NULL;
1355                                 for (i = 0;i < numsockets;i++)
1356                                         if (sock[i] && LHNETADDRESS_GetAddressType(&destaddress) == LHNETADDRESS_GetAddressType(&sockaddress[i]))
1357                                                 sendsock = sock[i];
1358                                 if (sendsock == NULL)
1359                                 {
1360                                         printf("Could not find an open socket matching the addresstype (%i) of destination address, switching to listen only mode\n", LHNETADDRESS_GetAddressType(&destaddress));
1361                                         argc = 2;
1362                                 }
1363                         }
1364                         else
1365                         {
1366                                 printf("LHNETADDRESS_FromString did not like the address \"%s\", switching to listen only mode\n", argv[3]);
1367                                 argc = 2;
1368                         }
1369                 }
1370                 printf("started, now listening for \"exit\" on the opened sockets\n");
1371                 oldtime = time(NULL);
1372                 for(;;)
1373                 {
1374 #ifdef WIN32
1375                         Sleep(1);
1376 #else
1377                         usleep(1);
1378 #endif
1379                         for (i = 0;i < numsockets;i++)
1380                         {
1381                                 if (sock[i])
1382                                 {
1383                                         length = LHNET_Read(sock[i], buffer, sizeof(buffer), &receiveaddress);
1384                                         if (length < 0)
1385                                                 printf("localsock read error: length < 0");
1386                                         else if (length > 0 && length < (int)sizeof(buffer))
1387                                         {
1388                                                 buffer[length] = 0;
1389                                                 LHNETADDRESS_ToString(&receiveaddress, addressstring, sizeof(addressstring), 1);
1390                                                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(sock[i]), addressstring2, sizeof(addressstring2), 1);
1391                                                 printf("received message \"%s\" from \"%s\" on socket \"%s\"\n", buffer, addressstring, addressstring2);
1392                                                 if (!strcmp(buffer, "exit"))
1393                                                         break;
1394                                         }
1395                                 }
1396                         }
1397                         if (i < numsockets)
1398                                 break;
1399                         if (argc == 5 && count > 0)
1400                         {
1401                                 newtime = time(NULL);
1402                                 if (newtime != oldtime)
1403                                 {
1404                                         LHNETADDRESS_ToString(&destaddress, addressstring, sizeof(addressstring), 1);
1405                                         LHNETADDRESS_ToString(LHNET_AddressFromSocket(sendsock), addressstring2, sizeof(addressstring2), 1);
1406                                         printf("calling LHNET_Write(<%s>, \"%s\", %i, <%s>)\n", addressstring2, sendmessage, sendmessagelength, addressstring);
1407                                         length = LHNET_Write(sendsock, sendmessage, sendmessagelength, &destaddress);
1408                                         if (length == sendmessagelength)
1409                                                 printf("sent successfully\n");
1410                                         else
1411                                                 printf("LH_Write failed, returned %i (length of message was %i)\n", length, strlen(argv[4]));
1412                                         oldtime = newtime;
1413                                         count--;
1414                                         if (count <= 0)
1415                                                 printf("Done sending, still listening for \"exit\"\n");
1416                                 }
1417                         }
1418                 }
1419                 for (i = 0;i < numsockets;i++)
1420                 {
1421                         if (sock[i])
1422                         {
1423                                 LHNETADDRESS_ToString(LHNET_AddressFromSocket(sock[i]), addressstring2, sizeof(addressstring2), 1);
1424                                 printf("calling LHNET_CloseSocket(<%s>)\n", addressstring2);
1425                                 LHNET_CloseSocket(sock[i]);
1426                         }
1427                 }
1428                 printf("calling LHNET_Shutdown()\n");
1429                 LHNET_Shutdown();
1430                 return 0;
1431         }
1432         printf("Testing code for lhnet.c\nusage: lhnettest <localportnumber> [<sendnumberoftimes> <sendaddress:port> <sendmessage>]\n");
1433         return -1;
1434 #endif
1435 }
1436 #endif
1437