../src/basic/socket-util.c

Bug Summary

File:	build-scan/../src/basic/socket-util.c
Warning:	line 140, column 50 Potential leak of memory pointed to by 'n'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name socket-util.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -menable-no-infs -menable-no-nans -menable-unsafe-fp-math -fno-signed-zeros -mreassociate -freciprocal-math -fdenormal-fp-math=preserve-sign,preserve-sign -ffp-contract=fast -fno-rounding-math -ffast-math -ffinite-math-only -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/12.0.0 -include config.h -I src/basic/libbasic.a.p -I src/basic -I ../src/basic -I src/shared -I ../src/shared -I src/systemd -I ../src/systemd -I src/journal -I ../src/journal -I src/journal-remote -I ../src/journal-remote -I src/nspawn -I ../src/nspawn -I src/resolve -I ../src/resolve -I src/timesync -I ../src/timesync -I ../src/time-wait-sync -I src/login -I ../src/login -I src/udev -I ../src/udev -I src/libudev -I ../src/libudev -I src/core -I ../src/core -I ../src/libsystemd/sd-bus -I ../src/libsystemd/sd-device -I ../src/libsystemd/sd-hwdb -I ../src/libsystemd/sd-id128 -I ../src/libsystemd/sd-netlink -I ../src/libsystemd/sd-network -I src/libsystemd-network -I ../src/libsystemd-network -I . -I .. -I /usr/include/blkid -I /usr/include/libmount -D _FILE_OFFSET_BITS=64 -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wwrite-strings -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unused-result -Wno-format-signedness -Wno-error=nonnull -std=gnu99 -fconst-strings -fdebug-compilation-dir /home/mrc0mmand/repos/@redhat-plumbers/systemd-rhel8/build-scan -ferror-limit 19 -fvisibility default -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-07-16-221226-1465241-1 -x c ../src/basic/socket-util.c
1/* SPDX-License-Identifier: LGPL-2.1+ */

3#include <arpa/inet.h>
4#include <errno(*__errno_location ()).h>
5#include <limits.h>
6#include <net/if.h>
7#include <netdb.h>
8#include <netinet/ip.h>
9#include <poll.h>
10#include <stddef.h>
11#include <stdint.h>
12#include <stdio.h>
13#include <stdlib.h>
14#include <string.h>
15#include <unistd.h>

17#include "alloc-util.h"
18#include "fd-util.h"
19#include "fileio.h"
20#include "format-util.h"
21#include "log.h"
22#include "macro.h"
23#include "missing.h"
24#include "parse-util.h"
25#include "path-util.h"
26#include "process-util.h"
27#include "socket-util.h"
28#include "string-table.h"
29#include "string-util.h"
30#include "strv.h"
31#include "user-util.h"
32#include "utf8.h"
33#include "util.h"

35#if ENABLE_IDN1
36#  define IDN_FLAGS32 NI_IDN32
37#else
38#  define IDN_FLAGS32 0
39#endif

41static const char* const socket_address_type_table[] = {
      [SOCK_STREAMSOCK_STREAM] = "Stream",
      [SOCK_DGRAMSOCK_DGRAM] = "Datagram",
      [SOCK_RAWSOCK_RAW] = "Raw",
      [SOCK_RDMSOCK_RDM] = "ReliableDatagram",
      [SOCK_SEQPACKETSOCK_SEQPACKET] = "SequentialPacket",
      [SOCK_DCCPSOCK_DCCP] = "DatagramCongestionControl",
48};

50DEFINE_STRING_TABLE_LOOKUP(socket_address_type, int)const char *socket_address_type_to_string(int i) { if (i <
|| i >= (int) __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(socket_address_type_table), typeof(&*(socket_address_type_table
))), sizeof(socket_address_type_table)/sizeof((socket_address_type_table
)[0]), ((void)0)))) return ((void*)0); return socket_address_type_table
[i]; } int socket_address_type_from_string(const char *s) { return
 (int) string_table_lookup(socket_address_type_table, __extension__
 (__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(socket_address_type_table), typeof(&*(socket_address_type_table
))), sizeof(socket_address_type_table)/sizeof((socket_address_type_table
)[0]), ((void)0))), s); };

52int socket_address_parse(SocketAddress *a, const char *s) {
      _cleanup_free___attribute__((cleanup(freep))) char *n = NULL((void*)0);
      char *e;
      int r;

      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 57, __PRETTY_FUNCTION__
); } while (0);
2
←
Taking false branch→
3
←
Loop condition is false.  Exiting loop→
      assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/basic/socket-util.c", 58, __PRETTY_FUNCTION__
); } while (0);
4
←
Assuming 's' is non-null→
5
←
Taking false branch→
6
←
Loop condition is false.  Exiting loop→

      zero(*a)(({ size_t _l_ = (sizeof(*a)); void *_x_ = (&(*a)); _l_ ==
? _x_ : memset(_x_, 0, _l_); }));
7
←
'?' condition is false→
      a->type = SOCK_STREAMSOCK_STREAM;

      if (*s == '[') {
8
←
Assuming the condition is false→
9
←
Taking false branch→
              uint16_t port;

              /* IPv6 in [x:.....:z]:p notation */

              e = strchr(s+1, ']');
              if (!e)
                      return -EINVAL22;

              n = strndup(s+1, e-s-1);
              if (!n)
                      return -ENOMEM12;

              errno(*__errno_location ()) = 0;
              if (inet_pton(AF_INET610, n, &a->sockaddr.in6.sin6_addr) <= 0)
                      return errno(*__errno_location ()) > 0 ? -errno(*__errno_location ()) : -EINVAL22;

              e++;
              if (*e != ':')
                      return -EINVAL22;

              e++;
              r = parse_ip_port(e, &port);
              if (r < 0)
                      return r;

              a->sockaddr.in6.sin6_family = AF_INET610;
              a->sockaddr.in6.sin6_port = htobe16(port)__bswap_16 (port);
              a->size = sizeof(struct sockaddr_in6);

      } else if (*s == '/') {
10
←
Assuming the condition is false→
11
←
Taking false branch→
              /* AF_UNIX socket */

              size_t l;

              l = strlen(s);
              if (l >= sizeof(a->sockaddr.un.sun_path))
                      return -EINVAL22;

              a->sockaddr.un.sun_family = AF_UNIX1;
              memcpy(a->sockaddr.un.sun_path, s, l);
              a->size = offsetof(struct sockaddr_un, sun_path)__builtin_offsetof(struct sockaddr_un, sun_path) + l + 1;

      } else if (*s == '@') {
12
←
Assuming the condition is false→
13
←
Taking false branch→
              /* Abstract AF_UNIX socket */
              size_t l;

              l = strlen(s+1);
              if (l >= sizeof(a->sockaddr.un.sun_path) - 1)
                      return -EINVAL22;

              a->sockaddr.un.sun_family = AF_UNIX1;
              memcpy(a->sockaddr.un.sun_path+1, s+1, l);
              a->size = offsetof(struct sockaddr_un, sun_path)__builtin_offsetof(struct sockaddr_un, sun_path) + 1 + l;

      } else if (startswith(s, "vsock:")) {
14
←
Taking true branch→
              /* AF_VSOCK socket in vsock:cid:port notation */
              const char *cid_start = s + STRLEN("vsock:")(sizeof("""vsock:""") - 1);
              unsigned port;

              e = strchr(cid_start, ':');
              if (!e)
15
←
Assuming 'e' is non-null→
16
←
Taking false branch→
                      return -EINVAL22;

              r = safe_atou(e+1, &port);
              if (r < 0)
17
←
Assuming 'r' is >= 0→
18
←
Taking false branch→
                      return r;

              n = strndup(cid_start, e - cid_start);
19
←
Memory is allocated→
              if (!n)
20
←
Assuming 'n' is non-null→
21
←
Taking false branch→
                      return -ENOMEM12;

              if (!isempty(n)) {
22
←
Taking false branch→
                      r = safe_atou(n, &a->sockaddr.vm.svm_cid);
                      if (r < 0)
                              return r;
              } else
                      a->sockaddr.vm.svm_cid = VMADDR_CID_ANY-1U;
23
←
Potential leak of memory pointed to by 'n'

              a->sockaddr.vm.svm_family = AF_VSOCK40;
              a->sockaddr.vm.svm_port = port;
              a->size = sizeof(struct sockaddr_vm);

      } else {
              uint16_t port;

              e = strchr(s, ':');
              if (e) {
                      r = parse_ip_port(e + 1, &port);
                      if (r < 0)
                              return r;

                      n = strndup(s, e-s);
                      if (!n)
                              return -ENOMEM12;

                      /* IPv4 in w.x.y.z:p notation? */
                      r = inet_pton(AF_INET2, n, &a->sockaddr.in.sin_addr);
                      if (r < 0)
                              return -errno(*__errno_location ());

                      if (r > 0) {
                              /* Gotcha, it's a traditional IPv4 address */
                              a->sockaddr.in.sin_family = AF_INET2;
                              a->sockaddr.in.sin_port = htobe16(port)__bswap_16 (port);
                              a->size = sizeof(struct sockaddr_in);
                      } else {
                              unsigned idx;

                              if (strlen(n) > IF_NAMESIZE16-1)
                                      return -EINVAL22;

                              /* Uh, our last resort, an interface name */
                              idx = if_nametoindex(n);
                              if (idx == 0)
                                      return -EINVAL22;

                              a->sockaddr.in6.sin6_family = AF_INET610;
                              a->sockaddr.in6.sin6_port = htobe16(port)__bswap_16 (port);
                              a->sockaddr.in6.sin6_scope_id = idx;
                              a->sockaddr.in6.sin6_addr = in6addr_any;
                              a->size = sizeof(struct sockaddr_in6);
                      }
              } else {

                      /* Just a port */
                      r = parse_ip_port(s, &port);
                      if (r < 0)
                              return r;

                      if (socket_ipv6_is_supported()) {
                              a->sockaddr.in6.sin6_family = AF_INET610;
                              a->sockaddr.in6.sin6_port = htobe16(port)__bswap_16 (port);
                              a->sockaddr.in6.sin6_addr = in6addr_any;
                              a->size = sizeof(struct sockaddr_in6);
                      } else {
                              a->sockaddr.in.sin_family = AF_INET2;
                              a->sockaddr.in.sin_port = htobe16(port)__bswap_16 (port);
                              a->sockaddr.in.sin_addr.s_addr = INADDR_ANY((in_addr_t) 0x00000000);
                              a->size = sizeof(struct sockaddr_in);
                      }
              }
      }

      return 0;
208}

210int socket_address_parse_and_warn(SocketAddress *a, const char *s) {
      SocketAddress b;
      int r;

      /* Similar to socket_address_parse() but warns for IPv6 sockets when we don't support them. */

      r = socket_address_parse(&b, s);
1
Calling 'socket_address_parse'→
      if (r < 0)
              return r;

      if (!socket_ipv6_is_supported() && b.sockaddr.sa.sa_family == AF_INET610) {
              log_warning("Binding to IPv6 address not available since kernel does not support IPv6.")({ int _level = (((4))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/socket-util.c", 221, __func__, "Binding to IPv6 address not available since kernel does not support IPv6."
) : -abs(_e); });
              return -EAFNOSUPPORT97;
      }

      *a = b;
      return 0;
227}

229int socket_address_parse_netlink(SocketAddress *a, const char *s) {
      int family;
      unsigned group = 0;
      _cleanup_free___attribute__((cleanup(freep))) char *sfamily = NULL((void*)0);
      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 233,
 __PRETTY_FUNCTION__); } while (0);
      assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/basic/socket-util.c", 234,
 __PRETTY_FUNCTION__); } while (0);

      zero(*a)(({ size_t _l_ = (sizeof(*a)); void *_x_ = (&(*a)); _l_ ==
? _x_ : memset(_x_, 0, _l_); }));
      a->type = SOCK_RAWSOCK_RAW;

      errno(*__errno_location ()) = 0;
      if (sscanf(s, "%ms %u", &sfamily, &group) < 1)
              return errno(*__errno_location ()) > 0 ? -errno(*__errno_location ()) : -EINVAL22;

      family = netlink_family_from_string(sfamily);
      if (family < 0)
              return -EINVAL22;

      a->sockaddr.nl.nl_family = AF_NETLINK16;
      a->sockaddr.nl.nl_groups = group;

      a->type = SOCK_RAWSOCK_RAW;
      a->size = sizeof(struct sockaddr_nl);
      a->protocol = family;

      return 0;
255}

257int socket_address_verify(const SocketAddress *a) {
      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 258,
 __PRETTY_FUNCTION__); } while (0);

      switch (socket_address_family(a)((a)->sockaddr.sa.sa_family)) {

      case AF_INET2:
              if (a->size != sizeof(struct sockaddr_in))
                      return -EINVAL22;

              if (a->sockaddr.in.sin_port == 0)
                      return -EINVAL22;

              if (!IN_SET(a->type, SOCK_STREAM, SOCK_DGRAM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SOCK_STREAM, SOCK_DGRAM})/sizeof(int)]; switch
(a->type) { case SOCK_STREAM: case SOCK_DGRAM: _found = 1;
 break; default: break; } _found; }))
                      return -EINVAL22;

              return 0;

      case AF_INET610:
              if (a->size != sizeof(struct sockaddr_in6))
                      return -EINVAL22;

              if (a->sockaddr.in6.sin6_port == 0)
                      return -EINVAL22;

              if (!IN_SET(a->type, SOCK_STREAM, SOCK_DGRAM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SOCK_STREAM, SOCK_DGRAM})/sizeof(int)]; switch
(a->type) { case SOCK_STREAM: case SOCK_DGRAM: _found = 1;
 break; default: break; } _found; }))
                      return -EINVAL22;

              return 0;

      case AF_UNIX1:
              if (a->size < offsetof(struct sockaddr_un, sun_path)__builtin_offsetof(struct sockaddr_un, sun_path))
                      return -EINVAL22;

              if (a->size > offsetof(struct sockaddr_un, sun_path)__builtin_offsetof(struct sockaddr_un, sun_path)) {

                      if (a->sockaddr.un.sun_path[0] != 0) {
                              char *e;

                              /* path */
                              e = memchr(a->sockaddr.un.sun_path, 0, sizeof(a->sockaddr.un.sun_path));
                              if (!e)
                                      return -EINVAL22;

                              if (a->size != offsetof(struct sockaddr_un, sun_path)__builtin_offsetof(struct sockaddr_un, sun_path) + (e - a->sockaddr.un.sun_path) + 1)
                                      return -EINVAL22;
                      }
              }

              if (!IN_SET(a->type, SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET}
)/sizeof(int)]; switch(a->type) { case SOCK_STREAM: case SOCK_DGRAM
: case SOCK_SEQPACKET: _found = 1; break; default: break; } _found
; }))
                      return -EINVAL22;

              return 0;

      case AF_NETLINK16:

              if (a->size != sizeof(struct sockaddr_nl))
                      return -EINVAL22;

              if (!IN_SET(a->type, SOCK_RAW, SOCK_DGRAM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SOCK_RAW, SOCK_DGRAM})/sizeof(int)]; switch
(a->type) { case SOCK_RAW: case SOCK_DGRAM: _found = 1; break
; default: break; } _found; }))
                      return -EINVAL22;

              return 0;

      case AF_VSOCK40:
              if (a->size != sizeof(struct sockaddr_vm))
                      return -EINVAL22;

              if (!IN_SET(a->type, SOCK_STREAM, SOCK_DGRAM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SOCK_STREAM, SOCK_DGRAM})/sizeof(int)]; switch
(a->type) { case SOCK_STREAM: case SOCK_DGRAM: _found = 1;
 break; default: break; } _found; }))
                      return -EINVAL22;

              return 0;

      default:
              return -EAFNOSUPPORT97;
      }
332}

334int socket_address_print(const SocketAddress *a, char **ret) {
      int r;

      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 337,
 __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/socket-util.c", 338
, __PRETTY_FUNCTION__); } while (0);

      r = socket_address_verify(a);
      if (r < 0)
              return r;

      if (socket_address_family(a)((a)->sockaddr.sa.sa_family) == AF_NETLINK16) {
              _cleanup_free___attribute__((cleanup(freep))) char *sfamily = NULL((void*)0);

              r = netlink_family_to_string_alloc(a->protocol, &sfamily);
              if (r < 0)
                      return r;

              r = asprintf(ret, "%s %u", sfamily, a->sockaddr.nl.nl_groups);
              if (r < 0)
                      return -ENOMEM12;

              return 0;
      }

      return sockaddr_pretty(&a->sockaddr.sa, a->size, false0, true1, ret);
359}

361bool_Bool socket_address_can_accept(const SocketAddress *a) {
      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 362,
 __PRETTY_FUNCTION__); } while (0);

      return
              IN_SET(a->type, SOCK_STREAM, SOCK_SEQPACKET)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SOCK_STREAM, SOCK_SEQPACKET})/sizeof(int
)]; switch(a->type) { case SOCK_STREAM: case SOCK_SEQPACKET
: _found = 1; break; default: break; } _found; });
366}

368bool_Bool socket_address_equal(const SocketAddress *a, const SocketAddress *b) {
      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 369,
 __PRETTY_FUNCTION__); } while (0);
      assert(b)do { if ((__builtin_expect(!!(!(b)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("b"), "../src/basic/socket-util.c", 370,
 __PRETTY_FUNCTION__); } while (0);

      /* Invalid addresses are unequal to all */
      if (socket_address_verify(a) < 0 ||
          socket_address_verify(b) < 0)
              return false0;

      if (a->type != b->type)
              return false0;

      if (socket_address_family(a)((a)->sockaddr.sa.sa_family) != socket_address_family(b)((b)->sockaddr.sa.sa_family))
              return false0;

      switch (socket_address_family(a)((a)->sockaddr.sa.sa_family)) {

      case AF_INET2:
              if (a->sockaddr.in.sin_addr.s_addr != b->sockaddr.in.sin_addr.s_addr)
                      return false0;

              if (a->sockaddr.in.sin_port != b->sockaddr.in.sin_port)
                      return false0;

              break;

      case AF_INET610:
              if (memcmp(&a->sockaddr.in6.sin6_addr, &b->sockaddr.in6.sin6_addr, sizeof(a->sockaddr.in6.sin6_addr)) != 0)
                      return false0;

              if (a->sockaddr.in6.sin6_port != b->sockaddr.in6.sin6_port)
                      return false0;

              break;

      case AF_UNIX1:
              if (a->size <= offsetof(struct sockaddr_un, sun_path)__builtin_offsetof(struct sockaddr_un, sun_path) ||
                  b->size <= offsetof(struct sockaddr_un, sun_path)__builtin_offsetof(struct sockaddr_un, sun_path))
                      return false0;

              if ((a->sockaddr.un.sun_path[0] == 0) != (b->sockaddr.un.sun_path[0] == 0))
                      return false0;

              if (a->sockaddr.un.sun_path[0]) {
                      if (!path_equal_or_files_same(a->sockaddr.un.sun_path, b->sockaddr.un.sun_path, 0))
                              return false0;
              } else {
                      if (a->size != b->size)
                              return false0;

                      if (memcmp(a->sockaddr.un.sun_path, b->sockaddr.un.sun_path, a->size) != 0)
                              return false0;
              }

              break;

      case AF_NETLINK16:
              if (a->protocol != b->protocol)
                      return false0;

              if (a->sockaddr.nl.nl_groups != b->sockaddr.nl.nl_groups)
                      return false0;

              break;

      case AF_VSOCK40:
              if (a->sockaddr.vm.svm_cid != b->sockaddr.vm.svm_cid)
                      return false0;

              if (a->sockaddr.vm.svm_port != b->sockaddr.vm.svm_port)
                      return false0;

              break;

      default:
              /* Cannot compare, so we assume the addresses are different */
              return false0;
      }

      return true1;
448}

450bool_Bool socket_address_is(const SocketAddress *a, const char *s, int type) {
      struct SocketAddress b;

      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 453,
 __PRETTY_FUNCTION__); } while (0);
      assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/basic/socket-util.c", 454,
 __PRETTY_FUNCTION__); } while (0);

      if (socket_address_parse(&b, s) < 0)
              return false0;

      b.type = type;

      return socket_address_equal(a, &b);
462}

464bool_Bool socket_address_is_netlink(const SocketAddress *a, const char *s) {
      struct SocketAddress b;

      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 467,
 __PRETTY_FUNCTION__); } while (0);
      assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/basic/socket-util.c", 468,
 __PRETTY_FUNCTION__); } while (0);

      if (socket_address_parse_netlink(&b, s) < 0)
              return false0;

      return socket_address_equal(a, &b);
474}

476const char* socket_address_get_path(const SocketAddress *a) {
      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 477,
 __PRETTY_FUNCTION__); } while (0);

      if (socket_address_family(a)((a)->sockaddr.sa.sa_family) != AF_UNIX1)
              return NULL((void*)0);

      if (a->sockaddr.un.sun_path[0] == 0)
              return NULL((void*)0);

      return a->sockaddr.un.sun_path;
486}

488bool_Bool socket_ipv6_is_supported(void) {
      if (access("/proc/net/if_inet6", F_OK0) != 0)
              return false0;

      return true1;
493}

495bool_Bool socket_address_matches_fd(const SocketAddress *a, int fd) {
      SocketAddress b;
      socklen_t solen;

      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 499,
 __PRETTY_FUNCTION__); } while (0);
      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/socket-util.c"
, 500, __PRETTY_FUNCTION__); } while (0);

      b.size = sizeof(b.sockaddr);
      if (getsockname(fd, &b.sockaddr.sa, &b.size) < 0)
              return false0;

      if (b.sockaddr.sa.sa_family != a->sockaddr.sa.sa_family)
              return false0;

      solen = sizeof(b.type);
      if (getsockopt(fd, SOL_SOCKET1, SO_TYPE3, &b.type, &solen) < 0)
              return false0;

      if (b.type != a->type)
              return false0;

      if (a->protocol != 0)  {
              solen = sizeof(b.protocol);
              if (getsockopt(fd, SOL_SOCKET1, SO_PROTOCOL38, &b.protocol, &solen) < 0)
                      return false0;

              if (b.protocol != a->protocol)
                      return false0;
      }

      return socket_address_equal(a, &b);
526}

528int sockaddr_port(const struct sockaddr *_sa, unsigned *ret_port) {
      union sockaddr_union *sa = (union sockaddr_union*) _sa;

      /* Note, this returns the port as 'unsigned' rather than 'uint16_t', as AF_VSOCK knows larger ports */

      assert(sa)do { if ((__builtin_expect(!!(!(sa)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sa"), "../src/basic/socket-util.c", 533
, __PRETTY_FUNCTION__); } while (0);

      switch (sa->sa.sa_family) {

      case AF_INET2:
              *ret_port = be16toh(sa->in.sin_port)__bswap_16 (sa->in.sin_port);
              return 0;

      case AF_INET610:
              *ret_port = be16toh(sa->in6.sin6_port)__bswap_16 (sa->in6.sin6_port);
              return 0;

      case AF_VSOCK40:
              *ret_port = sa->vm.svm_port;
              return 0;

      default:
              return -EAFNOSUPPORT97;
      }
552}

554int sockaddr_pretty(const struct sockaddr *_sa, socklen_t salen, bool_Bool translate_ipv6, bool_Bool include_port, char **ret) {
      union sockaddr_union *sa = (union sockaddr_union*) _sa;
      char *p;
      int r;

      assert(sa)do { if ((__builtin_expect(!!(!(sa)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sa"), "../src/basic/socket-util.c", 559
, __PRETTY_FUNCTION__); } while (0);
      assert(salen >= sizeof(sa->sa.sa_family))do { if ((__builtin_expect(!!(!(salen >= sizeof(sa->sa.
sa_family))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, (
"salen >= sizeof(sa->sa.sa_family)"), "../src/basic/socket-util.c"
, 560, __PRETTY_FUNCTION__); } while (0);

      switch (sa->sa.sa_family) {

      case AF_INET2: {
              uint32_t a;

              a = be32toh(sa->in.sin_addr.s_addr)__bswap_32 (sa->in.sin_addr.s_addr);

              if (include_port)
                      r = asprintf(&p,
                                   "%u.%u.%u.%u:%u",
                                   a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
                                   be16toh(sa->in.sin_port)__bswap_16 (sa->in.sin_port));
              else
                      r = asprintf(&p,
                                   "%u.%u.%u.%u",
                                   a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF);
              if (r < 0)
                      return -ENOMEM12;
              break;
      }

      case AF_INET610: {
              static const unsigned char ipv4_prefix[] = {
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
              };

              if (translate_ipv6 &&
                  memcmp(&sa->in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
                      const uint8_t *a = sa->in6.sin6_addr.s6_addr__in6_u.__u6_addr8+12;
                      if (include_port)
                              r = asprintf(&p,
                                           "%u.%u.%u.%u:%u",
                                           a[0], a[1], a[2], a[3],
                                           be16toh(sa->in6.sin6_port)__bswap_16 (sa->in6.sin6_port));
                      else
                              r = asprintf(&p,
                                           "%u.%u.%u.%u",
                                           a[0], a[1], a[2], a[3]);
                      if (r < 0)
                              return -ENOMEM12;
              } else {
                      char a[INET6_ADDRSTRLEN46];

                      inet_ntop(AF_INET610, &sa->in6.sin6_addr, a, sizeof(a));

                      if (include_port) {
                              r = asprintf(&p,
                                           "[%s]:%u",
                                           a,
                                           be16toh(sa->in6.sin6_port)__bswap_16 (sa->in6.sin6_port));
                              if (r < 0)
                                      return -ENOMEM12;
                      } else {
                              p = strdup(a);
                              if (!p)
                                      return -ENOMEM12;
                      }
              }

              break;
      }

      case AF_UNIX1:
              if (salen <= offsetof(struct sockaddr_un, sun_path)__builtin_offsetof(struct sockaddr_un, sun_path)) {
                      p = strdup("<unnamed>");
                      if (!p)
                              return -ENOMEM12;

              } else if (sa->un.sun_path[0] == 0) {
                      /* abstract */

                      /* FIXME: We assume we can print the
                       * socket path here and that it hasn't
                       * more than one NUL byte. That is
                       * actually an invalid assumption */

                      p = new(char, sizeof(sa->un.sun_path)+1)((char*) malloc_multiply(sizeof(char), (sizeof(sa->un.sun_path
)+1)));
                      if (!p)
                              return -ENOMEM12;

                      p[0] = '@';
                      memcpy(p+1, sa->un.sun_path+1, sizeof(sa->un.sun_path)-1);
                      p[sizeof(sa->un.sun_path)] = 0;

              } else {
                      p = strndup(sa->un.sun_path, sizeof(sa->un.sun_path));
                      if (!p)
                              return -ENOMEM12;
              }

              break;

      case AF_VSOCK40:
              if (include_port)
                      r = asprintf(&p,
                                   "vsock:%u:%u",
                                   sa->vm.svm_cid,
                                   sa->vm.svm_port);
              else
                      r = asprintf(&p, "vsock:%u", sa->vm.svm_cid);
              if (r < 0)
                      return -ENOMEM12;
              break;

      default:
              return -EOPNOTSUPP95;
      }

      *ret = p;
      return 0;
672}

674int getpeername_pretty(int fd, bool_Bool include_port, char **ret) {
      union sockaddr_union sa;
      socklen_t salen = sizeof(sa);
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/socket-util.c"
, 679, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/socket-util.c", 680
, __PRETTY_FUNCTION__); } while (0);

      if (getpeername(fd, &sa.sa, &salen) < 0)
              return -errno(*__errno_location ());

      if (sa.sa.sa_family == AF_UNIX1) {
              struct ucred ucred = {};

              /* UNIX connection sockets are anonymous, so let's use
               * PID/UID as pretty credentials instead */

              r = getpeercred(fd, &ucred);
              if (r < 0)
                      return r;

              if (asprintf(ret, "PID "PID_FMT"%" "i""/UID "UID_FMT"%" "u", ucred.pid, ucred.uid) < 0)
                      return -ENOMEM12;

              return 0;
      }

      /* For remote sockets we translate IPv6 addresses back to IPv4
       * if applicable, since that's nicer. */

      return sockaddr_pretty(&sa.sa, salen, true1, include_port, ret);
705}

707int getsockname_pretty(int fd, char **ret) {
      union sockaddr_union sa;
      socklen_t salen = sizeof(sa);

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/socket-util.c"
, 711, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/socket-util.c", 712
, __PRETTY_FUNCTION__); } while (0);

      if (getsockname(fd, &sa.sa, &salen) < 0)
              return -errno(*__errno_location ());

      /* For local sockets we do not translate IPv6 addresses back
       * to IPv6 if applicable, since this is usually used for
       * listening sockets where the difference between IPv4 and
       * IPv6 matters. */

      return sockaddr_pretty(&sa.sa, salen, false0, true1, ret);
723}

725int socknameinfo_pretty(union sockaddr_union *sa, socklen_t salen, char **_ret) {
      int r;
      char host[NI_MAXHOST1025], *ret;

      assert(_ret)do { if ((__builtin_expect(!!(!(_ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_ret"), "../src/basic/socket-util.c", 729
, __PRETTY_FUNCTION__); } while (0);

      r = getnameinfo(&sa->sa, salen, host, sizeof(host), NULL((void*)0), 0, IDN_FLAGS32);
      if (r != 0) {
              int saved_errno = errno(*__errno_location ());

              r = sockaddr_pretty(&sa->sa, salen, true1, true1, &ret);
              if (r < 0)
                      return r;

              log_debug_errno(saved_errno, "getnameinfo(%s) failed: %m", ret)({ int _level = ((7)), _e = ((saved_errno)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/socket-util.c", 739, __func__, "getnameinfo(%s) failed: %m"
, ret) : -abs(_e); });
      } else {
              ret = strdup(host);
              if (!ret)
                      return -ENOMEM12;
      }

      *_ret = ret;
      return 0;
748}

750int socket_address_unlink(SocketAddress *a) {
      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 751,
 __PRETTY_FUNCTION__); } while (0);

      if (socket_address_family(a)((a)->sockaddr.sa.sa_family) != AF_UNIX1)
              return 0;

      if (a->sockaddr.un.sun_path[0] == 0)
              return 0;

      if (unlink(a->sockaddr.un.sun_path) < 0)
              return -errno(*__errno_location ());

      return 1;
763}

765static const char* const netlink_family_table[] = {
      [NETLINK_ROUTE0] = "route",
      [NETLINK_FIREWALL3] = "firewall",
      [NETLINK_INET_DIAG4] = "inet-diag",
      [NETLINK_NFLOG5] = "nflog",
      [NETLINK_XFRM6] = "xfrm",
      [NETLINK_SELINUX7] = "selinux",
      [NETLINK_ISCSI8] = "iscsi",
      [NETLINK_AUDIT9] = "audit",
      [NETLINK_FIB_LOOKUP10] = "fib-lookup",
      [NETLINK_CONNECTOR11] = "connector",
      [NETLINK_NETFILTER12] = "netfilter",
      [NETLINK_IP6_FW13] = "ip6-fw",
      [NETLINK_DNRTMSG14] = "dnrtmsg",
      [NETLINK_KOBJECT_UEVENT15] = "kobject-uevent",
      [NETLINK_GENERIC16] = "generic",
      [NETLINK_SCSITRANSPORT18] = "scsitransport",
      [NETLINK_ECRYPTFS19] = "ecryptfs",
      [NETLINK_RDMA20] = "rdma",
784};

786DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(netlink_family, int, INT_MAX)int netlink_family_to_string_alloc(int i, char **str) { char *
s; if (i < 0 || i > 2147483647) return -34; if (i < (
int) __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(netlink_family_table), typeof(&*(netlink_family_table
))), sizeof(netlink_family_table)/sizeof((netlink_family_table
)[0]), ((void)0)))) { s = strdup(netlink_family_table[i]); if
 (!s) return -12; } else { if (asprintf(&s, "%i", i) <
 0) return -12; } *str = s; return 0; } int netlink_family_from_string
(const char *s) { int i; unsigned u = 0; if (!s) return (int)
 -1; for (i = 0; i < (int) __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(netlink_family_table),
 typeof(&*(netlink_family_table))), sizeof(netlink_family_table
)/sizeof((netlink_family_table)[0]), ((void)0))); i++) if (streq_ptr
(netlink_family_table[i], s)) return i; if (safe_atou(s, &
u) >= 0 && u <= 2147483647) return (int) u; return
 (int) -1; };

788static const char* const socket_address_bind_ipv6_only_table[_SOCKET_ADDRESS_BIND_IPV6_ONLY_MAX] = {
      [SOCKET_ADDRESS_DEFAULT] = "default",
      [SOCKET_ADDRESS_BOTH] = "both",
      [SOCKET_ADDRESS_IPV6_ONLY] = "ipv6-only"
792};

794DEFINE_STRING_TABLE_LOOKUP(socket_address_bind_ipv6_only, SocketAddressBindIPv6Only)const char *socket_address_bind_ipv6_only_to_string(SocketAddressBindIPv6Only
 i) { if (i < 0 || i >= (SocketAddressBindIPv6Only) __extension__
 (__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(socket_address_bind_ipv6_only_table), typeof(&*(socket_address_bind_ipv6_only_table
))), sizeof(socket_address_bind_ipv6_only_table)/sizeof((socket_address_bind_ipv6_only_table
)[0]), ((void)0)))) return ((void*)0); return socket_address_bind_ipv6_only_table
[i]; } SocketAddressBindIPv6Only socket_address_bind_ipv6_only_from_string
(const char *s) { return (SocketAddressBindIPv6Only) string_table_lookup
(socket_address_bind_ipv6_only_table, __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(socket_address_bind_ipv6_only_table
), typeof(&*(socket_address_bind_ipv6_only_table))), sizeof
(socket_address_bind_ipv6_only_table)/sizeof((socket_address_bind_ipv6_only_table
)[0]), ((void)0))), s); };

796SocketAddressBindIPv6Only socket_address_bind_ipv6_only_or_bool_from_string(const char *n) {
      int r;

      r = parse_boolean(n);
      if (r > 0)
              return SOCKET_ADDRESS_IPV6_ONLY;
      if (r == 0)
              return SOCKET_ADDRESS_BOTH;

      return socket_address_bind_ipv6_only_from_string(n);
806}

808bool_Bool sockaddr_equal(const union sockaddr_union *a, const union sockaddr_union *b) {
      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/socket-util.c", 809,
 __PRETTY_FUNCTION__); } while (0);
      assert(b)do { if ((__builtin_expect(!!(!(b)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("b"), "../src/basic/socket-util.c", 810,
 __PRETTY_FUNCTION__); } while (0);

      if (a->sa.sa_family != b->sa.sa_family)
              return false0;

      if (a->sa.sa_family == AF_INET2)
              return a->in.sin_addr.s_addr == b->in.sin_addr.s_addr;

      if (a->sa.sa_family == AF_INET610)
              return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr)) == 0;

      if (a->sa.sa_family == AF_VSOCK40)
              return a->vm.svm_cid == b->vm.svm_cid;

      return false0;
825}

827int fd_inc_sndbuf(int fd, size_t n) {
      int r, value;
      socklen_t l = sizeof(value);

      r = getsockopt(fd, SOL_SOCKET1, SO_SNDBUF7, &value, &l);
      if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
              return 0;

      /* If we have the privileges we will ignore the kernel limit. */

      value = (int) n;
      if (setsockopt(fd, SOL_SOCKET1, SO_SNDBUFFORCE32, &value, sizeof(value)) < 0)
              if (setsockopt(fd, SOL_SOCKET1, SO_SNDBUF7, &value, sizeof(value)) < 0)
                      return -errno(*__errno_location ());

      return 1;
843}

845int fd_inc_rcvbuf(int fd, size_t n) {
      int r, value;
      socklen_t l = sizeof(value);

      r = getsockopt(fd, SOL_SOCKET1, SO_RCVBUF8, &value, &l);
      if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
              return 0;

      /* If we have the privileges we will ignore the kernel limit. */

      value = (int) n;
      if (setsockopt(fd, SOL_SOCKET1, SO_RCVBUFFORCE33, &value, sizeof(value)) < 0)
              if (setsockopt(fd, SOL_SOCKET1, SO_RCVBUF8, &value, sizeof(value)) < 0)
                      return -errno(*__errno_location ());
      return 1;
860}

862static const char* const ip_tos_table[] = {
      [IPTOS_LOWDELAY0x10] = "low-delay",
      [IPTOS_THROUGHPUT0x08] = "throughput",
      [IPTOS_RELIABILITY0x04] = "reliability",
      [IPTOS_LOWCOST0x02] = "low-cost",
867};

869DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff)int ip_tos_to_string_alloc(int i, char **str) { char *s; if (
i < 0 || i > 0xff) return -34; if (i < (int) __extension__
 (__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(ip_tos_table), typeof(&*(ip_tos_table))), sizeof(ip_tos_table
)/sizeof((ip_tos_table)[0]), ((void)0)))) { s = strdup(ip_tos_table
[i]); if (!s) return -12; } else { if (asprintf(&s, "%i",
 i) < 0) return -12; } *str = s; return 0; } int ip_tos_from_string
(const char *s) { int i; unsigned u = 0; if (!s) return (int)
 -1; for (i = 0; i < (int) __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(ip_tos_table), typeof(
&*(ip_tos_table))), sizeof(ip_tos_table)/sizeof((ip_tos_table
)[0]), ((void)0))); i++) if (streq_ptr(ip_tos_table[i], s)) return
 i; if (safe_atou(s, &u) >= 0 && u <= 0xff)
 return (int) u; return (int) -1; };

871bool_Bool ifname_valid(const char *p) {
      bool_Bool numeric = true1;

      /* Checks whether a network interface name is valid. This is inspired by dev_valid_name() in the kernel sources
       * but slightly stricter, as we only allow non-control, non-space ASCII characters in the interface name. We
       * also don't permit names that only container numbers, to avoid confusion with numeric interface indexes. */

      if (isempty(p))
              return false0;

      if (strlen(p) >= IFNAMSIZ16)
              return false0;

      if (dot_or_dot_dot(p))
              return false0;

      while (*p) {
              if ((unsigned char) *p >= 127U)
                      return false0;

              if ((unsigned char) *p <= 32U)
                      return false0;

              if (IN_SET(*p, ':', '/')({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){':', '/'})/sizeof(int)]; switch(*p) { case
 ':': case '/': _found = 1; break; default: break; } _found; }
))
                      return false0;

              numeric = numeric && (*p >= '0' && *p <= '9');
              p++;
      }

      if (numeric)
              return false0;

      return true1;
905}

907bool_Bool address_label_valid(const char *p) {

      if (isempty(p))
              return false0;

      if (strlen(p) >= IFNAMSIZ16)
              return false0;

      while (*p) {
              if ((uint8_t) *p >= 127U)
                      return false0;

              if ((uint8_t) *p <= 31U)
                      return false0;
              p++;
      }

      return true1;
925}

927int getpeercred(int fd, struct ucred *ucred) {
      socklen_t n = sizeof(struct ucred);
      struct ucred u;
      int r;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/socket-util.c"
, 932, __PRETTY_FUNCTION__); } while (0);
      assert(ucred)do { if ((__builtin_expect(!!(!(ucred)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ucred"), "../src/basic/socket-util.c", 933
, __PRETTY_FUNCTION__); } while (0);

      r = getsockopt(fd, SOL_SOCKET1, SO_PEERCRED17, &u, &n);
      if (r < 0)
              return -errno(*__errno_location ());

      if (n != sizeof(struct ucred))
              return -EIO5;

      /* Check if the data is actually useful and not suppressed due to namespacing issues */
      if (!pid_is_valid(u.pid))
              return -ENODATA61;

      /* Note that we don't check UID/GID here, as namespace translation works differently there: instead of
       * receiving in "invalid" user/group we get the overflow UID/GID. */

      *ucred = u;
      return 0;
951}

953int getpeersec(int fd, char **ret) {
      _cleanup_free___attribute__((cleanup(freep))) char *s = NULL((void*)0);
      socklen_t n = 64;

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/socket-util.c"
, 957, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/socket-util.c", 958
, __PRETTY_FUNCTION__); } while (0);

      for (;;) {
              s = new0(char, n+1)((char*) calloc((n+1), sizeof(char)));
              if (!s)
                      return -ENOMEM12;

              if (getsockopt(fd, SOL_SOCKET1, SO_PEERSEC31, s, &n) >= 0)
                      break;

              if (errno(*__errno_location ()) != ERANGE34)
                      return -errno(*__errno_location ());

              s = mfree(s);
      }

      if (isempty(s))
              return -EOPNOTSUPP95;

      *ret = TAKE_PTR(s)({ typeof(s) _ptr_ = (s); (s) = ((void*)0); _ptr_; });

      return 0;
980}

982int getpeergroups(int fd, gid_t **ret) {
      socklen_t n = sizeof(gid_t) * 64;
      _cleanup_free___attribute__((cleanup(freep))) gid_t *d = NULL((void*)0);

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/socket-util.c"
, 986, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/socket-util.c", 987
, __PRETTY_FUNCTION__); } while (0);

      for (;;) {
              d = malloc(n);
              if (!d)
                      return -ENOMEM12;

              if (getsockopt(fd, SOL_SOCKET1, SO_PEERGROUPS59, d, &n) >= 0)
                      break;

              if (errno(*__errno_location ()) != ERANGE34)
                      return -errno(*__errno_location ());

              d = mfree(d);
      }

      assert_se(n % sizeof(gid_t) == 0)do { if ((__builtin_expect(!!(!(n % sizeof(gid_t) == 0)),0)))
 log_assert_failed_realm(LOG_REALM_SYSTEMD, ("n % sizeof(gid_t) == 0"
), "../src/basic/socket-util.c", 1003, __PRETTY_FUNCTION__); }
 while (0);
      n /= sizeof(gid_t);

      if ((socklen_t) (int) n != n)
              return -E2BIG7;

      *ret = TAKE_PTR(d)({ typeof(d) _ptr_ = (d); (d) = ((void*)0); _ptr_; });

      return (int) n;
1012}

1014ssize_t send_one_fd_iov_sa(
              int transport_fd,
              int fd,
              struct iovec *iov, size_t iovlen,
              const struct sockaddr *sa, socklen_t len,
              int flags) {

      union {
              struct cmsghdr cmsghdr;
              uint8_t buf[CMSG_SPACE(sizeof(int))((((sizeof(int)) + sizeof (size_t) - 1) & (size_t) ~(sizeof
 (size_t) - 1)) + (((sizeof (struct cmsghdr)) + sizeof (size_t
) - 1) & (size_t) ~(sizeof (size_t) - 1)))];
      } control = {};
      struct msghdr mh = {
              .msg_name = (struct sockaddr*) sa,
              .msg_namelen = len,
              .msg_iov = iov,
              .msg_iovlen = iovlen,
      };
      ssize_t k;

      assert(transport_fd >= 0)do { if ((__builtin_expect(!!(!(transport_fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("transport_fd >= 0"), "../src/basic/socket-util.c"
, 1033, __PRETTY_FUNCTION__); } while (0);

      /*
       * We need either an FD or data to send.
       * If there's nothing, return an error.
       */
      if (fd < 0 && !iov)
              return -EINVAL22;

      if (fd >= 0) {
              struct cmsghdr *cmsg;

              mh.msg_control = &control;
              mh.msg_controllen = sizeof(control);

              cmsg = CMSG_FIRSTHDR(&mh)((size_t) (&mh)->msg_controllen >= sizeof (struct cmsghdr
) ? (struct cmsghdr *) (&mh)->msg_control : (struct cmsghdr
 *) 0);
              cmsg->cmsg_level = SOL_SOCKET1;
              cmsg->cmsg_type = SCM_RIGHTSSCM_RIGHTS;
              cmsg->cmsg_len = CMSG_LEN(sizeof(int))((((sizeof (struct cmsghdr)) + sizeof (size_t) - 1) & (size_t
) ~(sizeof (size_t) - 1)) + (sizeof(int)));
              memcpy(CMSG_DATA(cmsg)((cmsg)->__cmsg_data), &fd, sizeof(int));

              mh.msg_controllen = CMSG_SPACE(sizeof(int))((((sizeof(int)) + sizeof (size_t) - 1) & (size_t) ~(sizeof
 (size_t) - 1)) + (((sizeof (struct cmsghdr)) + sizeof (size_t
) - 1) & (size_t) ~(sizeof (size_t) - 1)));
      }
      k = sendmsg(transport_fd, &mh, MSG_NOSIGNALMSG_NOSIGNAL | flags);
      if (k < 0)
              return (ssize_t) -errno(*__errno_location ());

      return k;
1061}

1063int send_one_fd_sa(
              int transport_fd,
              int fd,
              const struct sockaddr *sa, socklen_t len,
              int flags) {

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/socket-util.c"
, 1069, __PRETTY_FUNCTION__); } while (0);

      return (int) send_one_fd_iov_sa(transport_fd, fd, NULL((void*)0), 0, sa, len, flags);
1072}

1074ssize_t receive_one_fd_iov(
              int transport_fd,
              struct iovec *iov, size_t iovlen,
              int flags,
              int *ret_fd) {

      union {
              struct cmsghdr cmsghdr;
              uint8_t buf[CMSG_SPACE(sizeof(int))((((sizeof(int)) + sizeof (size_t) - 1) & (size_t) ~(sizeof
 (size_t) - 1)) + (((sizeof (struct cmsghdr)) + sizeof (size_t
) - 1) & (size_t) ~(sizeof (size_t) - 1)))];
      } control = {};
      struct msghdr mh = {
              .msg_control = &control,
              .msg_controllen = sizeof(control),
              .msg_iov = iov,
              .msg_iovlen = iovlen,
      };
      struct cmsghdr *cmsg, *found = NULL((void*)0);
      ssize_t k;

      assert(transport_fd >= 0)do { if ((__builtin_expect(!!(!(transport_fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("transport_fd >= 0"), "../src/basic/socket-util.c"
, 1093, __PRETTY_FUNCTION__); } while (0);
      assert(ret_fd)do { if ((__builtin_expect(!!(!(ret_fd)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret_fd"), "../src/basic/socket-util.c",
 1094, __PRETTY_FUNCTION__); } while (0);

      /*
       * Receive a single FD via @transport_fd. We don't care for
       * the transport-type. We retrieve a single FD at most, so for
       * packet-based transports, the caller must ensure to send
       * only a single FD per packet.  This is best used in
       * combination with send_one_fd().
       */

      k = recvmsg(transport_fd, &mh, MSG_CMSG_CLOEXECMSG_CMSG_CLOEXEC | flags);
      if (k < 0)
              return (ssize_t) -errno(*__errno_location ());

      CMSG_FOREACH(cmsg, &mh)for ((cmsg) = ((size_t) (&mh)->msg_controllen >= sizeof
 (struct cmsghdr) ? (struct cmsghdr *) (&mh)->msg_control
 : (struct cmsghdr *) 0); (cmsg); (cmsg) = __cmsg_nxthdr ((&
mh), (cmsg))) {
              if (cmsg->cmsg_level == SOL_SOCKET1 &&
                  cmsg->cmsg_type == SCM_RIGHTSSCM_RIGHTS &&
                  cmsg->cmsg_len == CMSG_LEN(sizeof(int))((((sizeof (struct cmsghdr)) + sizeof (size_t) - 1) & (size_t
) ~(sizeof (size_t) - 1)) + (sizeof(int)))) {
                      assert(!found)do { if ((__builtin_expect(!!(!(!found)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!found"), "../src/basic/socket-util.c",
 1112, __PRETTY_FUNCTION__); } while (0);
                      found = cmsg;
                      break;
              }
      }

      if (!found)
              cmsg_close_all(&mh);

      /* If didn't receive an FD or any data, return an error. */
      if (k == 0 && !found)
              return -EIO5;

      if (found)
              *ret_fd = *(int*) CMSG_DATA(found)((found)->__cmsg_data);
      else
              *ret_fd = -1;

      return k;
1131}

1133int receive_one_fd(int transport_fd, int flags) {
      int fd;
      ssize_t k;

      k = receive_one_fd_iov(transport_fd, NULL((void*)0), 0, flags, &fd);
      if (k == 0)
              return fd;

      /* k must be negative, since receive_one_fd_iov() only returns
       * a positive value if data was received through the iov. */
      assert(k < 0)do { if ((__builtin_expect(!!(!(k < 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("k < 0"), "../src/basic/socket-util.c"
, 1143, __PRETTY_FUNCTION__); } while (0);
      return (int) k;
1145}

1147ssize_t next_datagram_size_fd(int fd) {
      ssize_t l;
      int k;

      /* This is a bit like FIONREAD/SIOCINQ, however a bit more powerful. The difference being: recv(MSG_PEEK) will
       * actually cause the next datagram in the queue to be validated regarding checksums, which FIONREAD doesn't
       * do. This difference is actually of major importance as we need to be sure that the size returned here
       * actually matches what we will read with recvmsg() next, as otherwise we might end up allocating a buffer of
       * the wrong size. */

      l = recv(fd, NULL((void*)0), 0, MSG_PEEKMSG_PEEK|MSG_TRUNCMSG_TRUNC);
      if (l < 0) {
              if (IN_SET(errno, EOPNOTSUPP, EFAULT)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){95, 14})/sizeof(int)]; switch((*__errno_location
 ())) { case 95: case 14: _found = 1; break; default: break; }
 _found; }))
                      goto fallback;

              return -errno(*__errno_location ());
      }
      if (l == 0)
              goto fallback;

      return l;

1169fallback:
      k = 0;

      /* Some sockets (AF_PACKET) do not support null-sized recv() with MSG_TRUNC set, let's fall back to FIONREAD
       * for them. Checksums don't matter for raw sockets anyway, hence this should be fine. */

      if (ioctl(fd, FIONREAD0x541B, &k) < 0)
              return -errno(*__errno_location ());

      return (ssize_t) k;
1179}

1181int flush_accept(int fd) {

      struct pollfd pollfd = {
              .fd = fd,
              .events = POLLIN0x001,
      };
      int r;

      /* Similar to flush_fd() but flushes all incoming connection by accepting them and immediately closing them. */

      for (;;) {
              int cfd;

              r = poll(&pollfd, 1, 0);
              if (r < 0) {
                      if (errno(*__errno_location ()) == EINTR4)
                              continue;

                      return -errno(*__errno_location ());

              } else if (r == 0)
                      return 0;

              cfd = accept4(fd, NULL((void*)0), NULL((void*)0), SOCK_NONBLOCKSOCK_NONBLOCK|SOCK_CLOEXECSOCK_CLOEXEC);
              if (cfd < 0) {
                      if (errno(*__errno_location ()) == EINTR4)
                              continue;

                      if (errno(*__errno_location ()) == EAGAIN11)
                              return 0;

                      return -errno(*__errno_location ());
              }

              close(cfd);
      }
1217}

1219struct cmsghdr* cmsg_find(struct msghdr *mh, int level, int type, socklen_t length) {
      struct cmsghdr *cmsg;

      assert(mh)do { if ((__builtin_expect(!!(!(mh)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("mh"), "../src/basic/socket-util.c", 1222
, __PRETTY_FUNCTION__); } while (0);

      CMSG_FOREACH(cmsg, mh)for ((cmsg) = ((size_t) (mh)->msg_controllen >= sizeof (
struct cmsghdr) ? (struct cmsghdr *) (mh)->msg_control : (
struct cmsghdr *) 0); (cmsg); (cmsg) = __cmsg_nxthdr ((mh), (
cmsg)))
              if (cmsg->cmsg_level == level &&
                  cmsg->cmsg_type == type &&
                  (length == (socklen_t) -1 || length == cmsg->cmsg_len))
                      return cmsg;

      return NULL((void*)0);
1231}

1233int socket_ioctl_fd(void) {
      int fd;

      /* Create a socket to invoke the various network interface ioctl()s on. Traditionally only AF_INET was good for
       * that. Since kernel 4.6 AF_NETLINK works for this too. We first try to use AF_INET hence, but if that's not
       * available (for example, because it is made unavailable via SECCOMP or such), we'll fall back to the more
       * generic AF_NETLINK. */

      fd = socket(AF_INET2, SOCK_DGRAMSOCK_DGRAM|SOCK_CLOEXECSOCK_CLOEXEC, 0);
      if (fd < 0)
              fd = socket(AF_NETLINK16, SOCK_RAWSOCK_RAW|SOCK_CLOEXECSOCK_CLOEXEC, NETLINK_GENERIC16);
      if (fd < 0)
              return -errno(*__errno_location ());

      return fd;
1248}

1250int socket_pass_pktinfo(int fd, bool_Bool b) {
      int af;
      socklen_t sl = sizeof(af);

      if (getsockopt(fd, SOL_SOCKET1, SO_DOMAIN39, &af, &sl) < 0)
              return -errno(*__errno_location ());

      switch (af) {

      case AF_INET2:
              return setsockopt_int(fd, IPPROTO_IPIPPROTO_IP, IP_PKTINFO8, b);

      case AF_INET610:
              return setsockopt_int(fd, IPPROTO_IPV6IPPROTO_IPV6, IPV6_RECVPKTINFO49, b);

      case AF_NETLINK16:
              return setsockopt_int(fd, SOL_NETLINK270, NETLINK_PKTINFO3, b);

      default:
              return -EAFNOSUPPORT97;
      }
1271}