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