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