]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/basic/socket-util.c
projects / thirdparty / systemd.git / blob
? search:


13537593cfe130905ba1fd9f3d5a88cf463d5d3a
[thirdparty/systemd.git] / src / basic / socket-util.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <fcntl.h>
4 #include <linux/if.h>
5 #include <linux/if_arp.h>
6 #include <linux/if_ether.h>
7 #include <linux/if_infiniband.h>
8 #include <linux/pkt_sched.h>
9 #include <mqueue.h>
10 #include <net/if.h>
11 #include <netdb.h>
12 #include <netinet/ip.h>
13 #include <poll.h>
14 #include <stdio.h>
15 #include <sys/ioctl.h>
16 #include <sys/stat.h>
17 #include <unistd.h>
18
19 #include "alloc-util.h"
20 #include "errno-util.h"
21 #include "escape.h"
22 #include "fd-util.h"
23 #include "format-ifname.h"
24 #include "format-util.h"
25 #include "fs-util.h"
26 #include "in-addr-util.h"
27 #include "io-util.h"
28 #include "log.h"
29 #include "memory-util.h"
30 #include "parse-util.h"
31 #include "path-util.h"
32 #include "pidref.h"
33 #include "process-util.h"
34 #include "random-util.h"
35 #include "socket-util.h"
36 #include "sparse-endian.h"
37 #include "string-table.h"
38 #include "string-util.h"
39 #include "strv.h"
40 #include "sysctl-util.h"
41 #include "tmpfile-util.h"
42 #include "xattr-util.h"
43
44 #if ENABLE_IDN
45 # define IDN_FLAGS NI_IDN
46 #else
47 # define IDN_FLAGS 0
48 #endif
49
50 static const char* const socket_address_type_table[] = {
51 [SOCK_STREAM] = "Stream",
52 [SOCK_DGRAM] = "Datagram",
53 [SOCK_RAW] = "Raw",
54 [SOCK_RDM] = "ReliableDatagram",
55 [SOCK_SEQPACKET] = "SequentialPacket",
56 [SOCK_DCCP] = "DatagramCongestionControl",
57 };
58
59 DEFINE_STRING_TABLE_LOOKUP(socket_address_type, int);
60
61 int socket_address_verify(const SocketAddress *a, bool strict) {
62 assert(a);
63
64 /* With 'strict' we enforce additional sanity constraints which are not set by the standard,
65 * but should only apply to sockets we create ourselves. */
66
67 switch (socket_address_family(a)) {
68
69 case AF_INET:
70 if (a->size != sizeof(struct sockaddr_in))
71 return -EINVAL;
72
73 if (a->sockaddr.in.sin_port == 0)
74 return -EINVAL;
75
76 if (!IN_SET(a->type, 0, SOCK_STREAM, SOCK_DGRAM))
77 return -EINVAL;
78
79 return 0;
80
81 case AF_INET6:
82 if (a->size != sizeof(struct sockaddr_in6))
83 return -EINVAL;
84
85 if (a->sockaddr.in6.sin6_port == 0)
86 return -EINVAL;
87
88 if (!IN_SET(a->type, 0, SOCK_STREAM, SOCK_DGRAM))
89 return -EINVAL;
90
91 return 0;
92
93 case AF_UNIX:
94 if (a->size < offsetof(struct sockaddr_un, sun_path))
95 return -EINVAL;
96 if (a->size > sizeof(struct sockaddr_un) + !strict)
97 /* If !strict, allow one extra byte, since getsockname() on Linux will append
98 * a NUL byte if we have path sockets that are above sun_path's full size. */
99 return -EINVAL;
100
101 if (a->size > offsetof(struct sockaddr_un, sun_path) &&
102 a->sockaddr.un.sun_path[0] != 0 &&
103 strict) {
104 /* Only validate file system sockets here, and only in strict mode */
105 const char *e;
106
107 e = memchr(a->sockaddr.un.sun_path, 0, sizeof(a->sockaddr.un.sun_path));
108 if (e) {
109 /* If there's an embedded NUL byte, make sure the size of the socket address matches it */
110 if (a->size != offsetof(struct sockaddr_un, sun_path) + (e - a->sockaddr.un.sun_path) + 1)
111 return -EINVAL;
112 } else {
113 /* If there's no embedded NUL byte, then the size needs to match the whole
114 * structure or the structure with one extra NUL byte suffixed. (Yeah, Linux is awful,
115 * and considers both equivalent: getsockname() even extends sockaddr_un beyond its
116 * size if the path is non NUL terminated.) */
117 if (!IN_SET(a->size, sizeof(a->sockaddr.un.sun_path), sizeof(a->sockaddr.un.sun_path)+1))
118 return -EINVAL;
119 }
120 }
121
122 if (!IN_SET(a->type, 0, SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET))
123 return -EINVAL;
124
125 return 0;
126
127 case AF_NETLINK:
128
129 if (a->size != sizeof(struct sockaddr_nl))
130 return -EINVAL;
131
132 if (!IN_SET(a->type, 0, SOCK_RAW, SOCK_DGRAM))
133 return -EINVAL;
134
135 return 0;
136
137 case AF_VSOCK:
138 if (a->size != sizeof(struct sockaddr_vm))
139 return -EINVAL;
140
141 if (!IN_SET(a->type, 0, SOCK_STREAM, SOCK_DGRAM))
142 return -EINVAL;
143
144 return 0;
145
146 default:
147 return -EAFNOSUPPORT;
148 }
149 }
150
151 int socket_address_print(const SocketAddress *a, char **ret) {
152 int r;
153
154 assert(a);
155 assert(ret);
156
157 r = socket_address_verify(a, false); /* We do non-strict validation, because we want to be
158 * able to pretty-print any socket the kernel considers
159 * valid. We still need to do validation to know if we
160 * can meaningfully print the address. */
161 if (r < 0)
162 return r;
163
164 if (socket_address_family(a) == AF_NETLINK) {
165 _cleanup_free_ char *sfamily = NULL;
166
167 r = netlink_family_to_string_alloc(a->protocol, &sfamily);
168 if (r < 0)
169 return r;
170
171 r = asprintf(ret, "%s %u", sfamily, a->sockaddr.nl.nl_groups);
172 if (r < 0)
173 return -ENOMEM;
174
175 return 0;
176 }
177
178 return sockaddr_pretty(&a->sockaddr.sa, a->size, false, true, ret);
179 }
180
181 bool socket_address_can_accept(const SocketAddress *a) {
182 assert(a);
183
184 return
185 IN_SET(a->type, SOCK_STREAM, SOCK_SEQPACKET);
186 }
187
188 bool socket_address_equal(const SocketAddress *a, const SocketAddress *b) {
189 assert(a);
190 assert(b);
191
192 /* Invalid addresses are unequal to all */
193 if (socket_address_verify(a, false) < 0 ||
194 socket_address_verify(b, false) < 0)
195 return false;
196
197 if (a->type != b->type)
198 return false;
199
200 if (socket_address_family(a) != socket_address_family(b))
201 return false;
202
203 switch (socket_address_family(a)) {
204
205 case AF_INET:
206 if (a->sockaddr.in.sin_addr.s_addr != b->sockaddr.in.sin_addr.s_addr)
207 return false;
208
209 if (a->sockaddr.in.sin_port != b->sockaddr.in.sin_port)
210 return false;
211
212 break;
213
214 case AF_INET6:
215 if (memcmp(&a->sockaddr.in6.sin6_addr, &b->sockaddr.in6.sin6_addr, sizeof(a->sockaddr.in6.sin6_addr)) != 0)
216 return false;
217
218 if (a->sockaddr.in6.sin6_port != b->sockaddr.in6.sin6_port)
219 return false;
220
221 break;
222
223 case AF_UNIX:
224 if (a->size <= offsetof(struct sockaddr_un, sun_path) ||
225 b->size <= offsetof(struct sockaddr_un, sun_path))
226 return false;
227
228 if ((a->sockaddr.un.sun_path[0] == 0) != (b->sockaddr.un.sun_path[0] == 0))
229 return false;
230
231 if (a->sockaddr.un.sun_path[0]) {
232 if (!path_equal_or_inode_same(a->sockaddr.un.sun_path, b->sockaddr.un.sun_path, 0))
233 return false;
234 } else {
235 if (a->size != b->size)
236 return false;
237
238 if (memcmp(a->sockaddr.un.sun_path, b->sockaddr.un.sun_path, a->size) != 0)
239 return false;
240 }
241
242 break;
243
244 case AF_NETLINK:
245 if (a->protocol != b->protocol)
246 return false;
247
248 if (a->sockaddr.nl.nl_groups != b->sockaddr.nl.nl_groups)
249 return false;
250
251 break;
252
253 case AF_VSOCK:
254 if (a->sockaddr.vm.svm_cid != b->sockaddr.vm.svm_cid)
255 return false;
256
257 if (a->sockaddr.vm.svm_port != b->sockaddr.vm.svm_port)
258 return false;
259
260 break;
261
262 default:
263 /* Cannot compare, so we assume the addresses are different */
264 return false;
265 }
266
267 return true;
268 }
269
270 const char* socket_address_get_path(const SocketAddress *a) {
271 assert(a);
272
273 if (socket_address_family(a) != AF_UNIX)
274 return NULL;
275
276 if (a->sockaddr.un.sun_path[0] == 0)
277 return NULL;
278
279 /* Note that this is only safe because we know that there's an extra NUL byte after the sockaddr_un
280 * structure. On Linux AF_UNIX file system socket addresses don't have to be NUL terminated if they take up the
281 * full sun_path space. */
282 assert_cc(sizeof(union sockaddr_union) >= sizeof(struct sockaddr_un)+1);
283 return a->sockaddr.un.sun_path;
284 }
285
286 bool socket_ipv6_is_supported(void) {
287 static int cached = -1;
288
289 if (cached < 0) {
290
291 if (access("/proc/net/if_inet6", F_OK) < 0) {
292
293 if (errno != ENOENT) {
294 log_debug_errno(errno, "Unexpected error when checking whether /proc/net/if_inet6 exists: %m");
295 return false;
296 }
297
298 cached = false;
299 } else
300 cached = true;
301 }
302
303 return cached;
304 }
305
306 bool socket_ipv6_is_enabled(void) {
307 _cleanup_free_ char *v = NULL;
308 int r;
309
310 /* Much like socket_ipv6_is_supported(), but also checks that the sysctl that disables IPv6 on all
311 * interfaces isn't turned on */
312
313 if (!socket_ipv6_is_supported())
314 return false;
315
316 r = sysctl_read_ip_property(AF_INET6, "all", "disable_ipv6", &v);
317 if (r < 0) {
318 log_debug_errno(r, "Unexpected error reading 'net.ipv6.conf.all.disable_ipv6' sysctl: %m");
319 return true;
320 }
321
322 r = parse_boolean(v);
323 if (r < 0) {
324 log_debug_errno(r, "Failed to pare 'net.ipv6.conf.all.disable_ipv6' sysctl: %m");
325 return true;
326 }
327
328 return !r;
329 }
330
331 bool socket_address_matches_fd(const SocketAddress *a, int fd) {
332 SocketAddress b;
333 socklen_t solen;
334
335 assert(a);
336 assert(fd >= 0);
337
338 b.size = sizeof(b.sockaddr);
339 if (getsockname(fd, &b.sockaddr.sa, &b.size) < 0)
340 return false;
341
342 if (b.sockaddr.sa.sa_family != a->sockaddr.sa.sa_family)
343 return false;
344
345 solen = sizeof(b.type);
346 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &b.type, &solen) < 0)
347 return false;
348
349 if (b.type != a->type)
350 return false;
351
352 if (a->protocol != 0) {
353 solen = sizeof(b.protocol);
354 if (getsockopt(fd, SOL_SOCKET, SO_PROTOCOL, &b.protocol, &solen) < 0)
355 return false;
356
357 if (b.protocol != a->protocol)
358 return false;
359 }
360
361 return socket_address_equal(a, &b);
362 }
363
364 int sockaddr_port(const struct sockaddr *_sa, unsigned *ret_port) {
365 const union sockaddr_union *sa = (const union sockaddr_union*) _sa;
366
367 /* Note, this returns the port as 'unsigned' rather than 'uint16_t', as AF_VSOCK knows larger ports */
368
369 assert(sa);
370 assert(ret_port);
371
372 switch (sa->sa.sa_family) {
373
374 case AF_INET:
375 *ret_port = be16toh(sa->in.sin_port);
376 return 0;
377
378 case AF_INET6:
379 *ret_port = be16toh(sa->in6.sin6_port);
380 return 0;
381
382 case AF_VSOCK:
383 *ret_port = sa->vm.svm_port;
384 return 0;
385
386 default:
387 return -EAFNOSUPPORT;
388 }
389 }
390
391 const union in_addr_union *sockaddr_in_addr(const struct sockaddr *_sa) {
392 const union sockaddr_union *sa = (const union sockaddr_union*) _sa;
393
394 if (!sa)
395 return NULL;
396
397 switch (sa->sa.sa_family) {
398
399 case AF_INET:
400 return (const union in_addr_union*) &sa->in.sin_addr;
401
402 case AF_INET6:
403 return (const union in_addr_union*) &sa->in6.sin6_addr;
404
405 default:
406 return NULL;
407 }
408 }
409
410 int sockaddr_set_in_addr(
411 union sockaddr_union *u,
412 int family,
413 const union in_addr_union *a,
414 uint16_t port) {
415
416 assert(u);
417 assert(a);
418
419 switch (family) {
420
421 case AF_INET:
422 u->in = (struct sockaddr_in) {
423 .sin_family = AF_INET,
424 .sin_addr = a->in,
425 .sin_port = htobe16(port),
426 };
427
428 return 0;
429
430 case AF_INET6:
431 u->in6 = (struct sockaddr_in6) {
432 .sin6_family = AF_INET6,
433 .sin6_addr = a->in6,
434 .sin6_port = htobe16(port),
435 };
436
437 return 0;
438
439 default:
440 return -EAFNOSUPPORT;
441
442 }
443 }
444
445 int sockaddr_pretty(
446 const struct sockaddr *_sa,
447 socklen_t salen,
448 bool translate_ipv6,
449 bool include_port,
450 char **ret) {
451
452 union sockaddr_union *sa = (union sockaddr_union*) _sa;
453 char *p;
454 int r;
455
456 assert(sa);
457 assert(salen >= sizeof(sa->sa.sa_family));
458 assert(ret);
459
460 switch (sa->sa.sa_family) {
461
462 case AF_INET: {
463 uint32_t a;
464
465 a = be32toh(sa->in.sin_addr.s_addr);
466
467 if (include_port)
468 r = asprintf(&p,
469 "%u.%u.%u.%u:%u",
470 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
471 be16toh(sa->in.sin_port));
472 else
473 r = asprintf(&p,
474 "%u.%u.%u.%u",
475 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF);
476 if (r < 0)
477 return -ENOMEM;
478 break;
479 }
480
481 case AF_INET6: {
482 static const unsigned char ipv4_prefix[] = {
483 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
484 };
485
486 if (translate_ipv6 &&
487 memcmp(&sa->in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
488 const uint8_t *a = sa->in6.sin6_addr.s6_addr+12;
489 if (include_port)
490 r = asprintf(&p,
491 "%u.%u.%u.%u:%u",
492 a[0], a[1], a[2], a[3],
493 be16toh(sa->in6.sin6_port));
494 else
495 r = asprintf(&p,
496 "%u.%u.%u.%u",
497 a[0], a[1], a[2], a[3]);
498 if (r < 0)
499 return -ENOMEM;
500 } else {
501 const char *a = IN6_ADDR_TO_STRING(&sa->in6.sin6_addr);
502
503 if (include_port) {
504 if (asprintf(&p,
505 "[%s]:%u%s%s",
506 a,
507 be16toh(sa->in6.sin6_port),
508 sa->in6.sin6_scope_id != 0 ? "%" : "",
509 FORMAT_IFNAME_FULL(sa->in6.sin6_scope_id, FORMAT_IFNAME_IFINDEX)) < 0)
510 return -ENOMEM;
511 } else {
512 if (sa->in6.sin6_scope_id != 0)
513 p = strjoin(a, "%", FORMAT_IFNAME_FULL(sa->in6.sin6_scope_id, FORMAT_IFNAME_IFINDEX));
514 else
515 p = strdup(a);
516 if (!p)
517 return -ENOMEM;
518 }
519 }
520
521 break;
522 }
523
524 case AF_UNIX:
525 if (salen <= offsetof(struct sockaddr_un, sun_path) ||
526 (sa->un.sun_path[0] == 0 && salen == offsetof(struct sockaddr_un, sun_path) + 1))
527 /* The name must have at least one character (and the leading NUL does not count) */
528 p = strdup("<unnamed>");
529 else {
530 /* Note that we calculate the path pointer here through the .un_buffer[] field, in order to
531 * outtrick bounds checking tools such as ubsan, which are too smart for their own good: on
532 * Linux the kernel may return sun_path[] data one byte longer than the declared size of the
533 * field. */
534 char *path = (char*) sa->un_buffer + offsetof(struct sockaddr_un, sun_path);
535 size_t path_len = salen - offsetof(struct sockaddr_un, sun_path);
536
537 if (path[0] == 0) {
538 /* Abstract socket. When parsing address information from, we
539 * explicitly reject overly long paths and paths with embedded NULs.
540 * But we might get such a socket from the outside. Let's return
541 * something meaningful and printable in this case. */
542
543 _cleanup_free_ char *e = NULL;
544
545 e = cescape_length(path + 1, path_len - 1);
546 if (!e)
547 return -ENOMEM;
548
549 p = strjoin("@", e);
550 } else {
551 if (path[path_len - 1] == '\0')
552 /* We expect a terminating NUL and don't print it */
553 path_len--;
554
555 p = cescape_length(path, path_len);
556 }
557 }
558 if (!p)
559 return -ENOMEM;
560
561 break;
562
563 case AF_VSOCK:
564 if (include_port) {
565 if (sa->vm.svm_cid == VMADDR_CID_ANY)
566 r = asprintf(&p, "vsock::%u", sa->vm.svm_port);
567 else
568 r = asprintf(&p, "vsock:%u:%u", sa->vm.svm_cid, sa->vm.svm_port);
569 } else
570 r = asprintf(&p, "vsock:%u", sa->vm.svm_cid);
571 if (r < 0)
572 return -ENOMEM;
573 break;
574
575 default:
576 return -EOPNOTSUPP;
577 }
578
579 *ret = p;
580 return 0;
581 }
582
583 int getpeername_pretty(int fd, bool include_port, char **ret) {
584 union sockaddr_union sa;
585 socklen_t salen = sizeof(sa);
586 int r;
587
588 assert(fd >= 0);
589 assert(ret);
590
591 if (getpeername(fd, &sa.sa, &salen) < 0)
592 return -errno;
593
594 if (sa.sa.sa_family == AF_UNIX) {
595 struct ucred ucred = UCRED_INVALID;
596
597 /* UNIX connection sockets are anonymous, so let's use
598 * PID/UID as pretty credentials instead */
599
600 r = getpeercred(fd, &ucred);
601 if (r < 0)
602 return r;
603
604 if (asprintf(ret, "PID "PID_FMT"/UID "UID_FMT, ucred.pid, ucred.uid) < 0)
605 return -ENOMEM;
606
607 return 0;
608 }
609
610 /* For remote sockets we translate IPv6 addresses back to IPv4
611 * if applicable, since that's nicer. */
612
613 return sockaddr_pretty(&sa.sa, salen, true, include_port, ret);
614 }
615
616 int getsockname_pretty(int fd, char **ret) {
617 union sockaddr_union sa;
618 socklen_t salen = sizeof(sa);
619
620 assert(fd >= 0);
621 assert(ret);
622
623 if (getsockname(fd, &sa.sa, &salen) < 0)
624 return -errno;
625
626 /* For local sockets we do not translate IPv6 addresses back
627 * to IPv6 if applicable, since this is usually used for
628 * listening sockets where the difference between IPv4 and
629 * IPv6 matters. */
630
631 return sockaddr_pretty(&sa.sa, salen, false, true, ret);
632 }
633
634 int socknameinfo_pretty(const struct sockaddr *sa, socklen_t salen, char **ret) {
635 char host[NI_MAXHOST];
636 int r;
637
638 assert(sa);
639 assert(salen >= sizeof(sa_family_t));
640 assert(ret);
641
642 r = getnameinfo(sa, salen, host, sizeof(host), /* service= */ NULL, /* service_len= */ 0, IDN_FLAGS);
643 if (r != 0) {
644 if (r == EAI_MEMORY)
645 return log_oom_debug();
646 if (r == EAI_SYSTEM)
647 log_debug_errno(errno, "getnameinfo() failed, ignoring: %m");
648 else
649 log_debug("getnameinfo() failed, ignoring: %s", gai_strerror(r));
650
651 return sockaddr_pretty(sa, salen, /* translate_ipv6= */ true, /* include_port= */ true, ret);
652 }
653
654 return strdup_to(ret, host);
655 }
656
657 static const char* const netlink_family_table[] = {
658 [NETLINK_ROUTE] = "route",
659 [NETLINK_FIREWALL] = "firewall",
660 [NETLINK_INET_DIAG] = "inet-diag",
661 [NETLINK_NFLOG] = "nflog",
662 [NETLINK_XFRM] = "xfrm",
663 [NETLINK_SELINUX] = "selinux",
664 [NETLINK_ISCSI] = "iscsi",
665 [NETLINK_AUDIT] = "audit",
666 [NETLINK_FIB_LOOKUP] = "fib-lookup",
667 [NETLINK_CONNECTOR] = "connector",
668 [NETLINK_NETFILTER] = "netfilter",
669 [NETLINK_IP6_FW] = "ip6-fw",
670 [NETLINK_DNRTMSG] = "dnrtmsg",
671 [NETLINK_KOBJECT_UEVENT] = "kobject-uevent",
672 [NETLINK_GENERIC] = "generic",
673 [NETLINK_SCSITRANSPORT] = "scsitransport",
674 [NETLINK_ECRYPTFS] = "ecryptfs",
675 [NETLINK_RDMA] = "rdma",
676 };
677
678 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(netlink_family, int, INT_MAX);
679
680 bool sockaddr_equal(const union sockaddr_union *a, const union sockaddr_union *b) {
681 assert(a);
682 assert(b);
683
684 if (a->sa.sa_family != b->sa.sa_family)
685 return false;
686
687 if (a->sa.sa_family == AF_INET)
688 return a->in.sin_addr.s_addr == b->in.sin_addr.s_addr;
689
690 if (a->sa.sa_family == AF_INET6)
691 return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr)) == 0;
692
693 if (a->sa.sa_family == AF_VSOCK)
694 return a->vm.svm_cid == b->vm.svm_cid;
695
696 return false;
697 }
698
699 int fd_set_sndbuf(int fd, size_t n, bool increase) {
700 int r, value;
701 socklen_t l = sizeof(value);
702
703 if (n > INT_MAX)
704 return -ERANGE;
705
706 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
707 if (r >= 0 && l == sizeof(value) && increase ? (size_t) value >= n*2 : (size_t) value == n*2)
708 return 0;
709
710 /* First, try to set the buffer size with SO_SNDBUF. */
711 r = setsockopt_int(fd, SOL_SOCKET, SO_SNDBUF, n);
712 if (r < 0)
713 return r;
714
715 /* SO_SNDBUF above may set to the kernel limit, instead of the requested size.
716 * So, we need to check the actual buffer size here. */
717 l = sizeof(value);
718 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
719 if (r >= 0 && l == sizeof(value) && increase ? (size_t) value >= n*2 : (size_t) value == n*2)
720 return 1;
721
722 /* If we have the privileges we will ignore the kernel limit. */
723 r = setsockopt_int(fd, SOL_SOCKET, SO_SNDBUFFORCE, n);
724 if (r < 0)
725 return r;
726
727 return 1;
728 }
729
730 int fd_set_rcvbuf(int fd, size_t n, bool increase) {
731 int r, value;
732 socklen_t l = sizeof(value);
733
734 if (n > INT_MAX)
735 return -ERANGE;
736
737 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
738 if (r >= 0 && l == sizeof(value) && increase ? (size_t) value >= n*2 : (size_t) value == n*2)
739 return 0;
740
741 /* First, try to set the buffer size with SO_RCVBUF. */
742 r = setsockopt_int(fd, SOL_SOCKET, SO_RCVBUF, n);
743 if (r < 0)
744 return r;
745
746 /* SO_RCVBUF above may set to the kernel limit, instead of the requested size.
747 * So, we need to check the actual buffer size here. */
748 l = sizeof(value);
749 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
750 if (r >= 0 && l == sizeof(value) && increase ? (size_t) value >= n*2 : (size_t) value == n*2)
751 return 1;
752
753 /* If we have the privileges we will ignore the kernel limit. */
754 r = setsockopt_int(fd, SOL_SOCKET, SO_RCVBUFFORCE, n);
755 if (r < 0)
756 return r;
757
758 return 1;
759 }
760
761 static const char* const ip_tos_table[] = {
762 [IPTOS_LOWDELAY] = "low-delay",
763 [IPTOS_THROUGHPUT] = "throughput",
764 [IPTOS_RELIABILITY] = "reliability",
765 [IPTOS_LOWCOST] = "low-cost",
766 };
767
768 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
769
770 bool ifname_valid_char(char a) {
771 if ((unsigned char) a >= 127U)
772 return false;
773
774 if ((unsigned char) a <= 32U)
775 return false;
776
777 if (IN_SET(a,
778 ':', /* colons are used by the legacy "alias" interface logic */
779 '/', /* slashes cannot work, since we need to use network interfaces in sysfs paths, and in paths slashes are separators */
780 '%')) /* %d is used in the kernel's weird foo%d format string naming feature which we really really don't want to ever run into by accident */
781 return false;
782
783 return true;
784 }
785
786 bool ifname_valid_full(const char *p, IfnameValidFlags flags) {
787 bool numeric = true;
788
789 /* Checks whether a network interface name is valid. This is inspired by dev_valid_name() in the kernel sources
790 * but slightly stricter, as we only allow non-control, non-space ASCII characters in the interface name. We
791 * also don't permit names that only container numbers, to avoid confusion with numeric interface indexes. */
792
793 assert(!(flags & ~_IFNAME_VALID_ALL));
794
795 if (isempty(p))
796 return false;
797
798 /* A valid ifindex? If so, it's valid iff IFNAME_VALID_NUMERIC is set */
799 if (parse_ifindex(p) >= 0)
800 return flags & IFNAME_VALID_NUMERIC;
801
802 if (flags & IFNAME_VALID_ALTERNATIVE) {
803 if (strlen(p) >= ALTIFNAMSIZ)
804 return false;
805 } else {
806 if (strlen(p) >= IFNAMSIZ)
807 return false;
808 }
809
810 if (dot_or_dot_dot(p))
811 return false;
812
813 /* Let's refuse "all" and "default" as interface name, to avoid collisions with the special sysctl
814 * directories /proc/sys/net/{ipv4,ipv6}/conf/{all,default} */
815 if (!FLAGS_SET(flags, IFNAME_VALID_SPECIAL) && STR_IN_SET(p, "all", "default"))
816 return false;
817
818 for (const char *t = p; *t; t++) {
819 if (!ifname_valid_char(*t))
820 return false;
821
822 numeric = numeric && ascii_isdigit(*t);
823 }
824
825 /* It's fully numeric but didn't parse as valid ifindex above? if so, it must be too large or zero or
826 * so, let's refuse that. */
827 if (numeric)
828 return false;
829
830 return true;
831 }
832
833 bool address_label_valid(const char *p) {
834
835 POINTER_MAY_BE_NULL(p);
836
837 if (isempty(p))
838 return false;
839
840 if (strlen(p) >= IFNAMSIZ)
841 return false;
842
843 while (*p) {
844 if ((uint8_t) *p >= 127U)
845 return false;
846
847 if ((uint8_t) *p <= 31U)
848 return false;
849 p++;
850 }
851
852 return true;
853 }
854
855 int getpeercred(int fd, struct ucred *ucred) {
856 socklen_t n = sizeof(struct ucred);
857 struct ucred u;
858
859 assert(fd >= 0);
860 assert(ucred);
861
862 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n) < 0)
863 return -errno;
864
865 if (n != sizeof(struct ucred))
866 return -EIO;
867
868 /* Check if the data is actually useful and not suppressed due to namespacing issues */
869 if (!pid_is_valid(u.pid))
870 return -ENODATA;
871
872 /* Note that we don't check UID/GID here, as namespace translation works differently there: instead of
873 * receiving in "invalid" user/group we get the overflow UID/GID. */
874
875 *ucred = u;
876 return 0;
877 }
878
879 int getpeersec(int fd, char **ret) {
880 _cleanup_free_ char *s = NULL;
881 socklen_t n = 64;
882
883 assert(fd >= 0);
884 assert(ret);
885
886 for (;;) {
887 s = new0(char, n+1);
888 if (!s)
889 return -ENOMEM;
890
891 if (getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n) >= 0) {
892 s[n] = 0;
893 break;
894 }
895
896 if (errno != ERANGE)
897 return -errno;
898
899 s = mfree(s);
900 }
901
902 if (isempty(s))
903 return -EOPNOTSUPP;
904
905 *ret = TAKE_PTR(s);
906
907 return 0;
908 }
909
910 int getpeergroups(int fd, gid_t **ret) {
911 socklen_t n = sizeof(gid_t) * 64U;
912 _cleanup_free_ gid_t *d = NULL;
913
914 assert(fd >= 0);
915 assert(ret);
916
917 long ngroups_max = sysconf(_SC_NGROUPS_MAX);
918 if (ngroups_max > 0)
919 n = MAX(n, sizeof(gid_t) * (socklen_t) ngroups_max);
920
921 for (;;) {
922 d = malloc(n);
923 if (!d)
924 return -ENOMEM;
925
926 if (getsockopt(fd, SOL_SOCKET, SO_PEERGROUPS, d, &n) >= 0)
927 break;
928
929 if (errno != ERANGE)
930 return -errno;
931
932 d = mfree(d);
933 }
934
935 assert_se(n % sizeof(gid_t) == 0);
936 n /= sizeof(gid_t);
937
938 if (n > INT_MAX)
939 return -E2BIG;
940
941 *ret = TAKE_PTR(d);
942
943 return (int) n;
944 }
945
946 int getpeerpidfd(int fd) {
947 socklen_t n = sizeof(int);
948 int pidfd = -EBADF;
949
950 assert(fd >= 0);
951
952 if (getsockopt(fd, SOL_SOCKET, SO_PEERPIDFD, &pidfd, &n) < 0)
953 return -errno;
954
955 if (n != sizeof(int))
956 return -EIO;
957
958 return pidfd;
959 }
960
961 int getpeerpidref(int fd, PidRef *ret) {
962 int r;
963
964 assert(fd >= 0);
965 assert(ret);
966
967 int pidfd = getpeerpidfd(fd);
968 if (pidfd < 0) {
969 if (!ERRNO_IS_NEG_NOT_SUPPORTED(pidfd))
970 return pidfd;
971
972 struct ucred ucred;
973 r = getpeercred(fd, &ucred);
974 if (r < 0)
975 return r;
976
977 return pidref_set_pid(ret, ucred.pid);
978 }
979
980 return pidref_set_pidfd_consume(ret, pidfd);
981 }
982
983 ssize_t send_one_fd_iov_sa(
984 int transport_fd,
985 int fd,
986 const struct iovec *iov, size_t iovlen,
987 const struct sockaddr *sa, socklen_t len,
988 int flags) {
989
990 CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(int))) control = {};
991 struct msghdr mh = {
992 .msg_name = (struct sockaddr*) sa,
993 .msg_namelen = len,
994 .msg_iov = (struct iovec *)iov,
995 .msg_iovlen = iovlen,
996 };
997 ssize_t k;
998
999 assert(transport_fd >= 0);
1000
1001 /*
1002 * We need either an FD or data to send.
1003 * If there's nothing, return an error.
1004 */
1005 if (fd < 0 && !iov)
1006 return -EINVAL;
1007
1008 if (fd >= 0) {
1009 struct cmsghdr *cmsg;
1010
1011 mh.msg_control = &control;
1012 mh.msg_controllen = sizeof(control);
1013
1014 cmsg = CMSG_FIRSTHDR(&mh);
1015 cmsg->cmsg_level = SOL_SOCKET;
1016 cmsg->cmsg_type = SCM_RIGHTS;
1017 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
1018 memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
1019 }
1020 k = sendmsg(transport_fd, &mh, MSG_NOSIGNAL | flags);
1021 if (k < 0)
1022 return (ssize_t) -errno;
1023
1024 return k;
1025 }
1026
1027 int send_one_fd_sa(
1028 int transport_fd,
1029 int fd,
1030 const struct sockaddr *sa, socklen_t len,
1031 int flags) {
1032
1033 assert(fd >= 0);
1034
1035 return (int) send_one_fd_iov_sa(transport_fd, fd, NULL, 0, sa, len, flags);
1036 }
1037
1038 ssize_t receive_one_fd_iov(
1039 int transport_fd,
1040 struct iovec *iov, size_t iovlen,
1041 int flags,
1042 int *ret_fd) {
1043
1044 CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(int))) control;
1045 struct msghdr mh = {
1046 .msg_control = &control,
1047 .msg_controllen = sizeof(control),
1048 .msg_iov = iov,
1049 .msg_iovlen = iovlen,
1050 };
1051 struct cmsghdr *found;
1052 ssize_t k;
1053
1054 assert(transport_fd >= 0);
1055 assert(ret_fd);
1056
1057 /*
1058 * Receive a single FD via @transport_fd. We don't care for
1059 * the transport-type. We retrieve a single FD at most, so for
1060 * packet-based transports, the caller must ensure to send
1061 * only a single FD per packet. This is best used in
1062 * combination with send_one_fd().
1063 */
1064
1065 k = recvmsg_safe(transport_fd, &mh, MSG_CMSG_CLOEXEC | flags);
1066 if (k < 0)
1067 return k;
1068
1069 found = cmsg_find(&mh, SOL_SOCKET, SCM_RIGHTS, CMSG_LEN(sizeof(int)));
1070 if (!found) {
1071 cmsg_close_all(&mh);
1072
1073 /* If didn't receive an FD or any data, return an error. */
1074 if (k == 0)
1075 return -EIO;
1076 }
1077
1078 if (found)
1079 *ret_fd = *CMSG_TYPED_DATA(found, int);
1080 else
1081 *ret_fd = -EBADF;
1082
1083 return k;
1084 }
1085
1086 int receive_one_fd(int transport_fd, int flags) {
1087 int fd;
1088 ssize_t k;
1089
1090 k = receive_one_fd_iov(transport_fd, NULL, 0, flags, &fd);
1091 if (k == 0)
1092 return fd;
1093
1094 /* k must be negative, since receive_one_fd_iov() only returns
1095 * a positive value if data was received through the iov. */
1096 assert(k < 0);
1097 return (int) k;
1098 }
1099
1100 ssize_t next_datagram_size_fd(int fd) {
1101 ssize_t l;
1102 int k;
1103
1104 /* This is a bit like FIONREAD/SIOCINQ, however a bit more powerful. The difference being: recv(MSG_PEEK) will
1105 * actually cause the next datagram in the queue to be validated regarding checksums, which FIONREAD doesn't
1106 * do. This difference is actually of major importance as we need to be sure that the size returned here
1107 * actually matches what we will read with recvmsg() next, as otherwise we might end up allocating a buffer of
1108 * the wrong size. */
1109
1110 l = recv(fd, NULL, 0, MSG_PEEK|MSG_TRUNC);
1111 if (l < 0) {
1112 if (IN_SET(errno, EOPNOTSUPP, EFAULT))
1113 goto fallback;
1114
1115 return -errno;
1116 }
1117 if (l == 0)
1118 goto fallback;
1119
1120 return l;
1121
1122 fallback:
1123 k = 0;
1124
1125 /* Some sockets (AF_PACKET) do not support null-sized recv() with MSG_TRUNC set, let's fall back to FIONREAD
1126 * for them. Checksums don't matter for raw sockets anyway, hence this should be fine. */
1127
1128 if (ioctl(fd, FIONREAD, &k) < 0)
1129 return -errno;
1130
1131 return (ssize_t) k;
1132 }
1133
1134 /* Put a limit on how many times will attempt to call accept4(). We loop
1135 * only on "transient" errors, but let's make sure we don't loop forever. */
1136 #define MAX_FLUSH_ITERATIONS 1024
1137
1138 int flush_accept(int fd) {
1139
1140 int r, b;
1141 socklen_t l = sizeof(b);
1142
1143 /* Similar to flush_fd() but flushes all incoming connections by accepting and immediately closing
1144 * them. */
1145
1146 if (getsockopt(fd, SOL_SOCKET, SO_ACCEPTCONN, &b, &l) < 0)
1147 return -errno;
1148
1149 assert(l == sizeof(b));
1150 if (!b) /* Let's check if this socket accepts connections before calling accept(). accept4() can
1151 * return EOPNOTSUPP if the fd is not a listening socket, which we should treat as a fatal
1152 * error, or in case the incoming TCP connection triggered a network issue, which we want to
1153 * treat as a transient error. Thus, let's rule out the first reason for EOPNOTSUPP early, so
1154 * we can loop safely on transient errors below. */
1155 return -ENOTTY;
1156
1157 for (unsigned iteration = 0;; iteration++) {
1158 int cfd;
1159
1160 r = fd_wait_for_event(fd, POLLIN, 0);
1161 if (r == -EINTR)
1162 continue;
1163 if (r <= 0)
1164 return r;
1165
1166 if (iteration >= MAX_FLUSH_ITERATIONS)
1167 return log_debug_errno(SYNTHETIC_ERRNO(EBUSY),
1168 "Failed to flush connections within " STRINGIFY(MAX_FLUSH_ITERATIONS) " iterations.");
1169
1170 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
1171 if (cfd < 0) {
1172 if (errno == EAGAIN)
1173 return 0;
1174
1175 if (ERRNO_IS_ACCEPT_AGAIN(errno))
1176 continue;
1177
1178 return -errno;
1179 }
1180
1181 safe_close(cfd);
1182 }
1183 }
1184
1185 ssize_t flush_mqueue(int fd) {
1186 _cleanup_free_ char *buf = NULL;
1187 struct mq_attr attr;
1188 ssize_t count = 0;
1189 int r;
1190
1191 assert(fd >= 0);
1192
1193 /* Similar to flush_fd() but flushes all messages from a POSIX message queue. */
1194
1195 for (;;) {
1196 ssize_t l;
1197
1198 r = fd_wait_for_event(fd, POLLIN, /* timeout= */ 0);
1199 if (r == -EINTR)
1200 continue;
1201 if (r < 0)
1202 return r;
1203 if (r == 0)
1204 return count;
1205
1206 if (!buf) {
1207 /* Buffer must be at least as large as mq_msgsize. */
1208 if (mq_getattr(fd, &attr) < 0)
1209 return -errno;
1210
1211 buf = malloc(attr.mq_msgsize);
1212 if (!buf)
1213 return -ENOMEM;
1214 }
1215
1216 l = mq_receive(fd, buf, attr.mq_msgsize, /* msg_prio= */ NULL);
1217 if (l < 0) {
1218 if (errno == EINTR)
1219 continue;
1220
1221 if (errno == EAGAIN)
1222 return count;
1223
1224 return -errno;
1225 }
1226
1227 count += l;
1228 }
1229 }
1230
1231 struct cmsghdr* cmsg_find(struct msghdr *mh, int level, int type, socklen_t length) {
1232 struct cmsghdr *cmsg;
1233
1234 assert(mh);
1235
1236 CMSG_FOREACH(cmsg, mh)
1237 if (cmsg->cmsg_level == level &&
1238 cmsg->cmsg_type == type &&
1239 (length == (socklen_t) -1 || length == cmsg->cmsg_len))
1240 return cmsg;
1241
1242 return NULL;
1243 }
1244
1245 void* cmsg_find_and_copy_data(struct msghdr *mh, int level, int type, void *buf, size_t buf_len) {
1246 struct cmsghdr *cmsg;
1247
1248 assert(mh);
1249 assert(buf);
1250 assert(buf_len > 0);
1251
1252 /* This is similar to cmsg_find_data(), but copy the found data to buf. This should be typically used
1253 * when reading possibly unaligned data such as timestamp, as time_t is 64-bit and size_t is 32-bit on
1254 * RISCV32. See issue #27241. */
1255
1256 cmsg = cmsg_find(mh, level, type, CMSG_LEN(buf_len));
1257 if (!cmsg)
1258 return NULL;
1259
1260 return memcpy_safe(buf, CMSG_DATA(cmsg), buf_len);
1261 }
1262
1263 size_t sockaddr_ll_len(const struct sockaddr_ll *sa) {
1264 /* Certain hardware address types (e.g Infiniband) do not fit into sll_addr
1265 * (8 bytes) and run over the structure. This function returns the correct size that
1266 * must be passed to kernel. */
1267
1268 assert(sa->sll_family == AF_PACKET);
1269
1270 size_t mac_len = sizeof(sa->sll_addr);
1271
1272 if (be16toh(sa->sll_hatype) == ARPHRD_ETHER)
1273 mac_len = MAX(mac_len, (size_t) ETH_ALEN);
1274 if (be16toh(sa->sll_hatype) == ARPHRD_INFINIBAND)
1275 mac_len = MAX(mac_len, (size_t) INFINIBAND_ALEN);
1276
1277 return offsetof(struct sockaddr_ll, sll_addr) + mac_len;
1278 }
1279
1280 size_t sockaddr_un_len(const struct sockaddr_un *sa) {
1281 /* Covers only file system and abstract AF_UNIX socket addresses, but not unnamed socket addresses. */
1282
1283 assert(sa->sun_family == AF_UNIX);
1284
1285 return offsetof(struct sockaddr_un, sun_path) +
1286 (sa->sun_path[0] == 0 ?
1287 1 + strnlen(sa->sun_path+1, sizeof(sa->sun_path)-1) :
1288 strnlen(sa->sun_path, sizeof(sa->sun_path))+1);
1289 }
1290
1291 size_t sockaddr_len(const union sockaddr_union *sa) {
1292 assert(sa);
1293
1294 switch (sa->sa.sa_family) {
1295 case AF_INET:
1296 return sizeof(struct sockaddr_in);
1297 case AF_INET6:
1298 return sizeof(struct sockaddr_in6);
1299 case AF_UNIX:
1300 return sockaddr_un_len(&sa->un);
1301 case AF_PACKET:
1302 return sockaddr_ll_len(&sa->ll);
1303 case AF_NETLINK:
1304 return sizeof(struct sockaddr_nl);
1305 case AF_VSOCK:
1306 return sizeof(struct sockaddr_vm);
1307 default:
1308 assert_not_reached();
1309 }
1310 }
1311
1312 int socket_ioctl_fd(void) {
1313 int fd;
1314
1315 /* Create a socket to invoke the various network interface ioctl()s on. Traditionally only AF_INET was good for
1316 * that. Since kernel 4.6 AF_NETLINK works for this too. We first try to use AF_INET hence, but if that's not
1317 * available (for example, because it is made unavailable via SECCOMP or such), we'll fall back to the more
1318 * generic AF_NETLINK. */
1319
1320 fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);
1321 if (fd < 0)
1322 fd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC, NETLINK_GENERIC);
1323 if (fd < 0)
1324 return -errno;
1325
1326 return fd;
1327 }
1328
1329 int sockaddr_un_unlink(const struct sockaddr_un *sa) {
1330 const char *p, * nul;
1331
1332 assert(sa);
1333
1334 if (sa->sun_family != AF_UNIX)
1335 return -EPROTOTYPE;
1336
1337 if (sa->sun_path[0] == 0) /* Nothing to do for abstract sockets */
1338 return 0;
1339
1340 /* The path in .sun_path is not necessarily NUL terminated. Let's fix that. */
1341 nul = memchr(sa->sun_path, 0, sizeof(sa->sun_path));
1342 if (nul)
1343 p = sa->sun_path;
1344 else
1345 p = memdupa_suffix0(sa->sun_path, sizeof(sa->sun_path));
1346
1347 if (unlink(p) < 0)
1348 return -errno;
1349
1350 return 1;
1351 }
1352
1353 int sockaddr_un_set_path(struct sockaddr_un *ret, const char *path) {
1354 size_t l;
1355
1356 assert(ret);
1357 assert(path);
1358
1359 /* Initialize ret->sun_path from the specified argument. This will interpret paths starting with '@' as
1360 * abstract namespace sockets, and those starting with '/' as regular filesystem sockets. It won't accept
1361 * anything else (i.e. no relative paths), to avoid ambiguities. Note that this function cannot be used to
1362 * reference paths in the abstract namespace that include NUL bytes in the name. */
1363
1364 l = strlen(path);
1365 if (l < 2)
1366 return -EINVAL;
1367 if (!IN_SET(path[0], '/', '@'))
1368 return -EINVAL;
1369
1370 /* Don't allow paths larger than the space in sockaddr_un. Note that we are a tiny bit more restrictive than
1371 * the kernel is: we insist on NUL termination (both for abstract namespace and regular file system socket
1372 * addresses!), which the kernel doesn't. We do this to reduce chance of incompatibility with other apps that
1373 * do not expect non-NUL terminated file system path. */
1374 if (l+1 > sizeof(ret->sun_path))
1375 return path[0] == '@' ? -EINVAL : -ENAMETOOLONG; /* return a recognizable error if this is
1376 * too long to fit into a sockaddr_un, but
1377 * is a file system path, and thus might be
1378 * connectible via O_PATH indirection. */
1379
1380 *ret = (struct sockaddr_un) {
1381 .sun_family = AF_UNIX,
1382 };
1383
1384 if (path[0] == '@') {
1385 /* Abstract namespace socket */
1386 memcpy(ret->sun_path + 1, path + 1, l); /* copy *with* trailing NUL byte */
1387 return (int) (offsetof(struct sockaddr_un, sun_path) + l); /* 🔥 *don't* 🔥 include trailing NUL in size */
1388
1389 } else {
1390 assert(path[0] == '/');
1391
1392 /* File system socket */
1393 memcpy(ret->sun_path, path, l + 1); /* copy *with* trailing NUL byte */
1394 return (int) (offsetof(struct sockaddr_un, sun_path) + l + 1); /* include trailing NUL in size */
1395 }
1396 }
1397
1398 int getsockopt_int(int fd, int level, int optname, int *ret) {
1399 int v;
1400 socklen_t sl = sizeof(v);
1401
1402 assert(fd >= 0);
1403 assert(ret);
1404
1405 if (getsockopt(fd, level, optname, &v, &sl) < 0)
1406 return negative_errno();
1407 if (sl != sizeof(v))
1408 return -EIO;
1409
1410 *ret = v;
1411 return 0;
1412 }
1413
1414 int socket_bind_to_ifname(int fd, const char *ifname) {
1415 assert(fd >= 0);
1416
1417 /* Call with NULL to drop binding */
1418
1419 return RET_NERRNO(setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, ifname, strlen_ptr(ifname)));
1420 }
1421
1422 int socket_bind_to_ifindex(int fd, int ifindex) {
1423 assert(fd >= 0);
1424
1425 if (ifindex <= 0)
1426 /* Drop binding */
1427 return RET_NERRNO(setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, NULL, 0));
1428
1429 return setsockopt_int(fd, SOL_SOCKET, SO_BINDTOIFINDEX, ifindex);
1430 }
1431
1432 int socket_autobind(int fd, char **ret_name) {
1433 _cleanup_free_ char *name = NULL;
1434 uint64_t random;
1435 int r;
1436
1437 /* Generate a random abstract socket name and bind fd to it. This is modeled after the kernel
1438 * "autobind" feature, but uses 64-bit random number internally. */
1439
1440 assert(fd >= 0);
1441
1442 random = random_u64();
1443
1444 if (asprintf(&name, "@%" PRIu64, random) < 0)
1445 return -ENOMEM;
1446
1447 union sockaddr_union sa;
1448 assert_cc(DECIMAL_STR_MAX(uint64_t) < sizeof(sa.un.sun_path));
1449
1450 r = sockaddr_un_set_path(&sa.un, name);
1451 if (r < 0)
1452 return r;
1453
1454 if (bind(fd, &sa.sa, r) < 0)
1455 return -errno;
1456
1457 if (ret_name)
1458 *ret_name = TAKE_PTR(name);
1459 return 0;
1460 }
1461
1462 ssize_t recvmsg_safe(int sockfd, struct msghdr *msg, int flags) {
1463 ssize_t n;
1464
1465 /* A wrapper around recvmsg() that checks for MSG_CTRUNC and MSG_TRUNC, and turns them into an error,
1466 * in a reasonably safe way, closing any received fds in the error path.
1467 *
1468 * Note that unlike our usual coding style this might modify *msg on failure. */
1469
1470 assert(sockfd >= 0);
1471 assert(msg);
1472
1473 n = recvmsg(sockfd, msg, flags);
1474 if (n < 0)
1475 return -errno;
1476
1477 if (FLAGS_SET(msg->msg_flags, MSG_CTRUNC) ||
1478 (!FLAGS_SET(flags, MSG_PEEK) && FLAGS_SET(msg->msg_flags, MSG_TRUNC))) {
1479 cmsg_close_all(msg);
1480 return FLAGS_SET(msg->msg_flags, MSG_CTRUNC) ? -ECHRNG : -EXFULL;
1481 }
1482
1483 return n;
1484 }
1485
1486 int socket_get_family(int fd) {
1487 int af;
1488 socklen_t sl = sizeof(af);
1489
1490 if (getsockopt(fd, SOL_SOCKET, SO_DOMAIN, &af, &sl) < 0)
1491 return -errno;
1492
1493 if (sl != sizeof(af))
1494 return -EINVAL;
1495
1496 return af;
1497 }
1498
1499 int socket_set_recvpktinfo(int fd, int af, bool b) {
1500
1501 if (af == AF_UNSPEC) {
1502 af = socket_get_family(fd);
1503 if (af < 0)
1504 return af;
1505 }
1506
1507 switch (af) {
1508
1509 case AF_INET:
1510 return setsockopt_int(fd, IPPROTO_IP, IP_PKTINFO, b);
1511
1512 case AF_INET6:
1513 return setsockopt_int(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, b);
1514
1515 case AF_NETLINK:
1516 return setsockopt_int(fd, SOL_NETLINK, NETLINK_PKTINFO, b);
1517
1518 case AF_PACKET:
1519 return setsockopt_int(fd, SOL_PACKET, PACKET_AUXDATA, b);
1520
1521 default:
1522 return -EAFNOSUPPORT;
1523 }
1524 }
1525
1526 int socket_set_unicast_if(int fd, int af, int ifi) {
1527 be32_t ifindex_be = htobe32(ifi);
1528
1529 if (af == AF_UNSPEC) {
1530 af = socket_get_family(fd);
1531 if (af < 0)
1532 return af;
1533 }
1534
1535 switch (af) {
1536
1537 case AF_INET:
1538 return RET_NERRNO(setsockopt(fd, IPPROTO_IP, IP_UNICAST_IF, &ifindex_be, sizeof(ifindex_be)));
1539
1540 case AF_INET6:
1541 return RET_NERRNO(setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_IF, &ifindex_be, sizeof(ifindex_be)));
1542
1543 default:
1544 return -EAFNOSUPPORT;
1545 }
1546 }
1547
1548 int socket_set_option(int fd, int af, int opt_ipv4, int opt_ipv6, int val) {
1549 if (af == AF_UNSPEC) {
1550 af = socket_get_family(fd);
1551 if (af < 0)
1552 return af;
1553 }
1554
1555 switch (af) {
1556
1557 case AF_INET:
1558 return setsockopt_int(fd, IPPROTO_IP, opt_ipv4, val);
1559
1560 case AF_INET6:
1561 return setsockopt_int(fd, IPPROTO_IPV6, opt_ipv6, val);
1562
1563 default:
1564 return -EAFNOSUPPORT;
1565 }
1566 }
1567
1568 int socket_get_mtu(int fd, int af, size_t *ret) {
1569 int mtu, r;
1570
1571 assert(ret);
1572
1573 if (af == AF_UNSPEC) {
1574 af = socket_get_family(fd);
1575 if (af < 0)
1576 return af;
1577 }
1578
1579 switch (af) {
1580
1581 case AF_INET:
1582 r = getsockopt_int(fd, IPPROTO_IP, IP_MTU, &mtu);
1583 break;
1584
1585 case AF_INET6:
1586 r = getsockopt_int(fd, IPPROTO_IPV6, IPV6_MTU, &mtu);
1587 break;
1588
1589 default:
1590 return -EAFNOSUPPORT;
1591 }
1592
1593 if (r < 0)
1594 return r;
1595 if (mtu <= 0)
1596 return -EINVAL;
1597
1598 *ret = (size_t) mtu;
1599 return 0;
1600 }
1601
1602 static int connect_unix_path_simple(int fd, const char *path) {
1603 union sockaddr_union sa = {
1604 .un.sun_family = AF_UNIX,
1605 };
1606 size_t l;
1607
1608 assert(fd >= 0);
1609 assert(path);
1610
1611 l = strlen(path);
1612 assert(l > 0);
1613 assert(l < sizeof(sa.un.sun_path));
1614
1615 memcpy(sa.un.sun_path, path, l + 1);
1616 return RET_NERRNO(connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + l + 1));
1617 }
1618
1619 static int connect_unix_inode(int fd, int inode_fd) {
1620 assert(fd >= 0);
1621 assert(inode_fd >= 0);
1622
1623 return connect_unix_path_simple(fd, FORMAT_PROC_FD_PATH(inode_fd));
1624 }
1625
1626 int connect_unix_path(int fd, int dir_fd, const char *path) {
1627 _cleanup_close_ int inode_fd = -EBADF;
1628
1629 assert(fd >= 0);
1630 assert(wildcard_fd_is_valid(dir_fd));
1631
1632 /* Connects to the specified AF_UNIX socket in the file system. Works around the 108 byte size limit
1633 * in sockaddr_un, by going via O_PATH if needed. This hence works for any kind of path. */
1634
1635 if (!path) {
1636 if (dir_fd < 0)
1637 return -EISDIR;
1638
1639 return connect_unix_inode(fd, dir_fd); /* If no path is specified, then dir_fd refers to the socket inode to connect to. */
1640 }
1641
1642 /* Refuse zero length path early, to make sure AF_UNIX stack won't mistake this for an abstract
1643 * namespace path, since first char is NUL */
1644 if (isempty(path))
1645 return -EINVAL;
1646
1647 /* Shortcut for the simple case */
1648 if (dir_fd == AT_FDCWD && strlen(path) < sizeof_field(struct sockaddr_un, sun_path))
1649 return connect_unix_path_simple(fd, path);
1650
1651 /* If dir_fd is specified, then we need to go the indirect O_PATH route, because connectat() does not
1652 * exist. If the path is too long, we also need to take the indirect route, since we can't fit this
1653 * into a sockaddr_un directly. */
1654
1655 if (dir_fd == XAT_FDROOT) {
1656 _cleanup_free_ char *j = strjoin("/", path);
1657 if (!j)
1658 return -ENOMEM;
1659
1660 inode_fd = open(j, O_PATH|O_CLOEXEC);
1661 } else
1662 inode_fd = openat(dir_fd, path, O_PATH|O_CLOEXEC);
1663 if (inode_fd < 0)
1664 return -errno;
1665
1666 return connect_unix_inode(fd, inode_fd);
1667 }
1668
1669 int socket_address_parse_unix(SocketAddress *ret_address, const char *s) {
1670 struct sockaddr_un un;
1671 int r;
1672
1673 assert(ret_address);
1674 assert(s);
1675
1676 if (!IN_SET(*s, '/', '@'))
1677 return -EPROTO;
1678
1679 r = sockaddr_un_set_path(&un, s);
1680 if (r < 0)
1681 return r;
1682
1683 *ret_address = (SocketAddress) {
1684 .sockaddr.un = un,
1685 .size = r,
1686 };
1687
1688 return 0;
1689 }
1690
1691 int socket_address_equal_unix(const char *a, const char *b) {
1692 SocketAddress socket_a, socket_b;
1693 int r;
1694
1695 assert(a);
1696 assert(b);
1697
1698 r = socket_address_parse_unix(&socket_a, a);
1699 if (r < 0)
1700 return r;
1701
1702 r = socket_address_parse_unix(&socket_b, b);
1703 if (r < 0)
1704 return r;
1705
1706 return sockaddr_equal(&socket_a.sockaddr, &socket_b.sockaddr);
1707 }
1708
1709 int vsock_parse_port(const char *s, unsigned *ret) {
1710 int r;
1711
1712 assert(ret);
1713
1714 if (!s)
1715 return -EINVAL;
1716
1717 unsigned u;
1718 r = safe_atou(s, &u);
1719 if (r < 0)
1720 return r;
1721
1722 /* Port 0 is apparently valid and not special in AF_VSOCK (unlike on IP). But VMADDR_PORT_ANY
1723 * (UINT32_MAX) is. Hence refuse that. */
1724
1725 if (u == VMADDR_PORT_ANY)
1726 return -EINVAL;
1727
1728 *ret = u;
1729 return 0;
1730 }
1731
1732 int vsock_parse_cid(const char *s, unsigned *ret) {
1733 assert(ret);
1734
1735 if (!s)
1736 return -EINVAL;
1737
1738 /* Parsed an AF_VSOCK "CID". This is a 32bit entity, and the usual type is "unsigned". We recognize
1739 * the four special CIDs as strings, and otherwise parse the numeric CIDs. */
1740
1741 if (streq(s, "hypervisor"))
1742 *ret = VMADDR_CID_HYPERVISOR;
1743 else if (streq(s, "local"))
1744 *ret = VMADDR_CID_LOCAL;
1745 else if (streq(s, "host"))
1746 *ret = VMADDR_CID_HOST;
1747 else if (STR_IN_SET(s, "any", "-1"))
1748 *ret = VMADDR_CID_ANY;
1749 else
1750 return safe_atou(s, ret);
1751
1752 return 0;
1753 }
1754
1755 int socket_address_parse_vsock(SocketAddress *ret_address, const char *s) {
1756 /* AF_VSOCK socket in vsock:cid:port notation */
1757 _cleanup_free_ char *n = NULL;
1758 const char *e, *cid_start;
1759 unsigned port, cid;
1760 int type, r;
1761
1762 assert(ret_address);
1763 assert(s);
1764
1765 if ((cid_start = startswith(s, "vsock:")))
1766 type = 0;
1767 else if ((cid_start = startswith(s, "vsock-dgram:")))
1768 type = SOCK_DGRAM;
1769 else if ((cid_start = startswith(s, "vsock-seqpacket:")))
1770 type = SOCK_SEQPACKET;
1771 else if ((cid_start = startswith(s, "vsock-stream:")))
1772 type = SOCK_STREAM;
1773 else
1774 return -EPROTO;
1775
1776 e = strchr(cid_start, ':');
1777 if (!e)
1778 return -EINVAL;
1779
1780 r = vsock_parse_port(e+1, &port);
1781 if (r < 0)
1782 return r;
1783
1784 n = strndup(cid_start, e - cid_start);
1785 if (!n)
1786 return -ENOMEM;
1787
1788 if (isempty(n))
1789 cid = VMADDR_CID_ANY;
1790 else {
1791 r = vsock_parse_cid(n, &cid);
1792 if (r < 0)
1793 return r;
1794 }
1795
1796 *ret_address = (SocketAddress) {
1797 .sockaddr.vm = {
1798 .svm_family = AF_VSOCK,
1799 .svm_cid = cid,
1800 .svm_port = port,
1801 },
1802 .type = type,
1803 .size = sizeof(struct sockaddr_vm),
1804 };
1805
1806 return 0;
1807 }
1808
1809 int netlink_socket_get_multicast_groups(int fd, size_t *ret_len, uint32_t **ret_groups) {
1810 _cleanup_free_ uint32_t *groups = NULL;
1811 socklen_t len = 0, old_len;
1812
1813 assert(fd >= 0);
1814
1815 if (getsockopt(fd, SOL_NETLINK, NETLINK_LIST_MEMBERSHIPS, NULL, &len) < 0)
1816 return -errno;
1817
1818 if (len == 0)
1819 goto finalize;
1820
1821 groups = new0(uint32_t, len);
1822 if (!groups)
1823 return -ENOMEM;
1824
1825 old_len = len;
1826
1827 if (getsockopt(fd, SOL_NETLINK, NETLINK_LIST_MEMBERSHIPS, groups, &len) < 0)
1828 return -errno;
1829
1830 if (old_len != len)
1831 return -EIO;
1832
1833 finalize:
1834 if (ret_len)
1835 *ret_len = len;
1836 if (ret_groups)
1837 *ret_groups = TAKE_PTR(groups);
1838
1839 return 0;
1840 }
1841
1842 int socket_get_cookie(int fd, uint64_t *ret) {
1843 assert(fd >= 0);
1844
1845 uint64_t cookie = 0;
1846 socklen_t cookie_len = sizeof(cookie);
1847 if (getsockopt(fd, SOL_SOCKET, SO_COOKIE, &cookie, &cookie_len) < 0)
1848 return -errno;
1849
1850 assert(cookie_len == sizeof(cookie));
1851 if (ret)
1852 *ret = cookie;
1853
1854 return 0;
1855 }
1856
1857 void cmsg_close_all(struct msghdr *mh) {
1858 assert(mh);
1859
1860 struct cmsghdr *cmsg;
1861 CMSG_FOREACH(cmsg, mh) {
1862 if (cmsg->cmsg_level != SOL_SOCKET)
1863 continue;
1864
1865 if (cmsg->cmsg_type == SCM_RIGHTS)
1866 close_many(CMSG_TYPED_DATA(cmsg, int),
1867 (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int));
1868 else if (cmsg->cmsg_type == SCM_PIDFD) {
1869 assert(cmsg->cmsg_len == CMSG_LEN(sizeof(int)));
1870 safe_close(*CMSG_TYPED_DATA(cmsg, int));
1871 }
1872 }
1873 }
1874
1875 int tos_to_priority(uint8_t tos) {
1876 /* Map the IP Precedence (top 3 bits of the TOS field) to Linux internal packet priorities
1877 * (TC_PRIO_*). This exactly mirrors the standard Linux kernel IP precedence-to-priority mapping
1878 * (rt_tos2priority) to ensure consistent behavior when explicitly setting SO_PRIORITY. */
1879 switch (IPTOS_PREC(tos)) {
1880 case IPTOS_PREC_NETCONTROL: /* 0xc0 (CS7) - Network Control. Used for infrastructure control (e.g., STP, keepalives). */
1881 case IPTOS_PREC_INTERNETCONTROL: /* 0xe0 (CS6) - Internetwork Control. Used for routing protocols (e.g., OSPF, BGP) and DHCP. */
1882 return TC_PRIO_CONTROL;
1883
1884 case IPTOS_PREC_CRITIC_ECP: /* 0xa0 (CS5) - Critical. Used for delay-sensitive traffic like Voice over IP (VoIP). */
1885 case IPTOS_PREC_FLASHOVERRIDE: /* 0x80 (CS4) - Flash Override. Used for interactive video and multimedia. */
1886 return TC_PRIO_INTERACTIVE;
1887
1888 case IPTOS_PREC_FLASH: /* 0x60 (CS3) - Flash. Used for broadcast video and call signaling (e.g., SIP). */
1889 case IPTOS_PREC_IMMEDIATE: /* 0x40 (CS2) - Immediate. Used for OAM (Operations, Administration, and Management) and transactional data. */
1890 return TC_PRIO_INTERACTIVE_BULK;
1891
1892 case IPTOS_PREC_PRIORITY: /* 0x20 (CS1) - Priority. Used for background traffic and bulk data transfers. */
1893 return TC_PRIO_BULK;
1894
1895 case IPTOS_PREC_ROUTINE: /* 0x00 (CS0) - Routine. Best effort traffic. */
1896 default:
1897 return TC_PRIO_BESTEFFORT;
1898 }
1899 }
1900
1901 int socket_xattr_supported(void) {
1902 int r;
1903
1904 // FIXME: Drop this check once Linux 7.0 becomes our baseline
1905
1906 /* Checks if socket inodes may have xattrs on this kernel. This should pass on kernel 7.0, fail on
1907 * older kernels */
1908
1909 static int cached = -1;
1910 if (cached >= 0)
1911 return cached;
1912
1913 const char *t;
1914 r = tmp_dir(&t);
1915 if (r < 0)
1916 return r;
1917
1918 _cleanup_free_ char *sp = NULL;
1919 r = tempfn_random_child(t, "sockxattrtest", &sp);
1920 if (r < 0)
1921 return r;
1922
1923 if (mknod(sp, S_IFSOCK | 0600, /* dev= */ 0) < 0)
1924 return -errno;
1925
1926 _cleanup_(unlink_and_freep) char *sp_destroy = TAKE_PTR(sp);
1927
1928 /* Old kernels return EPERM. But let's also check for more appropriate error codes, to be friendly to
1929 * seccomp policies */
1930 r = xsetxattr(AT_FDCWD, sp_destroy, /* at_flags= */ 0, "user.testxxx", "1");
1931 if (ERRNO_IS_NEG_NOT_SUPPORTED(r) || r == -EPERM)
1932 return (cached = false);
1933 if (r < 0)
1934 return log_debug_errno(r, "Failed to set test xattr on socket inode '%s': %m", sp_destroy);
1935
1936 return (cached = true);
1937 }
Unnamed repository; edit this file 'description' to name the repository.