1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
8 #include <netinet/ip.h>
14 #include <sys/ioctl.h>
18 #include "alloc-util.h"
19 #include "errno-util.h"
23 #include "format-util.h"
26 #include "memory-util.h"
27 #include "parse-util.h"
28 #include "path-util.h"
29 #include "process-util.h"
30 #include "socket-util.h"
31 #include "string-table.h"
32 #include "string-util.h"
34 #include "sysctl-util.h"
35 #include "user-util.h"
39 # define IDN_FLAGS NI_IDN
44 static const char* const socket_address_type_table
[] = {
45 [SOCK_STREAM
] = "Stream",
46 [SOCK_DGRAM
] = "Datagram",
48 [SOCK_RDM
] = "ReliableDatagram",
49 [SOCK_SEQPACKET
] = "SequentialPacket",
50 [SOCK_DCCP
] = "DatagramCongestionControl",
53 DEFINE_STRING_TABLE_LOOKUP(socket_address_type
, int);
55 int socket_address_verify(const SocketAddress
*a
, bool strict
) {
58 /* With 'strict' we enforce additional sanity constraints which are not set by the standard,
59 * but should only apply to sockets we create ourselves. */
61 switch (socket_address_family(a
)) {
64 if (a
->size
!= sizeof(struct sockaddr_in
))
67 if (a
->sockaddr
.in
.sin_port
== 0)
70 if (!IN_SET(a
->type
, 0, SOCK_STREAM
, SOCK_DGRAM
))
76 if (a
->size
!= sizeof(struct sockaddr_in6
))
79 if (a
->sockaddr
.in6
.sin6_port
== 0)
82 if (!IN_SET(a
->type
, 0, SOCK_STREAM
, SOCK_DGRAM
))
88 if (a
->size
< offsetof(struct sockaddr_un
, sun_path
))
90 if (a
->size
> sizeof(struct sockaddr_un
) + !strict
)
91 /* If !strict, allow one extra byte, since getsockname() on Linux will append
92 * a NUL byte if we have path sockets that are above sun_path's full size. */
95 if (a
->size
> offsetof(struct sockaddr_un
, sun_path
) &&
96 a
->sockaddr
.un
.sun_path
[0] != 0 &&
98 /* Only validate file system sockets here, and only in strict mode */
101 e
= memchr(a
->sockaddr
.un
.sun_path
, 0, sizeof(a
->sockaddr
.un
.sun_path
));
103 /* If there's an embedded NUL byte, make sure the size of the socket address matches it */
104 if (a
->size
!= offsetof(struct sockaddr_un
, sun_path
) + (e
- a
->sockaddr
.un
.sun_path
) + 1)
107 /* If there's no embedded NUL byte, then the size needs to match the whole
108 * structure or the structure with one extra NUL byte suffixed. (Yeah, Linux is awful,
109 * and considers both equivalent: getsockname() even extends sockaddr_un beyond its
110 * size if the path is non NUL terminated.) */
111 if (!IN_SET(a
->size
, sizeof(a
->sockaddr
.un
.sun_path
), sizeof(a
->sockaddr
.un
.sun_path
)+1))
116 if (!IN_SET(a
->type
, 0, SOCK_STREAM
, SOCK_DGRAM
, SOCK_SEQPACKET
))
123 if (a
->size
!= sizeof(struct sockaddr_nl
))
126 if (!IN_SET(a
->type
, 0, SOCK_RAW
, SOCK_DGRAM
))
132 if (a
->size
!= sizeof(struct sockaddr_vm
))
135 if (!IN_SET(a
->type
, 0, SOCK_STREAM
, SOCK_DGRAM
))
141 return -EAFNOSUPPORT
;
145 int socket_address_print(const SocketAddress
*a
, char **ret
) {
151 r
= socket_address_verify(a
, false); /* We do non-strict validation, because we want to be
152 * able to pretty-print any socket the kernel considers
153 * valid. We still need to do validation to know if we
154 * can meaningfully print the address. */
158 if (socket_address_family(a
) == AF_NETLINK
) {
159 _cleanup_free_
char *sfamily
= NULL
;
161 r
= netlink_family_to_string_alloc(a
->protocol
, &sfamily
);
165 r
= asprintf(ret
, "%s %u", sfamily
, a
->sockaddr
.nl
.nl_groups
);
172 return sockaddr_pretty(&a
->sockaddr
.sa
, a
->size
, false, true, ret
);
175 bool socket_address_can_accept(const SocketAddress
*a
) {
179 IN_SET(a
->type
, SOCK_STREAM
, SOCK_SEQPACKET
);
182 bool socket_address_equal(const SocketAddress
*a
, const SocketAddress
*b
) {
186 /* Invalid addresses are unequal to all */
187 if (socket_address_verify(a
, false) < 0 ||
188 socket_address_verify(b
, false) < 0)
191 if (a
->type
!= b
->type
)
194 if (socket_address_family(a
) != socket_address_family(b
))
197 switch (socket_address_family(a
)) {
200 if (a
->sockaddr
.in
.sin_addr
.s_addr
!= b
->sockaddr
.in
.sin_addr
.s_addr
)
203 if (a
->sockaddr
.in
.sin_port
!= b
->sockaddr
.in
.sin_port
)
209 if (memcmp(&a
->sockaddr
.in6
.sin6_addr
, &b
->sockaddr
.in6
.sin6_addr
, sizeof(a
->sockaddr
.in6
.sin6_addr
)) != 0)
212 if (a
->sockaddr
.in6
.sin6_port
!= b
->sockaddr
.in6
.sin6_port
)
218 if (a
->size
<= offsetof(struct sockaddr_un
, sun_path
) ||
219 b
->size
<= offsetof(struct sockaddr_un
, sun_path
))
222 if ((a
->sockaddr
.un
.sun_path
[0] == 0) != (b
->sockaddr
.un
.sun_path
[0] == 0))
225 if (a
->sockaddr
.un
.sun_path
[0]) {
226 if (!path_equal_or_files_same(a
->sockaddr
.un
.sun_path
, b
->sockaddr
.un
.sun_path
, 0))
229 if (a
->size
!= b
->size
)
232 if (memcmp(a
->sockaddr
.un
.sun_path
, b
->sockaddr
.un
.sun_path
, a
->size
) != 0)
239 if (a
->protocol
!= b
->protocol
)
242 if (a
->sockaddr
.nl
.nl_groups
!= b
->sockaddr
.nl
.nl_groups
)
248 if (a
->sockaddr
.vm
.svm_cid
!= b
->sockaddr
.vm
.svm_cid
)
251 if (a
->sockaddr
.vm
.svm_port
!= b
->sockaddr
.vm
.svm_port
)
257 /* Cannot compare, so we assume the addresses are different */
264 const char* socket_address_get_path(const SocketAddress
*a
) {
267 if (socket_address_family(a
) != AF_UNIX
)
270 if (a
->sockaddr
.un
.sun_path
[0] == 0)
273 /* Note that this is only safe because we know that there's an extra NUL byte after the sockaddr_un
274 * structure. On Linux AF_UNIX file system socket addresses don't have to be NUL terminated if they take up the
275 * full sun_path space. */
276 assert_cc(sizeof(union sockaddr_union
) >= sizeof(struct sockaddr_un
)+1);
277 return a
->sockaddr
.un
.sun_path
;
280 bool socket_ipv6_is_supported(void) {
281 static int cached
= -1;
285 if (access("/proc/net/if_inet6", F_OK
) < 0) {
287 if (errno
!= ENOENT
) {
288 log_debug_errno(errno
, "Unexpected error when checking whether /proc/net/if_inet6 exists: %m");
300 bool socket_ipv6_is_enabled(void) {
301 _cleanup_free_
char *v
= NULL
;
304 /* Much like socket_ipv6_is_supported(), but also checks that the sysctl that disables IPv6 on all
305 * interfaces isn't turned on */
307 if (!socket_ipv6_is_supported())
310 r
= sysctl_read_ip_property(AF_INET6
, "all", "disable_ipv6", &v
);
312 log_debug_errno(r
, "Unexpected error reading 'net.ipv6.conf.all.disable_ipv6' sysctl: %m");
316 r
= parse_boolean(v
);
318 log_debug_errno(r
, "Failed to pare 'net.ipv6.conf.all.disable_ipv6' sysctl: %m");
325 bool socket_address_matches_fd(const SocketAddress
*a
, int fd
) {
332 b
.size
= sizeof(b
.sockaddr
);
333 if (getsockname(fd
, &b
.sockaddr
.sa
, &b
.size
) < 0)
336 if (b
.sockaddr
.sa
.sa_family
!= a
->sockaddr
.sa
.sa_family
)
339 solen
= sizeof(b
.type
);
340 if (getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, &b
.type
, &solen
) < 0)
343 if (b
.type
!= a
->type
)
346 if (a
->protocol
!= 0) {
347 solen
= sizeof(b
.protocol
);
348 if (getsockopt(fd
, SOL_SOCKET
, SO_PROTOCOL
, &b
.protocol
, &solen
) < 0)
351 if (b
.protocol
!= a
->protocol
)
355 return socket_address_equal(a
, &b
);
358 int sockaddr_port(const struct sockaddr
*_sa
, unsigned *ret_port
) {
359 const union sockaddr_union
*sa
= (const union sockaddr_union
*) _sa
;
361 /* Note, this returns the port as 'unsigned' rather than 'uint16_t', as AF_VSOCK knows larger ports */
365 switch (sa
->sa
.sa_family
) {
368 *ret_port
= be16toh(sa
->in
.sin_port
);
372 *ret_port
= be16toh(sa
->in6
.sin6_port
);
376 *ret_port
= sa
->vm
.svm_port
;
380 return -EAFNOSUPPORT
;
384 const union in_addr_union
*sockaddr_in_addr(const struct sockaddr
*_sa
) {
385 const union sockaddr_union
*sa
= (const union sockaddr_union
*) _sa
;
390 switch (sa
->sa
.sa_family
) {
393 return (const union in_addr_union
*) &sa
->in
.sin_addr
;
396 return (const union in_addr_union
*) &sa
->in6
.sin6_addr
;
403 int sockaddr_set_in_addr(
404 union sockaddr_union
*u
,
406 const union in_addr_union
*a
,
415 u
->in
= (struct sockaddr_in
) {
416 .sin_family
= AF_INET
,
418 .sin_port
= htobe16(port
),
424 u
->in6
= (struct sockaddr_in6
) {
425 .sin6_family
= AF_INET6
,
427 .sin6_port
= htobe16(port
),
433 return -EAFNOSUPPORT
;
439 const struct sockaddr
*_sa
,
445 union sockaddr_union
*sa
= (union sockaddr_union
*) _sa
;
450 assert(salen
>= sizeof(sa
->sa
.sa_family
));
452 switch (sa
->sa
.sa_family
) {
457 a
= be32toh(sa
->in
.sin_addr
.s_addr
);
462 a
>> 24, (a
>> 16) & 0xFF, (a
>> 8) & 0xFF, a
& 0xFF,
463 be16toh(sa
->in
.sin_port
));
467 a
>> 24, (a
>> 16) & 0xFF, (a
>> 8) & 0xFF, a
& 0xFF);
474 static const unsigned char ipv4_prefix
[] = {
475 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
478 if (translate_ipv6
&&
479 memcmp(&sa
->in6
.sin6_addr
, ipv4_prefix
, sizeof(ipv4_prefix
)) == 0) {
480 const uint8_t *a
= sa
->in6
.sin6_addr
.s6_addr
+12;
484 a
[0], a
[1], a
[2], a
[3],
485 be16toh(sa
->in6
.sin6_port
));
489 a
[0], a
[1], a
[2], a
[3]);
493 char a
[INET6_ADDRSTRLEN
];
495 inet_ntop(AF_INET6
, &sa
->in6
.sin6_addr
, a
, sizeof(a
));
501 be16toh(sa
->in6
.sin6_port
),
502 sa
->in6
.sin6_scope_id
!= 0 ? "%" : "",
503 FORMAT_IFNAME_FULL(sa
->in6
.sin6_scope_id
, FORMAT_IFNAME_IFINDEX
)) < 0)
506 if (sa
->in6
.sin6_scope_id
!= 0)
507 p
= strjoin(a
, "%", FORMAT_IFNAME_FULL(sa
->in6
.sin6_scope_id
, FORMAT_IFNAME_IFINDEX
));
519 if (salen
<= offsetof(struct sockaddr_un
, sun_path
) ||
520 (sa
->un
.sun_path
[0] == 0 && salen
== offsetof(struct sockaddr_un
, sun_path
) + 1))
521 /* The name must have at least one character (and the leading NUL does not count) */
522 p
= strdup("<unnamed>");
524 /* Note that we calculate the path pointer here through the .un_buffer[] field, in order to
525 * outtrick bounds checking tools such as ubsan, which are too smart for their own good: on
526 * Linux the kernel may return sun_path[] data one byte longer than the declared size of the
528 char *path
= (char*) sa
->un_buffer
+ offsetof(struct sockaddr_un
, sun_path
);
529 size_t path_len
= salen
- offsetof(struct sockaddr_un
, sun_path
);
532 /* Abstract socket. When parsing address information from, we
533 * explicitly reject overly long paths and paths with embedded NULs.
534 * But we might get such a socket from the outside. Let's return
535 * something meaningful and printable in this case. */
537 _cleanup_free_
char *e
= NULL
;
539 e
= cescape_length(path
+ 1, path_len
- 1);
545 if (path
[path_len
- 1] == '\0')
546 /* We expect a terminating NUL and don't print it */
549 p
= cescape_length(path
, path_len
);
559 if (sa
->vm
.svm_cid
== VMADDR_CID_ANY
)
560 r
= asprintf(&p
, "vsock::%u", sa
->vm
.svm_port
);
562 r
= asprintf(&p
, "vsock:%u:%u", sa
->vm
.svm_cid
, sa
->vm
.svm_port
);
564 r
= asprintf(&p
, "vsock:%u", sa
->vm
.svm_cid
);
577 int getpeername_pretty(int fd
, bool include_port
, char **ret
) {
578 union sockaddr_union sa
;
579 socklen_t salen
= sizeof(sa
);
585 if (getpeername(fd
, &sa
.sa
, &salen
) < 0)
588 if (sa
.sa
.sa_family
== AF_UNIX
) {
589 struct ucred ucred
= UCRED_INVALID
;
591 /* UNIX connection sockets are anonymous, so let's use
592 * PID/UID as pretty credentials instead */
594 r
= getpeercred(fd
, &ucred
);
598 if (asprintf(ret
, "PID "PID_FMT
"/UID "UID_FMT
, ucred
.pid
, ucred
.uid
) < 0)
604 /* For remote sockets we translate IPv6 addresses back to IPv4
605 * if applicable, since that's nicer. */
607 return sockaddr_pretty(&sa
.sa
, salen
, true, include_port
, ret
);
610 int getsockname_pretty(int fd
, char **ret
) {
611 union sockaddr_union sa
;
612 socklen_t salen
= sizeof(sa
);
617 if (getsockname(fd
, &sa
.sa
, &salen
) < 0)
620 /* For local sockets we do not translate IPv6 addresses back
621 * to IPv6 if applicable, since this is usually used for
622 * listening sockets where the difference between IPv4 and
625 return sockaddr_pretty(&sa
.sa
, salen
, false, true, ret
);
628 int socknameinfo_pretty(union sockaddr_union
*sa
, socklen_t salen
, char **_ret
) {
630 char host
[NI_MAXHOST
], *ret
;
634 r
= getnameinfo(&sa
->sa
, salen
, host
, sizeof(host
), NULL
, 0, IDN_FLAGS
);
636 int saved_errno
= errno
;
638 r
= sockaddr_pretty(&sa
->sa
, salen
, true, true, &ret
);
642 log_debug_errno(saved_errno
, "getnameinfo(%s) failed: %m", ret
);
653 static const char* const netlink_family_table
[] = {
654 [NETLINK_ROUTE
] = "route",
655 [NETLINK_FIREWALL
] = "firewall",
656 [NETLINK_INET_DIAG
] = "inet-diag",
657 [NETLINK_NFLOG
] = "nflog",
658 [NETLINK_XFRM
] = "xfrm",
659 [NETLINK_SELINUX
] = "selinux",
660 [NETLINK_ISCSI
] = "iscsi",
661 [NETLINK_AUDIT
] = "audit",
662 [NETLINK_FIB_LOOKUP
] = "fib-lookup",
663 [NETLINK_CONNECTOR
] = "connector",
664 [NETLINK_NETFILTER
] = "netfilter",
665 [NETLINK_IP6_FW
] = "ip6-fw",
666 [NETLINK_DNRTMSG
] = "dnrtmsg",
667 [NETLINK_KOBJECT_UEVENT
] = "kobject-uevent",
668 [NETLINK_GENERIC
] = "generic",
669 [NETLINK_SCSITRANSPORT
] = "scsitransport",
670 [NETLINK_ECRYPTFS
] = "ecryptfs",
671 [NETLINK_RDMA
] = "rdma",
674 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(netlink_family
, int, INT_MAX
);
676 static const char* const socket_address_bind_ipv6_only_table
[_SOCKET_ADDRESS_BIND_IPV6_ONLY_MAX
] = {
677 [SOCKET_ADDRESS_DEFAULT
] = "default",
678 [SOCKET_ADDRESS_BOTH
] = "both",
679 [SOCKET_ADDRESS_IPV6_ONLY
] = "ipv6-only"
682 DEFINE_STRING_TABLE_LOOKUP(socket_address_bind_ipv6_only
, SocketAddressBindIPv6Only
);
684 SocketAddressBindIPv6Only
socket_address_bind_ipv6_only_or_bool_from_string(const char *n
) {
687 r
= parse_boolean(n
);
689 return SOCKET_ADDRESS_IPV6_ONLY
;
691 return SOCKET_ADDRESS_BOTH
;
693 return socket_address_bind_ipv6_only_from_string(n
);
696 bool sockaddr_equal(const union sockaddr_union
*a
, const union sockaddr_union
*b
) {
700 if (a
->sa
.sa_family
!= b
->sa
.sa_family
)
703 if (a
->sa
.sa_family
== AF_INET
)
704 return a
->in
.sin_addr
.s_addr
== b
->in
.sin_addr
.s_addr
;
706 if (a
->sa
.sa_family
== AF_INET6
)
707 return memcmp(&a
->in6
.sin6_addr
, &b
->in6
.sin6_addr
, sizeof(a
->in6
.sin6_addr
)) == 0;
709 if (a
->sa
.sa_family
== AF_VSOCK
)
710 return a
->vm
.svm_cid
== b
->vm
.svm_cid
;
715 int fd_set_sndbuf(int fd
, size_t n
, bool increase
) {
717 socklen_t l
= sizeof(value
);
722 r
= getsockopt(fd
, SOL_SOCKET
, SO_SNDBUF
, &value
, &l
);
723 if (r
>= 0 && l
== sizeof(value
) && increase
? (size_t) value
>= n
*2 : (size_t) value
== n
*2)
726 /* First, try to set the buffer size with SO_SNDBUF. */
727 r
= setsockopt_int(fd
, SOL_SOCKET
, SO_SNDBUF
, n
);
731 /* SO_SNDBUF above may set to the kernel limit, instead of the requested size.
732 * So, we need to check the actual buffer size here. */
734 r
= getsockopt(fd
, SOL_SOCKET
, SO_SNDBUF
, &value
, &l
);
735 if (r
>= 0 && l
== sizeof(value
) && increase
? (size_t) value
>= n
*2 : (size_t) value
== n
*2)
738 /* If we have the privileges we will ignore the kernel limit. */
739 r
= setsockopt_int(fd
, SOL_SOCKET
, SO_SNDBUFFORCE
, n
);
746 int fd_set_rcvbuf(int fd
, size_t n
, bool increase
) {
748 socklen_t l
= sizeof(value
);
753 r
= getsockopt(fd
, SOL_SOCKET
, SO_RCVBUF
, &value
, &l
);
754 if (r
>= 0 && l
== sizeof(value
) && increase
? (size_t) value
>= n
*2 : (size_t) value
== n
*2)
757 /* First, try to set the buffer size with SO_RCVBUF. */
758 r
= setsockopt_int(fd
, SOL_SOCKET
, SO_RCVBUF
, n
);
762 /* SO_RCVBUF above may set to the kernel limit, instead of the requested size.
763 * So, we need to check the actual buffer size here. */
765 r
= getsockopt(fd
, SOL_SOCKET
, SO_RCVBUF
, &value
, &l
);
766 if (r
>= 0 && l
== sizeof(value
) && increase
? (size_t) value
>= n
*2 : (size_t) value
== n
*2)
769 /* If we have the privileges we will ignore the kernel limit. */
770 r
= setsockopt_int(fd
, SOL_SOCKET
, SO_RCVBUFFORCE
, n
);
777 static const char* const ip_tos_table
[] = {
778 [IPTOS_LOWDELAY
] = "low-delay",
779 [IPTOS_THROUGHPUT
] = "throughput",
780 [IPTOS_RELIABILITY
] = "reliability",
781 [IPTOS_LOWCOST
] = "low-cost",
784 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos
, int, 0xff);
786 bool ifname_valid_char(char a
) {
787 if ((unsigned char) a
>= 127U)
790 if ((unsigned char) a
<= 32U)
794 ':', /* colons are used by the legacy "alias" interface logic */
795 '/', /* slashes cannot work, since we need to use network interfaces in sysfs paths, and in paths slashes are separators */
796 '%')) /* %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 */
802 bool ifname_valid_full(const char *p
, IfnameValidFlags flags
) {
805 /* Checks whether a network interface name is valid. This is inspired by dev_valid_name() in the kernel sources
806 * but slightly stricter, as we only allow non-control, non-space ASCII characters in the interface name. We
807 * also don't permit names that only container numbers, to avoid confusion with numeric interface indexes. */
809 assert(!(flags
& ~_IFNAME_VALID_ALL
));
814 /* A valid ifindex? If so, it's valid iff IFNAME_VALID_NUMERIC is set */
815 if (parse_ifindex(p
) >= 0)
816 return flags
& IFNAME_VALID_NUMERIC
;
818 if (flags
& IFNAME_VALID_ALTERNATIVE
) {
819 if (strlen(p
) >= ALTIFNAMSIZ
)
822 if (strlen(p
) >= IFNAMSIZ
)
826 if (dot_or_dot_dot(p
))
829 /* Let's refuse "all" and "default" as interface name, to avoid collisions with the special sysctl
830 * directories /proc/sys/net/{ipv4,ipv6}/conf/{all,default} */
831 if (!FLAGS_SET(flags
, IFNAME_VALID_SPECIAL
) && STR_IN_SET(p
, "all", "default"))
834 for (const char *t
= p
; *t
; t
++) {
835 if (!ifname_valid_char(*t
))
838 numeric
= numeric
&& (*t
>= '0' && *t
<= '9');
841 /* It's fully numeric but didn't parse as valid ifindex above? if so, it must be too large or zero or
842 * so, let's refuse that. */
849 bool address_label_valid(const char *p
) {
854 if (strlen(p
) >= IFNAMSIZ
)
858 if ((uint8_t) *p
>= 127U)
861 if ((uint8_t) *p
<= 31U)
869 int getpeercred(int fd
, struct ucred
*ucred
) {
870 socklen_t n
= sizeof(struct ucred
);
877 r
= getsockopt(fd
, SOL_SOCKET
, SO_PEERCRED
, &u
, &n
);
881 if (n
!= sizeof(struct ucred
))
884 /* Check if the data is actually useful and not suppressed due to namespacing issues */
885 if (!pid_is_valid(u
.pid
))
888 /* Note that we don't check UID/GID here, as namespace translation works differently there: instead of
889 * receiving in "invalid" user/group we get the overflow UID/GID. */
895 int getpeersec(int fd
, char **ret
) {
896 _cleanup_free_
char *s
= NULL
;
907 if (getsockopt(fd
, SOL_SOCKET
, SO_PEERSEC
, s
, &n
) >= 0)
924 int getpeergroups(int fd
, gid_t
**ret
) {
925 socklen_t n
= sizeof(gid_t
) * 64;
926 _cleanup_free_ gid_t
*d
= NULL
;
936 if (getsockopt(fd
, SOL_SOCKET
, SO_PEERGROUPS
, d
, &n
) >= 0)
945 assert_se(n
% sizeof(gid_t
) == 0);
948 if ((socklen_t
) (int) n
!= n
)
956 ssize_t
send_one_fd_iov_sa(
959 const struct iovec
*iov
, size_t iovlen
,
960 const struct sockaddr
*sa
, socklen_t len
,
963 CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(int))) control
= {};
965 .msg_name
= (struct sockaddr
*) sa
,
967 .msg_iov
= (struct iovec
*)iov
,
968 .msg_iovlen
= iovlen
,
972 assert(transport_fd
>= 0);
975 * We need either an FD or data to send.
976 * If there's nothing, return an error.
982 struct cmsghdr
*cmsg
;
984 mh
.msg_control
= &control
;
985 mh
.msg_controllen
= sizeof(control
);
987 cmsg
= CMSG_FIRSTHDR(&mh
);
988 cmsg
->cmsg_level
= SOL_SOCKET
;
989 cmsg
->cmsg_type
= SCM_RIGHTS
;
990 cmsg
->cmsg_len
= CMSG_LEN(sizeof(int));
991 memcpy(CMSG_DATA(cmsg
), &fd
, sizeof(int));
993 k
= sendmsg(transport_fd
, &mh
, MSG_NOSIGNAL
| flags
);
995 return (ssize_t
) -errno
;
1003 const struct sockaddr
*sa
, socklen_t len
,
1008 return (int) send_one_fd_iov_sa(transport_fd
, fd
, NULL
, 0, sa
, len
, flags
);
1011 ssize_t
receive_one_fd_iov(
1013 struct iovec
*iov
, size_t iovlen
,
1017 CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(int))) control
;
1018 struct msghdr mh
= {
1019 .msg_control
= &control
,
1020 .msg_controllen
= sizeof(control
),
1022 .msg_iovlen
= iovlen
,
1024 struct cmsghdr
*found
;
1027 assert(transport_fd
>= 0);
1031 * Receive a single FD via @transport_fd. We don't care for
1032 * the transport-type. We retrieve a single FD at most, so for
1033 * packet-based transports, the caller must ensure to send
1034 * only a single FD per packet. This is best used in
1035 * combination with send_one_fd().
1038 k
= recvmsg_safe(transport_fd
, &mh
, MSG_CMSG_CLOEXEC
| flags
);
1042 found
= cmsg_find(&mh
, SOL_SOCKET
, SCM_RIGHTS
, CMSG_LEN(sizeof(int)));
1044 cmsg_close_all(&mh
);
1046 /* If didn't receive an FD or any data, return an error. */
1052 *ret_fd
= *(int*) CMSG_DATA(found
);
1059 int receive_one_fd(int transport_fd
, int flags
) {
1063 k
= receive_one_fd_iov(transport_fd
, NULL
, 0, flags
, &fd
);
1067 /* k must be negative, since receive_one_fd_iov() only returns
1068 * a positive value if data was received through the iov. */
1073 ssize_t
next_datagram_size_fd(int fd
) {
1077 /* This is a bit like FIONREAD/SIOCINQ, however a bit more powerful. The difference being: recv(MSG_PEEK) will
1078 * actually cause the next datagram in the queue to be validated regarding checksums, which FIONREAD doesn't
1079 * do. This difference is actually of major importance as we need to be sure that the size returned here
1080 * actually matches what we will read with recvmsg() next, as otherwise we might end up allocating a buffer of
1081 * the wrong size. */
1083 l
= recv(fd
, NULL
, 0, MSG_PEEK
|MSG_TRUNC
);
1085 if (IN_SET(errno
, EOPNOTSUPP
, EFAULT
))
1098 /* Some sockets (AF_PACKET) do not support null-sized recv() with MSG_TRUNC set, let's fall back to FIONREAD
1099 * for them. Checksums don't matter for raw sockets anyway, hence this should be fine. */
1101 if (ioctl(fd
, FIONREAD
, &k
) < 0)
1107 /* Put a limit on how many times will attempt to call accept4(). We loop
1108 * only on "transient" errors, but let's make sure we don't loop forever. */
1109 #define MAX_FLUSH_ITERATIONS 1024
1111 int flush_accept(int fd
) {
1114 socklen_t l
= sizeof(b
);
1116 /* Similar to flush_fd() but flushes all incoming connections by accepting and immediately closing
1119 if (getsockopt(fd
, SOL_SOCKET
, SO_ACCEPTCONN
, &b
, &l
) < 0)
1122 assert(l
== sizeof(b
));
1123 if (!b
) /* Let's check if this socket accepts connections before calling accept(). accept4() can
1124 * return EOPNOTSUPP if the fd is not a listening socket, which we should treat as a fatal
1125 * error, or in case the incoming TCP connection triggered a network issue, which we want to
1126 * treat as a transient error. Thus, let's rule out the first reason for EOPNOTSUPP early, so
1127 * we can loop safely on transient errors below. */
1130 for (unsigned iteration
= 0;; iteration
++) {
1133 r
= fd_wait_for_event(fd
, POLLIN
, 0);
1143 if (iteration
>= MAX_FLUSH_ITERATIONS
)
1144 return log_debug_errno(SYNTHETIC_ERRNO(EBUSY
),
1145 "Failed to flush connections within " STRINGIFY(MAX_FLUSH_ITERATIONS
) " iterations.");
1147 cfd
= accept4(fd
, NULL
, NULL
, SOCK_NONBLOCK
|SOCK_CLOEXEC
);
1149 if (errno
== EAGAIN
)
1152 if (ERRNO_IS_ACCEPT_AGAIN(errno
))
1162 struct cmsghdr
* cmsg_find(struct msghdr
*mh
, int level
, int type
, socklen_t length
) {
1163 struct cmsghdr
*cmsg
;
1167 CMSG_FOREACH(cmsg
, mh
)
1168 if (cmsg
->cmsg_level
== level
&&
1169 cmsg
->cmsg_type
== type
&&
1170 (length
== (socklen_t
) -1 || length
== cmsg
->cmsg_len
))
1176 int socket_ioctl_fd(void) {
1179 /* Create a socket to invoke the various network interface ioctl()s on. Traditionally only AF_INET was good for
1180 * that. Since kernel 4.6 AF_NETLINK works for this too. We first try to use AF_INET hence, but if that's not
1181 * available (for example, because it is made unavailable via SECCOMP or such), we'll fall back to the more
1182 * generic AF_NETLINK. */
1184 fd
= socket(AF_INET
, SOCK_DGRAM
|SOCK_CLOEXEC
, 0);
1186 fd
= socket(AF_NETLINK
, SOCK_RAW
|SOCK_CLOEXEC
, NETLINK_GENERIC
);
1193 int sockaddr_un_unlink(const struct sockaddr_un
*sa
) {
1194 const char *p
, * nul
;
1198 if (sa
->sun_family
!= AF_UNIX
)
1201 if (sa
->sun_path
[0] == 0) /* Nothing to do for abstract sockets */
1204 /* The path in .sun_path is not necessarily NUL terminated. Let's fix that. */
1205 nul
= memchr(sa
->sun_path
, 0, sizeof(sa
->sun_path
));
1209 p
= memdupa_suffix0(sa
->sun_path
, sizeof(sa
->sun_path
));
1217 int sockaddr_un_set_path(struct sockaddr_un
*ret
, const char *path
) {
1223 /* Initialize ret->sun_path from the specified argument. This will interpret paths starting with '@' as
1224 * abstract namespace sockets, and those starting with '/' as regular filesystem sockets. It won't accept
1225 * anything else (i.e. no relative paths), to avoid ambiguities. Note that this function cannot be used to
1226 * reference paths in the abstract namespace that include NUL bytes in the name. */
1231 if (!IN_SET(path
[0], '/', '@'))
1234 /* Don't allow paths larger than the space in sockaddr_un. Note that we are a tiny bit more restrictive than
1235 * the kernel is: we insist on NUL termination (both for abstract namespace and regular file system socket
1236 * addresses!), which the kernel doesn't. We do this to reduce chance of incompatibility with other apps that
1237 * do not expect non-NUL terminated file system path. */
1238 if (l
+1 > sizeof(ret
->sun_path
))
1241 *ret
= (struct sockaddr_un
) {
1242 .sun_family
= AF_UNIX
,
1245 if (path
[0] == '@') {
1246 /* Abstract namespace socket */
1247 memcpy(ret
->sun_path
+ 1, path
+ 1, l
); /* copy *with* trailing NUL byte */
1248 return (int) (offsetof(struct sockaddr_un
, sun_path
) + l
); /* 🔥 *don't* 🔥 include trailing NUL in size */
1251 assert(path
[0] == '/');
1253 /* File system socket */
1254 memcpy(ret
->sun_path
, path
, l
+ 1); /* copy *with* trailing NUL byte */
1255 return (int) (offsetof(struct sockaddr_un
, sun_path
) + l
+ 1); /* include trailing NUL in size */
1259 int socket_bind_to_ifname(int fd
, const char *ifname
) {
1262 /* Call with NULL to drop binding */
1264 return RET_NERRNO(setsockopt(fd
, SOL_SOCKET
, SO_BINDTODEVICE
, ifname
, strlen_ptr(ifname
)));
1267 int socket_bind_to_ifindex(int fd
, int ifindex
) {
1268 char ifname
[IF_NAMESIZE
];
1275 return RET_NERRNO(setsockopt(fd
, SOL_SOCKET
, SO_BINDTODEVICE
, NULL
, 0));
1277 r
= setsockopt_int(fd
, SOL_SOCKET
, SO_BINDTOIFINDEX
, ifindex
);
1278 if (r
!= -ENOPROTOOPT
)
1281 /* Fall back to SO_BINDTODEVICE on kernels < 5.0 which didn't have SO_BINDTOIFINDEX */
1282 r
= format_ifname(ifindex
, ifname
);
1286 return socket_bind_to_ifname(fd
, ifname
);
1289 ssize_t
recvmsg_safe(int sockfd
, struct msghdr
*msg
, int flags
) {
1292 /* A wrapper around recvmsg() that checks for MSG_CTRUNC, and turns it into an error, in a reasonably
1293 * safe way, closing any SCM_RIGHTS fds in the error path.
1295 * Note that unlike our usual coding style this might modify *msg on failure. */
1297 n
= recvmsg(sockfd
, msg
, flags
);
1301 if (FLAGS_SET(msg
->msg_flags
, MSG_CTRUNC
)) {
1302 cmsg_close_all(msg
);
1303 return -EXFULL
; /* a recognizable error code */
1309 int socket_get_family(int fd
, int *ret
) {
1311 socklen_t sl
= sizeof(af
);
1313 if (getsockopt(fd
, SOL_SOCKET
, SO_DOMAIN
, &af
, &sl
) < 0)
1316 if (sl
!= sizeof(af
))
1322 int socket_set_recvpktinfo(int fd
, int af
, bool b
) {
1325 if (af
== AF_UNSPEC
) {
1326 r
= socket_get_family(fd
, &af
);
1334 return setsockopt_int(fd
, IPPROTO_IP
, IP_PKTINFO
, b
);
1337 return setsockopt_int(fd
, IPPROTO_IPV6
, IPV6_RECVPKTINFO
, b
);
1340 return setsockopt_int(fd
, SOL_NETLINK
, NETLINK_PKTINFO
, b
);
1343 return setsockopt_int(fd
, SOL_PACKET
, PACKET_AUXDATA
, b
);
1346 return -EAFNOSUPPORT
;
1350 int socket_set_unicast_if(int fd
, int af
, int ifi
) {
1351 be32_t ifindex_be
= htobe32(ifi
);
1354 if (af
== AF_UNSPEC
) {
1355 r
= socket_get_family(fd
, &af
);
1363 return RET_NERRNO(setsockopt(fd
, IPPROTO_IP
, IP_UNICAST_IF
, &ifindex_be
, sizeof(ifindex_be
)));
1366 return RET_NERRNO(setsockopt(fd
, IPPROTO_IPV6
, IPV6_UNICAST_IF
, &ifindex_be
, sizeof(ifindex_be
)));
1369 return -EAFNOSUPPORT
;
1373 int socket_set_option(int fd
, int af
, int opt_ipv4
, int opt_ipv6
, int val
) {
1376 if (af
== AF_UNSPEC
) {
1377 r
= socket_get_family(fd
, &af
);
1385 return setsockopt_int(fd
, IPPROTO_IP
, opt_ipv4
, val
);
1388 return setsockopt_int(fd
, IPPROTO_IPV6
, opt_ipv6
, val
);
1391 return -EAFNOSUPPORT
;
1395 int socket_get_mtu(int fd
, int af
, size_t *ret
) {
1398 if (af
== AF_UNSPEC
) {
1399 r
= socket_get_family(fd
, &af
);
1407 r
= getsockopt_int(fd
, IPPROTO_IP
, IP_MTU
, &mtu
);
1411 r
= getsockopt_int(fd
, IPPROTO_IPV6
, IPV6_MTU
, &mtu
);
1415 return -EAFNOSUPPORT
;
1423 *ret
= (size_t) mtu
;