1/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
2/* If you are missing that file, acquire a complete release at teeworlds.com. */
3
4#include "net.h"
5
6#include "dbg.h"
7#include "log.h"
8#include "mem.h"
9#include "str.h"
10#include "windows.h"
11
12#include <chrono>
13#include <iterator> // std::size
14#include <string_view>
15
16#if defined(CONF_WEBSOCKETS)
17#include <engine/shared/websockets.h>
18#endif
19
20#if defined(CONF_FAMILY_UNIX)
21#include <sys/time.h> // timeval
22#include <unistd.h> // close
23
24// UNIX net includes
25#include <arpa/inet.h>
26#include <netdb.h>
27#include <netinet/in.h>
28#include <sys/ioctl.h>
29#include <sys/socket.h>
30
31#if defined(CONF_PLATFORM_SOLARIS)
32#include <sys/filio.h> // FIONBIO
33#endif
34
35#include <cerrno>
36#elif defined(CONF_FAMILY_WINDOWS)
37#include <windows.h>
38#include <winsock2.h>
39#include <ws2tcpip.h>
40#else
41#error NOT IMPLEMENTED
42#endif
43
44static NETSTATS network_stats = {.sent_packets: 0};
45
46#ifdef CONF_PLATFORM_LINUX
47static constexpr size_t VLEN = 128;
48#endif
49static constexpr size_t PACKETSIZE = 1400;
50
51typedef struct
52{
53#ifdef CONF_PLATFORM_LINUX
54 int pos;
55 int size;
56 struct mmsghdr msgs[VLEN];
57 struct iovec iovecs[VLEN];
58 char bufs[VLEN][PACKETSIZE];
59 char sockaddrs[VLEN][128];
60#else
61 char buf[PACKETSIZE];
62#endif
63} NETSOCKET_BUFFER;
64
65static void net_buffer_init(NETSOCKET_BUFFER *buffer)
66{
67#if defined(CONF_PLATFORM_LINUX)
68 buffer->pos = 0;
69 buffer->size = 0;
70 mem_zero(block: buffer->msgs, size: sizeof(buffer->msgs));
71 mem_zero(block: buffer->iovecs, size: sizeof(buffer->iovecs));
72 mem_zero(block: buffer->sockaddrs, size: sizeof(buffer->sockaddrs));
73 for(size_t i = 0; i < VLEN; ++i)
74 {
75 buffer->iovecs[i].iov_base = buffer->bufs[i];
76 buffer->iovecs[i].iov_len = PACKETSIZE;
77 buffer->msgs[i].msg_hdr.msg_iov = &(buffer->iovecs[i]);
78 buffer->msgs[i].msg_hdr.msg_iovlen = 1;
79 buffer->msgs[i].msg_hdr.msg_name = &(buffer->sockaddrs[i]);
80 buffer->msgs[i].msg_hdr.msg_namelen = sizeof(buffer->sockaddrs[i]);
81 }
82#endif
83}
84
85#if defined(CONF_PLATFORM_LINUX)
86static void net_buffer_reinit(NETSOCKET_BUFFER *buffer)
87{
88 for(size_t i = 0; i < VLEN; i++)
89 {
90 buffer->msgs[i].msg_hdr.msg_namelen = sizeof(buffer->sockaddrs[i]);
91 }
92}
93#endif
94
95#if defined(CONF_WEBSOCKETS)
96static void net_buffer_simple(NETSOCKET_BUFFER *buffer, char **buf, int *size)
97{
98#if defined(CONF_PLATFORM_LINUX)
99 *buf = buffer->bufs[0];
100 *size = sizeof(buffer->bufs[0]);
101#else
102 *buf = buffer->buf;
103 *size = sizeof(buffer->buf);
104#endif
105}
106#endif
107
108struct NETSOCKET_INTERNAL
109{
110 int type;
111 int ipv4sock;
112 int ipv6sock;
113 int web_ipv4sock;
114 int web_ipv6sock;
115
116 NETSOCKET_BUFFER buffer;
117};
118static NETSOCKET_INTERNAL invalid_socket = {.type: NETTYPE_INVALID, .ipv4sock: -1, .ipv6sock: -1, .web_ipv4sock: -1, .web_ipv6sock: -1};
119
120const NETADDR NETADDR_ZEROED = {.type: NETTYPE_INVALID, .ip: {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, .port: 0};
121
122static void netaddr_to_sockaddr_in(const NETADDR *src, sockaddr_in *dest)
123{
124 dbg_assert((src->type & NETTYPE_IPV4) != 0, "Invalid address type '%d' for netaddr_to_sockaddr_in", src->type);
125 mem_zero(block: dest, size: sizeof(*dest));
126 dest->sin_family = AF_INET;
127 dest->sin_port = htons(hostshort: src->port);
128 mem_copy(dest: &dest->sin_addr.s_addr, source: src->ip, size: 4);
129}
130
131static void netaddr_to_sockaddr_in6(const NETADDR *src, sockaddr_in6 *dest)
132{
133 dbg_assert((src->type & NETTYPE_IPV6) != 0, "Invalid address type '%d' for netaddr_to_sockaddr_in6", src->type);
134 mem_zero(block: dest, size: sizeof(*dest));
135 dest->sin6_family = AF_INET6;
136 dest->sin6_port = htons(hostshort: src->port);
137 mem_copy(dest: &dest->sin6_addr.s6_addr, source: src->ip, size: 16);
138}
139
140static void sockaddr_to_netaddr(const sockaddr *src, socklen_t src_len, NETADDR *dst)
141{
142 *dst = NETADDR_ZEROED;
143 if(src->sa_family == AF_INET && src_len >= (socklen_t)sizeof(sockaddr_in))
144 {
145 const sockaddr_in *src_in = (const sockaddr_in *)src;
146 dst->type = NETTYPE_IPV4;
147 dst->port = htons(hostshort: src_in->sin_port);
148 static_assert(sizeof(dst->ip) >= sizeof(src_in->sin_addr.s_addr));
149 mem_copy(dest: dst->ip, source: &src_in->sin_addr.s_addr, size: sizeof(src_in->sin_addr.s_addr));
150 }
151 else if(src->sa_family == AF_INET6 && src_len >= (socklen_t)sizeof(sockaddr_in6))
152 {
153 const sockaddr_in6 *src_in6 = (const sockaddr_in6 *)src;
154 dst->type = NETTYPE_IPV6;
155 dst->port = htons(hostshort: src_in6->sin6_port);
156 static_assert(sizeof(dst->ip) >= sizeof(src_in6->sin6_addr.s6_addr));
157 mem_copy(dest: dst->ip, source: &src_in6->sin6_addr.s6_addr, size: sizeof(src_in6->sin6_addr.s6_addr));
158 }
159 else
160 {
161 log_warn("net", "Cannot convert sockaddr of family %d", src->sa_family);
162 }
163}
164
165int net_addr_comp(const NETADDR *a, const NETADDR *b)
166{
167 int diff = a->type - b->type;
168 if(diff != 0)
169 {
170 return diff;
171 }
172 diff = mem_comp(a: a->ip, b: b->ip, size: sizeof(a->ip));
173 if(diff != 0)
174 {
175 return diff;
176 }
177 return a->port - b->port;
178}
179
180bool NETADDR::operator==(const NETADDR &other) const
181{
182 return net_addr_comp(a: this, b: &other) == 0;
183}
184
185bool NETADDR::operator!=(const NETADDR &other) const
186{
187 return net_addr_comp(a: this, b: &other) != 0;
188}
189
190bool NETADDR::operator<(const NETADDR &other) const
191{
192 return net_addr_comp(a: this, b: &other) < 0;
193}
194
195size_t std::hash<NETADDR>::operator()(const NETADDR &Addr) const noexcept
196{
197 size_t seed = std::hash<unsigned int>{}(Addr.type);
198 seed ^= std::hash<std::string_view>{}(std::string_view(reinterpret_cast<const char *>(Addr.ip), sizeof(Addr.ip))) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
199 seed ^= std::hash<unsigned short>{}(Addr.port) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
200 return seed;
201}
202
203int net_addr_comp_noport(const NETADDR *a, const NETADDR *b)
204{
205 int diff = a->type - b->type;
206 if(diff != 0)
207 {
208 return diff;
209 }
210 return mem_comp(a: a->ip, b: b->ip, size: sizeof(a->ip));
211}
212
213static void net_addr_str_v6(const unsigned short ip[8], int port, char *buffer, int buffer_size)
214{
215 int longest_seq_len = 0;
216 int longest_seq_start = -1;
217 int w = 0;
218 int i;
219 {
220 int seq_len = 0;
221 int seq_start = -1;
222 // Determine longest sequence of zeros.
223 for(i = 0; i < 8 + 1; i++)
224 {
225 if(seq_start != -1)
226 {
227 if(i == 8 || ip[i] != 0)
228 {
229 if(longest_seq_len < seq_len)
230 {
231 longest_seq_len = seq_len;
232 longest_seq_start = seq_start;
233 }
234 seq_len = 0;
235 seq_start = -1;
236 }
237 else
238 {
239 seq_len += 1;
240 }
241 }
242 else
243 {
244 if(i != 8 && ip[i] == 0)
245 {
246 seq_start = i;
247 seq_len = 1;
248 }
249 }
250 }
251 }
252 if(longest_seq_len <= 1)
253 {
254 longest_seq_len = 0;
255 longest_seq_start = -1;
256 }
257 w += str_copy(dst: buffer + w, src: "[", dst_size: buffer_size - w);
258 for(i = 0; i < 8; i++)
259 {
260 if(longest_seq_start <= i && i < longest_seq_start + longest_seq_len)
261 {
262 if(i == longest_seq_start)
263 {
264 w += str_copy(dst: buffer + w, src: "::", dst_size: buffer_size - w);
265 }
266 }
267 else
268 {
269 const char *colon = (i == 0 || i == longest_seq_start + longest_seq_len) ? "" : ":";
270 w += str_format(buffer: buffer + w, buffer_size: buffer_size - w, format: "%s%x", colon, ip[i]);
271 }
272 }
273 w += str_copy(dst: buffer + w, src: "]", dst_size: buffer_size - w);
274 if(port >= 0)
275 {
276 str_format(buffer: buffer + w, buffer_size: buffer_size - w, format: ":%d", port);
277 }
278}
279
280void net_addr_str(const NETADDR *addr, char *string, int max_length, bool add_port)
281{
282 if((addr->type & (NETTYPE_IPV4 | NETTYPE_WEBSOCKET_IPV4)) != 0)
283 {
284 if(add_port)
285 {
286 str_format(buffer: string, buffer_size: max_length, format: "%d.%d.%d.%d:%d", addr->ip[0], addr->ip[1], addr->ip[2], addr->ip[3], addr->port);
287 }
288 else
289 {
290 str_format(buffer: string, buffer_size: max_length, format: "%d.%d.%d.%d", addr->ip[0], addr->ip[1], addr->ip[2], addr->ip[3]);
291 }
292 }
293 else if((addr->type & (NETTYPE_IPV6 | NETTYPE_WEBSOCKET_IPV6)) != 0)
294 {
295 unsigned short ip[8];
296 for(int i = 0; i < 8; i++)
297 {
298 ip[i] = (addr->ip[i * 2] << 8) | (addr->ip[i * 2 + 1]);
299 }
300 int port = add_port ? addr->port : -1;
301 net_addr_str_v6(ip, port, buffer: string, buffer_size: max_length);
302 }
303 else
304 {
305 dbg_assert_failed("unknown NETADDR type %d", addr->type);
306 }
307}
308
309static int parse_int(int *out, const char **str)
310{
311 int i = 0;
312 *out = 0;
313 if(!str_isnum(c: **str))
314 return -1;
315
316 i = **str - '0';
317 (*str)++;
318
319 while(true)
320 {
321 if(!str_isnum(c: **str))
322 {
323 *out = i;
324 return 0;
325 }
326
327 i = (i * 10) + (**str - '0');
328 (*str)++;
329 }
330
331 return 0;
332}
333
334static int parse_char(char c, const char **str)
335{
336 if(**str != c)
337 return -1;
338 (*str)++;
339 return 0;
340}
341
342static int parse_uint8(unsigned char *out, const char **str)
343{
344 int i;
345 if(parse_int(out: &i, str) != 0)
346 return -1;
347 if(i < 0 || i > 0xff)
348 return -1;
349 *out = i;
350 return 0;
351}
352
353static int parse_uint16(unsigned short *out, const char **str)
354{
355 int i;
356 if(parse_int(out: &i, str) != 0)
357 return -1;
358 if(i < 0 || i > 0xffff)
359 return -1;
360 *out = i;
361 return 0;
362}
363
364int net_addr_from_url(NETADDR *addr, const char *string, char *host_buf, size_t host_buf_size)
365{
366 bool sixup = false;
367 mem_zero(block: addr, size: sizeof(*addr));
368 const char *str = str_startswith(str: string, prefix: "tw-0.6+udp://");
369 if(!str && (str = str_startswith(str: string, prefix: "tw-0.7+udp://")))
370 {
371 addr->type |= NETTYPE_TW7;
372 sixup = true;
373 }
374 if(!str)
375 return 1;
376
377 int length = str_length(str);
378 int start = 0;
379 int end = length;
380 for(int i = 0; i < length; i++)
381 {
382 if(str[i] == '@')
383 {
384 if(start != 0)
385 {
386 // Two at signs.
387 return true;
388 }
389 start = i + 1;
390 }
391 else if(str[i] == '/' || str[i] == '?' || str[i] == '#')
392 {
393 end = i;
394 break;
395 }
396 }
397
398 char host[128];
399 str_truncate(dst: host, dst_size: sizeof(host), src: str + start, truncation_len: end - start);
400 if(host_buf)
401 str_copy(dst: host_buf, src: host, dst_size: host_buf_size);
402
403 int failure = net_addr_from_str(addr, string: host);
404 if(failure)
405 return failure;
406
407 if(sixup)
408 addr->type |= NETTYPE_TW7;
409
410 return failure;
411}
412
413bool net_addr_is_local(const NETADDR *addr)
414{
415 char addr_str[NETADDR_MAXSTRSIZE];
416 net_addr_str(addr, string: addr_str, max_length: sizeof(addr_str), add_port: true);
417
418 if(addr->ip[0] == 127 || addr->ip[0] == 10 || (addr->ip[0] == 192 && addr->ip[1] == 168) || (addr->ip[0] == 172 && (addr->ip[1] >= 16 && addr->ip[1] <= 31)))
419 return true;
420
421 if(str_startswith(str: addr_str, prefix: "[fe80:") || str_startswith(str: addr_str, prefix: "[::1"))
422 return true;
423
424 return false;
425}
426
427int net_addr_from_str(NETADDR *addr, const char *string)
428{
429 const char *str = string;
430 mem_zero(block: addr, size: sizeof(NETADDR));
431
432 if(str[0] == '[')
433 {
434 /* ipv6 */
435 sockaddr_in6 sa6;
436 char buf[128];
437 int i;
438 str++;
439 for(i = 0; i < 127 && str[i] && str[i] != ']'; i++)
440 buf[i] = str[i];
441 buf[i] = 0;
442 str += i;
443#if defined(CONF_FAMILY_WINDOWS)
444 {
445 int size;
446 sa6.sin6_family = AF_INET6;
447 size = (int)sizeof(sa6);
448 if(WSAStringToAddressA(buf, AF_INET6, nullptr, (sockaddr *)&sa6, &size) != 0)
449 return -1;
450 }
451#else
452 sa6.sin6_family = AF_INET6;
453
454 if(inet_pton(AF_INET6, cp: buf, buf: &sa6.sin6_addr) != 1)
455 return -1;
456#endif
457 sockaddr_to_netaddr(src: (sockaddr *)&sa6, src_len: sizeof(sa6), dst: addr);
458
459 if(*str == ']')
460 {
461 str++;
462 if(*str == ':')
463 {
464 str++;
465 if(parse_uint16(out: &addr->port, str: &str))
466 return -1;
467 }
468 else
469 {
470 addr->port = 0;
471 }
472 }
473 else
474 return -1;
475
476 return 0;
477 }
478 else
479 {
480 /* ipv4 */
481 if(parse_uint8(out: &addr->ip[0], str: &str))
482 return -1;
483 if(parse_char(c: '.', str: &str))
484 return -1;
485 if(parse_uint8(out: &addr->ip[1], str: &str))
486 return -1;
487 if(parse_char(c: '.', str: &str))
488 return -1;
489 if(parse_uint8(out: &addr->ip[2], str: &str))
490 return -1;
491 if(parse_char(c: '.', str: &str))
492 return -1;
493 if(parse_uint8(out: &addr->ip[3], str: &str))
494 return -1;
495 if(*str == ':')
496 {
497 str++;
498 if(parse_uint16(out: &addr->port, str: &str))
499 return -1;
500 }
501 if(*str != '\0')
502 return -1;
503
504 addr->type = NETTYPE_IPV4;
505 }
506
507 return 0;
508}
509
510static int priv_net_extract(const char *hostname, char *host, int max_host, int *port)
511{
512 *port = 0;
513 host[0] = 0;
514
515 if(hostname[0] == '[')
516 {
517 // ipv6 mode
518 int i;
519 for(i = 1; i < max_host && hostname[i] && hostname[i] != ']'; i++)
520 host[i - 1] = hostname[i];
521 host[i - 1] = 0;
522 if(hostname[i] != ']') // malformatted
523 return -1;
524
525 i++;
526 if(hostname[i] == ':')
527 *port = str_toint(str: hostname + i + 1);
528 }
529 else
530 {
531 // generic mode (ipv4, hostname etc)
532 int i;
533 for(i = 0; i < max_host - 1 && hostname[i] && hostname[i] != ':'; i++)
534 host[i] = hostname[i];
535 host[i] = 0;
536
537 if(hostname[i] == ':')
538 *port = str_toint(str: hostname + i + 1);
539 }
540
541 return 0;
542}
543
544static int net_host_lookup_fallback(const char *hostname, NETADDR *addr, int types, int port)
545{
546 if(str_comp_nocase(a: hostname, b: "localhost") == 0)
547 {
548 if(types == NETTYPE_IPV4)
549 {
550 dbg_assert(net_addr_from_str(addr, "127.0.0.1") == 0, "unreachable");
551 addr->port = port;
552 return 0;
553 }
554 else if(types == NETTYPE_IPV6)
555 {
556 dbg_assert(net_addr_from_str(addr, "[::1]") == 0, "unreachable");
557 addr->port = port;
558 return 0;
559 }
560 else
561 {
562 // TODO: return both IPv4 and IPv6 address
563 dbg_assert(net_addr_from_str(addr, "127.0.0.1") == 0, "unreachable");
564 addr->port = port;
565 return 0;
566 }
567 }
568 return -1;
569}
570
571static int net_host_lookup_impl(const char *hostname, NETADDR *addr, int types)
572{
573 char host[256];
574 int port = 0;
575 if(priv_net_extract(hostname, host, max_host: sizeof(host), port: &port))
576 return -1;
577
578 log_trace("host_lookup", "host='%s' port='%d' types='%d'", host, port, types);
579
580 struct addrinfo hints;
581 mem_zero(block: &hints, size: sizeof(hints));
582
583 if(types == NETTYPE_IPV4)
584 hints.ai_family = AF_INET;
585 else if(types == NETTYPE_IPV6)
586 hints.ai_family = AF_INET6;
587 else
588 hints.ai_family = AF_UNSPEC;
589
590 struct addrinfo *result = nullptr;
591 int e = getaddrinfo(name: host, service: nullptr, req: &hints, pai: &result);
592 if(!result)
593 {
594 return net_host_lookup_fallback(hostname, addr, types, port);
595 }
596
597 if(e != 0)
598 {
599 freeaddrinfo(ai: result);
600 return net_host_lookup_fallback(hostname, addr, types, port);
601 }
602
603 sockaddr_to_netaddr(src: result->ai_addr, src_len: result->ai_addrlen, dst: addr);
604 addr->port = port;
605 freeaddrinfo(ai: result);
606 return 0;
607}
608
609int net_host_lookup(const char *hostname, NETADDR *addr, int types)
610{
611 const char *ws_hostname = str_startswith(str: hostname, prefix: "ws://");
612 if(ws_hostname)
613 {
614 if((types & (NETTYPE_WEBSOCKET_IPV4 | NETTYPE_WEBSOCKET_IPV6)) == 0)
615 {
616 return -1;
617 }
618 int result = net_host_lookup_impl(hostname: ws_hostname, addr, types: types & ~(NETTYPE_WEBSOCKET_IPV4 | NETTYPE_WEBSOCKET_IPV6));
619 if(result == 0)
620 {
621 if(addr->type == NETTYPE_IPV4)
622 {
623 addr->type = NETTYPE_WEBSOCKET_IPV4;
624 }
625 else if(addr->type == NETTYPE_IPV6)
626 {
627 addr->type = NETTYPE_WEBSOCKET_IPV6;
628 }
629 }
630 return result;
631 }
632 return net_host_lookup_impl(hostname, addr, types: types & ~(NETTYPE_WEBSOCKET_IPV4 | NETTYPE_WEBSOCKET_IPV6));
633}
634
635void net_init()
636{
637#if defined(CONF_FAMILY_WINDOWS)
638 WSADATA wsa_data;
639 dbg_assert(WSAStartup(MAKEWORD(1, 1), &wsa_data) == 0, "WSAStartup failure");
640#endif
641#if defined(CONF_WEBSOCKETS)
642 websocket_init();
643#endif
644}
645
646int net_errno()
647{
648#if defined(CONF_FAMILY_WINDOWS)
649 return WSAGetLastError();
650#else
651 return errno;
652#endif
653}
654
655std::string net_error_message()
656{
657 const int error = net_errno();
658#if defined(CONF_FAMILY_WINDOWS)
659 const std::string message = windows_format_system_message(error);
660 return std::to_string(error) + " '" + message + "'";
661#else
662 return std::to_string(val: error) + " '" + strerror(errnum: error) + "'";
663#endif
664}
665
666void net_stats(NETSTATS *stats_inout)
667{
668 *stats_inout = network_stats;
669}
670
671int net_socket_type(NETSOCKET sock)
672{
673 return sock->type;
674}
675
676static int net_set_blocking_impl(NETSOCKET sock, bool blocking)
677{
678 unsigned long mode = blocking ? 0 : 1;
679 const char *mode_str = blocking ? "blocking" : "non-blocking";
680 int sockets[] = {sock->ipv4sock, sock->ipv6sock};
681 const char *socket_str[] = {"IPv4", "IPv6"};
682
683 for(size_t i = 0; i < std::size(sockets); ++i)
684 {
685 if(sockets[i] >= 0)
686 {
687#if defined(CONF_FAMILY_WINDOWS)
688 if(ioctlsocket(sockets[i], FIONBIO, &mode) != NO_ERROR)
689 {
690 log_error("net", "Setting %s mode for %s socket failed (%s)", socket_str[i], mode_str, net_error_message().c_str());
691 }
692#else
693 if(ioctl(fd: sockets[i], FIONBIO, &mode) == -1)
694 {
695 log_error("net", "Setting %s mode for %s socket failed (%s)", socket_str[i], mode_str, net_error_message().c_str());
696 }
697#endif
698 }
699 }
700
701 return 0;
702}
703
704int net_set_non_blocking(NETSOCKET sock)
705{
706 return net_set_blocking_impl(sock, blocking: false);
707}
708
709int net_set_blocking(NETSOCKET sock)
710{
711 return net_set_blocking_impl(sock, blocking: true);
712}
713
714int net_would_block()
715{
716#if defined(CONF_FAMILY_WINDOWS)
717 return net_errno() == WSAEWOULDBLOCK;
718#else
719 return net_errno() == EWOULDBLOCK;
720#endif
721}
722
723int net_socket_read_wait(NETSOCKET sock, std::chrono::nanoseconds nanoseconds)
724{
725 const int64_t microseconds = std::chrono::duration_cast<std::chrono::microseconds>(d: nanoseconds).count();
726 dbg_assert(microseconds >= 0, "Negative wait duration %" PRId64 " not allowed", microseconds);
727
728 fd_set readfds;
729 FD_ZERO(&readfds);
730
731 int maxfd = -1;
732 if(sock->ipv4sock >= 0)
733 {
734 FD_SET(sock->ipv4sock, &readfds);
735 maxfd = sock->ipv4sock;
736 }
737 if(sock->ipv6sock >= 0)
738 {
739 FD_SET(sock->ipv6sock, &readfds);
740 maxfd = std::max(a: maxfd, b: sock->ipv6sock);
741 }
742#if defined(CONF_WEBSOCKETS)
743 if(sock->web_ipv4sock >= 0)
744 {
745 maxfd = std::max(a: maxfd, b: websocket_fd_set(socket: sock->web_ipv4sock, set: &readfds));
746 }
747 if(sock->web_ipv6sock >= 0)
748 {
749 maxfd = std::max(a: maxfd, b: websocket_fd_set(socket: sock->web_ipv6sock, set: &readfds));
750 }
751#endif
752 if(maxfd < 0)
753 {
754 return 0;
755 }
756
757 struct timeval tv;
758 tv.tv_sec = microseconds / 1000000;
759 tv.tv_usec = microseconds % 1000000;
760 // don't care about writefds and exceptfds
761 select(nfds: maxfd + 1, readfds: &readfds, writefds: nullptr, exceptfds: nullptr, timeout: &tv);
762
763 if(sock->ipv4sock >= 0 && FD_ISSET(sock->ipv4sock, &readfds))
764 {
765 return 1;
766 }
767 if(sock->ipv6sock >= 0 && FD_ISSET(sock->ipv6sock, &readfds))
768 {
769 return 1;
770 }
771#if defined(CONF_WEBSOCKETS)
772 if(sock->web_ipv4sock >= 0 && websocket_fd_get(socket: sock->web_ipv4sock, set: &readfds))
773 {
774 return 1;
775 }
776 if(sock->web_ipv6sock >= 0 && websocket_fd_get(socket: sock->web_ipv6sock, set: &readfds))
777 {
778 return 1;
779 }
780#endif
781 return 0;
782}
783
784static void priv_net_close_socket(int sock)
785{
786#if defined(CONF_FAMILY_WINDOWS)
787 dbg_assert(closesocket(sock) == 0, "closesocket failure (%s)", net_error_message().c_str());
788#else
789 dbg_assert(close(sock) == 0, "close failure (%s)", net_error_message().c_str());
790#endif
791}
792
793static void priv_net_close_all_sockets(NETSOCKET sock)
794{
795 if(sock->ipv4sock >= 0)
796 {
797 priv_net_close_socket(sock: sock->ipv4sock);
798 sock->ipv4sock = -1;
799 sock->type &= ~NETTYPE_IPV4;
800 }
801
802#if defined(CONF_WEBSOCKETS)
803 if(sock->web_ipv4sock >= 0)
804 {
805 websocket_destroy(socket: sock->web_ipv4sock);
806 sock->web_ipv4sock = -1;
807 sock->type &= ~NETTYPE_WEBSOCKET_IPV4;
808 }
809#endif
810
811 if(sock->ipv6sock >= 0)
812 {
813 priv_net_close_socket(sock: sock->ipv6sock);
814 sock->ipv6sock = -1;
815 sock->type &= ~NETTYPE_IPV6;
816 }
817
818#if defined(CONF_WEBSOCKETS)
819 if(sock->web_ipv6sock >= 0)
820 {
821 websocket_destroy(socket: sock->web_ipv6sock);
822 sock->web_ipv6sock = -1;
823 sock->type &= ~NETTYPE_WEBSOCKET_IPV6;
824 }
825#endif
826
827 free(ptr: sock);
828}
829
830static int priv_net_create_socket(int domain, int type, const NETADDR *bindaddr)
831{
832 int sock = socket(domain: domain, type: type, protocol: 0);
833 if(sock < 0)
834 {
835 log_error("net", "Failed to create socket with domain %d and type %d (%s)", domain, type, net_error_message().c_str());
836 return -1;
837 }
838
839#if defined(CONF_FAMILY_UNIX)
840 // On TCP sockets set SO_REUSEADDR to fix port rebind on restart
841 if(domain == AF_INET && type == SOCK_STREAM)
842 {
843 int reuse_addr = 1;
844 if(setsockopt(fd: sock, SOL_SOCKET, SO_REUSEADDR, optval: (const char *)&reuse_addr, optlen: sizeof(reuse_addr)) != 0)
845 {
846 log_error("net", "Setting SO_REUSEADDR failed with domain %d and type %d (%s)", domain, type, net_error_message().c_str());
847 }
848 }
849#elif defined(CONF_FAMILY_WINDOWS)
850 {
851 // Ensure exclusive use of address, otherwise it's possible on Windows to bind to the same address and port with another socket.
852 // See https://learn.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse (last update 06/14/2022)
853 int exclusive_addr_use = 1;
854 if(setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char *)&exclusive_addr_use, sizeof(exclusive_addr_use)) != 0)
855 {
856 log_error("net", "Setting SO_EXCLUSIVEADDRUSE failed with domain %d and type %d (%s)", domain, type, net_error_message().c_str());
857 }
858 }
859#endif
860
861 // Set to IPv6-only if that's what we are creating, to ensure that dual-stack does not block the same IPv4 port.
862#if defined(IPV6_V6ONLY)
863 if(domain == AF_INET6)
864 {
865 int ipv6only = 1;
866 if(setsockopt(fd: sock, IPPROTO_IPV6, IPV6_V6ONLY, optval: (const char *)&ipv6only, optlen: sizeof(ipv6only)) != 0)
867 {
868 log_error("net", "Setting IPV6_V6ONLY failed with domain %d and type %d (%s)", domain, type, net_error_message().c_str());
869 }
870 }
871#endif
872
873 sockaddr_storage addr;
874 socklen_t addr_len;
875 if(bindaddr->type == NETTYPE_IPV4)
876 {
877 netaddr_to_sockaddr_in(src: bindaddr, dest: (sockaddr_in *)&addr);
878 addr_len = sizeof(sockaddr_in);
879 }
880 else if(bindaddr->type == NETTYPE_IPV6)
881 {
882 netaddr_to_sockaddr_in6(src: bindaddr, dest: (sockaddr_in6 *)&addr);
883 addr_len = sizeof(sockaddr_in6);
884 }
885 else
886 {
887 dbg_assert_failed("socket type invalid: %d", type);
888 }
889
890 if(bind(fd: sock, addr: (sockaddr *)&addr, len: addr_len) != 0)
891 {
892 log_error("net", "Failed to bind socket with domain %d and type %d (%s)", domain, type, net_error_message().c_str());
893 priv_net_close_socket(sock);
894 return -1;
895 }
896
897 return sock;
898}
899
900NETSOCKET net_udp_create(NETADDR bindaddr)
901{
902 NETSOCKET sock = (NETSOCKET_INTERNAL *)malloc(size: sizeof(*sock));
903 *sock = invalid_socket;
904
905 if(bindaddr.type & NETTYPE_IPV4)
906 {
907 NETADDR bindaddr_ipv4 = bindaddr;
908 bindaddr_ipv4.type = NETTYPE_IPV4;
909 const int socket = priv_net_create_socket(AF_INET, SOCK_DGRAM, bindaddr: &bindaddr_ipv4);
910 if(socket >= 0)
911 {
912 sock->type |= NETTYPE_IPV4;
913 sock->ipv4sock = socket;
914
915 // Set broadcast
916 {
917 int broadcast = 1;
918 if(setsockopt(fd: socket, SOL_SOCKET, SO_BROADCAST, optval: (const char *)&broadcast, optlen: sizeof(broadcast)) != 0)
919 {
920 log_error("net", "Setting SO_BROADCAST on IPv4 failed (%s)", net_error_message().c_str());
921 }
922 }
923
924 // Set DSCP/TOS
925 {
926 int iptos = 0x10; // IPTOS_LOWDELAY
927 if(setsockopt(fd: socket, IPPROTO_IP, IP_TOS, optval: (const char *)&iptos, optlen: sizeof(iptos)) != 0)
928 {
929 log_error("net", "Setting IP_TOS on IPv4 failed (%s)", net_error_message().c_str());
930 }
931 }
932 }
933 }
934
935#if defined(CONF_WEBSOCKETS)
936 if(bindaddr.type & NETTYPE_WEBSOCKET_IPV4)
937 {
938 NETADDR bindaddr_websocket_ipv4 = bindaddr;
939 bindaddr_websocket_ipv4.type = NETTYPE_WEBSOCKET_IPV4;
940 const int socket = websocket_create(bindaddr: &bindaddr_websocket_ipv4);
941 if(socket >= 0)
942 {
943 sock->type |= NETTYPE_WEBSOCKET_IPV4;
944 sock->web_ipv4sock = socket;
945 }
946 }
947#endif
948
949 if(bindaddr.type & NETTYPE_IPV6)
950 {
951 NETADDR bindaddr_ipv6 = bindaddr;
952 bindaddr_ipv6.type = NETTYPE_IPV6;
953 const int socket = priv_net_create_socket(AF_INET6, SOCK_DGRAM, bindaddr: &bindaddr_ipv6);
954 if(socket >= 0)
955 {
956 sock->type |= NETTYPE_IPV6;
957 sock->ipv6sock = socket;
958
959 // Set broadcast
960 {
961 int broadcast = 1;
962 if(setsockopt(fd: socket, SOL_SOCKET, SO_BROADCAST, optval: (const char *)&broadcast, optlen: sizeof(broadcast)) != 0)
963 {
964 log_error("net", "Setting SO_BROADCAST on IPv6 failed (%s)", net_error_message().c_str());
965 }
966 }
967
968 // Set DSCP/TOS
969 // TODO: setting IP_TOS on ipv6 with setsockopt is not supported on Windows, see https://github.com/ddnet/ddnet/issues/7605
970#if !defined(CONF_FAMILY_WINDOWS)
971 {
972 int iptos = 0x10; // IPTOS_LOWDELAY
973 if(setsockopt(fd: socket, IPPROTO_IP, IP_TOS, optval: (const char *)&iptos, optlen: sizeof(iptos)) != 0)
974 {
975 log_error("net", "Setting IP_TOS on IPv6 failed (%s)", net_error_message().c_str());
976 }
977 }
978#endif
979 }
980 }
981
982#if defined(CONF_WEBSOCKETS)
983 if(bindaddr.type & NETTYPE_WEBSOCKET_IPV6)
984 {
985 NETADDR bindaddr_websocket_ipv6 = bindaddr;
986 bindaddr_websocket_ipv6.type = NETTYPE_WEBSOCKET_IPV6;
987 const int socket = websocket_create(bindaddr: &bindaddr_websocket_ipv6);
988 if(socket >= 0)
989 {
990 sock->type |= NETTYPE_WEBSOCKET_IPV6;
991 sock->web_ipv6sock = socket;
992 }
993 }
994#endif
995
996 if(sock->type == NETTYPE_INVALID)
997 {
998 free(ptr: sock);
999 sock = nullptr;
1000 }
1001 else
1002 {
1003 net_set_non_blocking(sock);
1004 net_buffer_init(buffer: &sock->buffer);
1005 }
1006
1007 return sock;
1008}
1009
1010int net_udp_send(NETSOCKET sock, const NETADDR *addr, const void *data, int size)
1011{
1012 int d = -1;
1013
1014 if(addr->type & NETTYPE_IPV4)
1015 {
1016 if(sock->ipv4sock >= 0)
1017 {
1018 sockaddr_in sa;
1019 if(addr->type & NETTYPE_LINK_BROADCAST)
1020 {
1021 mem_zero(block: &sa, size: sizeof(sa));
1022 sa.sin_port = htons(hostshort: addr->port);
1023 sa.sin_family = AF_INET;
1024 sa.sin_addr.s_addr = INADDR_BROADCAST;
1025 }
1026 else
1027 {
1028 netaddr_to_sockaddr_in(src: addr, dest: &sa);
1029 }
1030
1031 d = sendto(fd: sock->ipv4sock, buf: (const char *)data, n: size, flags: 0, addr: (sockaddr *)&sa, addr_len: sizeof(sa));
1032 }
1033 else
1034 {
1035 log_error("net", "Cannot send IPv4 traffic to this socket");
1036 }
1037 }
1038
1039#if defined(CONF_WEBSOCKETS)
1040 if(addr->type & NETTYPE_WEBSOCKET_IPV4)
1041 {
1042 if(sock->web_ipv4sock >= 0)
1043 {
1044 if(addr->type & NETTYPE_LINK_BROADCAST)
1045 {
1046 log_error("net", "Cannot send broadcasts to Websocket IPv4");
1047 }
1048 else
1049 {
1050 d = websocket_send(socket: sock->web_ipv4sock, data: (const unsigned char *)data, size, addr);
1051 }
1052 }
1053 else
1054 {
1055 log_error("net", "Cannot send Websocket IPv4 traffic to this socket");
1056 }
1057 }
1058#endif
1059
1060 if(addr->type & NETTYPE_IPV6)
1061 {
1062 if(sock->ipv6sock >= 0)
1063 {
1064 sockaddr_in6 sa;
1065 if(addr->type & NETTYPE_LINK_BROADCAST)
1066 {
1067 mem_zero(block: &sa, size: sizeof(sa));
1068 sa.sin6_port = htons(hostshort: addr->port);
1069 sa.sin6_family = AF_INET6;
1070 sa.sin6_addr.s6_addr[0] = 0xff; /* multicast */
1071 sa.sin6_addr.s6_addr[1] = 0x02; /* link local scope */
1072 sa.sin6_addr.s6_addr[15] = 1; /* all nodes */
1073 }
1074 else
1075 {
1076 netaddr_to_sockaddr_in6(src: addr, dest: &sa);
1077 }
1078
1079 d = sendto(fd: sock->ipv6sock, buf: (const char *)data, n: size, flags: 0, addr: (sockaddr *)&sa, addr_len: sizeof(sa));
1080 }
1081 else
1082 {
1083 log_error("net", "Cannot send IPv6 traffic to this socket");
1084 }
1085 }
1086
1087#if defined(CONF_WEBSOCKETS)
1088 if(addr->type & NETTYPE_WEBSOCKET_IPV6)
1089 {
1090 if(sock->web_ipv6sock >= 0)
1091 {
1092 if(addr->type & NETTYPE_LINK_BROADCAST)
1093 {
1094 log_error("net", "Cannot send broadcasts to Websocket IPv6");
1095 }
1096 else
1097 {
1098 d = websocket_send(socket: sock->web_ipv6sock, data: (const unsigned char *)data, size, addr);
1099 }
1100 }
1101 else
1102 {
1103 log_error("net", "Cannot send Websocket IPv6 traffic to this socket");
1104 }
1105 }
1106#endif
1107
1108 network_stats.sent_bytes += size;
1109 network_stats.sent_packets++;
1110 return d;
1111}
1112
1113int net_udp_recv(NETSOCKET sock, NETADDR *addr, unsigned char **data)
1114{
1115 static const auto &&update_stats = [](int bytes) {
1116 network_stats.recv_bytes += bytes;
1117 network_stats.recv_packets++;
1118 };
1119
1120 int bytes = 0;
1121#if defined(CONF_PLATFORM_LINUX)
1122 if(sock->ipv4sock >= 0)
1123 {
1124 if(sock->buffer.pos >= sock->buffer.size)
1125 {
1126 net_buffer_reinit(buffer: &sock->buffer);
1127 sock->buffer.size = recvmmsg(fd: sock->ipv4sock, vmessages: sock->buffer.msgs, vlen: VLEN, flags: 0, tmo: nullptr);
1128 sock->buffer.pos = 0;
1129 }
1130 }
1131
1132 if(sock->ipv6sock >= 0)
1133 {
1134 if(sock->buffer.pos >= sock->buffer.size)
1135 {
1136 net_buffer_reinit(buffer: &sock->buffer);
1137 sock->buffer.size = recvmmsg(fd: sock->ipv6sock, vmessages: sock->buffer.msgs, vlen: VLEN, flags: 0, tmo: nullptr);
1138 sock->buffer.pos = 0;
1139 }
1140 }
1141
1142 if(sock->buffer.pos < sock->buffer.size)
1143 {
1144 sockaddr_to_netaddr(src: (sockaddr *)&(sock->buffer.sockaddrs[sock->buffer.pos]), src_len: sizeof(sock->buffer.sockaddrs[sock->buffer.pos]), dst: addr);
1145 bytes = sock->buffer.msgs[sock->buffer.pos].msg_len;
1146 *data = (unsigned char *)sock->buffer.bufs[sock->buffer.pos];
1147 sock->buffer.pos++;
1148 update_stats(bytes);
1149 return bytes;
1150 }
1151#else
1152 if(sock->ipv4sock >= 0)
1153 {
1154 sockaddr_storage recv_addr;
1155 socklen_t fromlen = sizeof(recv_addr);
1156 bytes = recvfrom(sock->ipv4sock, sock->buffer.buf, sizeof(sock->buffer.buf), 0, (sockaddr *)&recv_addr, &fromlen);
1157 *data = (unsigned char *)sock->buffer.buf;
1158 if(bytes > 0)
1159 {
1160 sockaddr_to_netaddr((sockaddr *)&recv_addr, fromlen, addr);
1161 update_stats(bytes);
1162 return bytes;
1163 }
1164 }
1165
1166 if(sock->ipv6sock >= 0)
1167 {
1168 sockaddr_storage recv_addr;
1169 socklen_t fromlen = sizeof(recv_addr);
1170 bytes = recvfrom(sock->ipv6sock, sock->buffer.buf, sizeof(sock->buffer.buf), 0, (sockaddr *)&recv_addr, &fromlen);
1171 *data = (unsigned char *)sock->buffer.buf;
1172 if(bytes > 0)
1173 {
1174 sockaddr_to_netaddr((sockaddr *)&recv_addr, fromlen, addr);
1175 update_stats(bytes);
1176 return bytes;
1177 }
1178 }
1179#endif
1180
1181#if defined(CONF_WEBSOCKETS)
1182 if(sock->web_ipv4sock >= 0)
1183 {
1184 char *buf;
1185 int size;
1186 net_buffer_simple(buffer: &sock->buffer, buf: &buf, size: &size);
1187 bytes = websocket_recv(socket: sock->web_ipv4sock, data: (unsigned char *)buf, maxsize: size, addr);
1188 *data = (unsigned char *)buf;
1189 if(bytes > 0)
1190 {
1191 update_stats(bytes);
1192 return bytes;
1193 }
1194 }
1195
1196 if(sock->web_ipv6sock >= 0)
1197 {
1198 char *buf;
1199 int size;
1200 net_buffer_simple(buffer: &sock->buffer, buf: &buf, size: &size);
1201 bytes = websocket_recv(socket: sock->web_ipv6sock, data: (unsigned char *)buf, maxsize: size, addr);
1202 *data = (unsigned char *)buf;
1203 if(bytes > 0)
1204 {
1205 update_stats(bytes);
1206 return bytes;
1207 }
1208 }
1209#endif
1210
1211 return bytes < 0 ? -1 : 0;
1212}
1213
1214void net_udp_close(NETSOCKET sock)
1215{
1216 priv_net_close_all_sockets(sock);
1217}
1218
1219NETSOCKET net_tcp_create(NETADDR bindaddr)
1220{
1221 NETSOCKET sock = (NETSOCKET_INTERNAL *)malloc(size: sizeof(*sock));
1222 *sock = invalid_socket;
1223
1224 if(bindaddr.type & NETTYPE_IPV4)
1225 {
1226 NETADDR bindaddr_ipv4 = bindaddr;
1227 bindaddr_ipv4.type = NETTYPE_IPV4;
1228 const int socket4 = priv_net_create_socket(AF_INET, SOCK_STREAM, bindaddr: &bindaddr_ipv4);
1229 if(socket4 >= 0)
1230 {
1231 sock->type |= NETTYPE_IPV4;
1232 sock->ipv4sock = socket4;
1233 }
1234 }
1235
1236 if(bindaddr.type & NETTYPE_IPV6)
1237 {
1238 NETADDR bindaddr_ipv6 = bindaddr;
1239 bindaddr_ipv6.type = NETTYPE_IPV6;
1240 const int socket6 = priv_net_create_socket(AF_INET6, SOCK_STREAM, bindaddr: &bindaddr_ipv6);
1241 if(socket6 >= 0)
1242 {
1243 sock->type |= NETTYPE_IPV6;
1244 sock->ipv6sock = socket6;
1245 }
1246 }
1247
1248 if(sock->type == NETTYPE_INVALID)
1249 {
1250 free(ptr: sock);
1251 sock = nullptr;
1252 }
1253
1254 return sock;
1255}
1256
1257int net_tcp_listen(NETSOCKET sock, int backlog)
1258{
1259 int err = -1;
1260 if(sock->ipv4sock >= 0)
1261 {
1262 err = listen(fd: sock->ipv4sock, n: backlog);
1263 }
1264 if(sock->ipv6sock >= 0)
1265 {
1266 err = listen(fd: sock->ipv6sock, n: backlog);
1267 }
1268 return err;
1269}
1270
1271int net_tcp_accept(NETSOCKET sock, NETSOCKET *new_sock, NETADDR *a)
1272{
1273 *new_sock = nullptr;
1274
1275 if(sock->ipv4sock >= 0)
1276 {
1277 sockaddr_storage addr;
1278 socklen_t sockaddr_len = sizeof(addr);
1279
1280 int s = accept(fd: sock->ipv4sock, addr: (sockaddr *)&addr, addr_len: &sockaddr_len);
1281 if(s != -1)
1282 {
1283 sockaddr_to_netaddr(src: (sockaddr *)&addr, src_len: sockaddr_len, dst: a);
1284
1285 *new_sock = (NETSOCKET_INTERNAL *)malloc(size: sizeof(**new_sock));
1286 **new_sock = invalid_socket;
1287 (*new_sock)->type = NETTYPE_IPV4;
1288 (*new_sock)->ipv4sock = s;
1289 return s;
1290 }
1291 }
1292
1293 if(sock->ipv6sock >= 0)
1294 {
1295 sockaddr_storage addr;
1296 socklen_t sockaddr_len = sizeof(addr);
1297
1298 int s = accept(fd: sock->ipv6sock, addr: (sockaddr *)&addr, addr_len: &sockaddr_len);
1299 if(s != -1)
1300 {
1301 *new_sock = (NETSOCKET_INTERNAL *)malloc(size: sizeof(**new_sock));
1302 **new_sock = invalid_socket;
1303 sockaddr_to_netaddr(src: (sockaddr *)&addr, src_len: sockaddr_len, dst: a);
1304 (*new_sock)->type = NETTYPE_IPV6;
1305 (*new_sock)->ipv6sock = s;
1306 return s;
1307 }
1308 }
1309
1310 return -1;
1311}
1312
1313int net_tcp_connect(NETSOCKET sock, const NETADDR *a)
1314{
1315 if(a->type & NETTYPE_IPV4)
1316 {
1317 if(sock->ipv4sock < 0)
1318 return -2;
1319 sockaddr_in addr;
1320 netaddr_to_sockaddr_in(src: a, dest: &addr);
1321 return connect(fd: sock->ipv4sock, addr: (sockaddr *)&addr, len: sizeof(addr));
1322 }
1323
1324 if(a->type & NETTYPE_IPV6)
1325 {
1326 if(sock->ipv6sock < 0)
1327 return -2;
1328 sockaddr_in6 addr;
1329 netaddr_to_sockaddr_in6(src: a, dest: &addr);
1330 return connect(fd: sock->ipv6sock, addr: (sockaddr *)&addr, len: sizeof(addr));
1331 }
1332
1333 return -1;
1334}
1335
1336int net_tcp_connect_non_blocking(NETSOCKET sock, NETADDR bindaddr)
1337{
1338 net_set_non_blocking(sock);
1339 int res = net_tcp_connect(sock, a: &bindaddr);
1340 net_set_blocking(sock);
1341 return res;
1342}
1343
1344int net_tcp_send(NETSOCKET sock, const void *data, int size)
1345{
1346 int bytes = -1;
1347
1348 if(sock->ipv4sock >= 0)
1349 {
1350 bytes = send(fd: sock->ipv4sock, buf: (const char *)data, n: size, flags: 0);
1351 }
1352 if(sock->ipv6sock >= 0)
1353 {
1354 bytes = send(fd: sock->ipv6sock, buf: (const char *)data, n: size, flags: 0);
1355 }
1356
1357 return bytes;
1358}
1359
1360int net_tcp_recv(NETSOCKET sock, void *data, int maxsize)
1361{
1362 int bytes = -1;
1363
1364 if(sock->ipv4sock >= 0)
1365 {
1366 bytes = recv(fd: sock->ipv4sock, buf: (char *)data, n: maxsize, flags: 0);
1367 }
1368 if(sock->ipv6sock >= 0)
1369 {
1370 bytes = recv(fd: sock->ipv6sock, buf: (char *)data, n: maxsize, flags: 0);
1371 }
1372
1373 return bytes;
1374}
1375
1376void net_tcp_close(NETSOCKET sock)
1377{
1378 priv_net_close_all_sockets(sock);
1379}
1380
1381#if defined(CONF_FAMILY_UNIX)
1382UNIXSOCKET net_unix_create_unnamed()
1383{
1384 return socket(AF_UNIX, SOCK_DGRAM, protocol: 0);
1385}
1386
1387int net_unix_send(UNIXSOCKET sock, UNIXSOCKETADDR *addr, void *data, int size)
1388{
1389 return sendto(fd: sock, buf: data, n: size, flags: 0, addr: (sockaddr *)addr, addr_len: sizeof(*addr));
1390}
1391
1392void net_unix_set_addr(UNIXSOCKETADDR *addr, const char *path)
1393{
1394 mem_zero(block: addr, size: sizeof(*addr));
1395 addr->sun_family = AF_UNIX;
1396 str_copy(dst&: addr->sun_path, src: path);
1397}
1398
1399void net_unix_close(UNIXSOCKET sock)
1400{
1401 close(fd: sock);
1402}
1403#endif
1404