../src/libsystemd/sd-login/sd-login.c

Bug Summary

File:	build-scan/../src/libsystemd/sd-login/sd-login.c
Warning:	line 715, column 49 Potential leak of memory pointed to by 'b'

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 sd-login.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/udev/libudev-core.a.p -I src/udev -I ../src/udev -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/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 ../src/udev/net -I /usr/include/blkid -D _FILE_OFFSET_BITS=64 -D LOG_REALM=LOG_REALM_UDEV -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 hidden -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/libsystemd/sd-login/sd-login.c

../src/libsystemd/sd-login/sd-login.c

→

1/* SPDX-License-Identifier: LGPL-2.1+ */
2/***
3***/

5#include <errno(*__errno_location ()).h>
6#include <poll.h>
7#include <string.h>
8#include <sys/inotify.h>
9#include <unistd.h>

11#include "sd-login.h"

13#include "alloc-util.h"
14#include "cgroup-util.h"
15#include "dirent-util.h"
16#include "escape.h"
17#include "fd-util.h"
18#include "fileio.h"
19#include "format-util.h"
20#include "fs-util.h"
21#include "hostname-util.h"
22#include "io-util.h"
23#include "login-util.h"
24#include "macro.h"
25#include "parse-util.h"
26#include "path-util.h"
27#include "socket-util.h"
28#include "string-util.h"
29#include "strv.h"
30#include "user-util.h"
31#include "util.h"

33/* Error codes:
*
*    invalid input parameters                → -EINVAL
*    invalid fd                              → -EBADF
*    process does not exist                  → -ESRCH
*    cgroup does not exist                   → -ENOENT
*    machine, session does not exist         → -ENXIO
*    requested metadata on object is missing → -ENODATA
*/

43_public___attribute__ ((visibility("default"))) int sd_pid_get_session(pid_t pid, char **session) {
      int r;

      assert_return(pid >= 0, -EINVAL)do { if (!(((__builtin_expect(!!(pid >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("pid >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 46, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(session, -EINVAL)do { if (!(((__builtin_expect(!!(session),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("session"), "../src/libsystemd/sd-login/sd-login.c"
, 47, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = cg_pid_get_session(pid, session);
      return IN_SET(r, -ENXIO, -ENOMEDIUM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-6, -123})/sizeof(int)]; switch(r) { case
 -6: case -123: _found = 1; break; default: break; } _found; }
) ? -ENODATA61 : r;
51}

53_public___attribute__ ((visibility("default"))) int sd_pid_get_unit(pid_t pid, char **unit) {
      int r;

      assert_return(pid >= 0, -EINVAL)do { if (!(((__builtin_expect(!!(pid >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("pid >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 56, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(unit, -EINVAL)do { if (!(((__builtin_expect(!!(unit),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("unit"), "../src/libsystemd/sd-login/sd-login.c"
, 57, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = cg_pid_get_unit(pid, unit);
      return IN_SET(r, -ENXIO, -ENOMEDIUM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-6, -123})/sizeof(int)]; switch(r) { case
 -6: case -123: _found = 1; break; default: break; } _found; }
) ? -ENODATA61 : r;
61}

63_public___attribute__ ((visibility("default"))) int sd_pid_get_user_unit(pid_t pid, char **unit) {
      int r;

      assert_return(pid >= 0, -EINVAL)do { if (!(((__builtin_expect(!!(pid >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("pid >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 66, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(unit, -EINVAL)do { if (!(((__builtin_expect(!!(unit),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("unit"), "../src/libsystemd/sd-login/sd-login.c"
, 67, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = cg_pid_get_user_unit(pid, unit);
      return IN_SET(r, -ENXIO, -ENOMEDIUM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-6, -123})/sizeof(int)]; switch(r) { case
 -6: case -123: _found = 1; break; default: break; } _found; }
) ? -ENODATA61 : r;
71}

73_public___attribute__ ((visibility("default"))) int sd_pid_get_machine_name(pid_t pid, char **name) {
      int r;

      assert_return(pid >= 0, -EINVAL)do { if (!(((__builtin_expect(!!(pid >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("pid >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 76, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(name, -EINVAL)do { if (!(((__builtin_expect(!!(name),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("name"), "../src/libsystemd/sd-login/sd-login.c"
, 77, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = cg_pid_get_machine_name(pid, name);
      return IN_SET(r, -ENXIO, -ENOMEDIUM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-6, -123})/sizeof(int)]; switch(r) { case
 -6: case -123: _found = 1; break; default: break; } _found; }
) ? -ENODATA61 : r;
81}

83_public___attribute__ ((visibility("default"))) int sd_pid_get_slice(pid_t pid, char **slice) {
      int r;

      assert_return(pid >= 0, -EINVAL)do { if (!(((__builtin_expect(!!(pid >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("pid >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 86, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(slice, -EINVAL)do { if (!(((__builtin_expect(!!(slice),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("slice"), "../src/libsystemd/sd-login/sd-login.c"
, 87, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = cg_pid_get_slice(pid, slice);
      return IN_SET(r, -ENXIO, -ENOMEDIUM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-6, -123})/sizeof(int)]; switch(r) { case
 -6: case -123: _found = 1; break; default: break; } _found; }
) ? -ENODATA61 : r;
91}

93_public___attribute__ ((visibility("default"))) int sd_pid_get_user_slice(pid_t pid, char **slice) {
      int r;

      assert_return(pid >= 0, -EINVAL)do { if (!(((__builtin_expect(!!(pid >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("pid >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 96, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(slice, -EINVAL)do { if (!(((__builtin_expect(!!(slice),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("slice"), "../src/libsystemd/sd-login/sd-login.c"
, 97, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = cg_pid_get_user_slice(pid, slice);
      return IN_SET(r, -ENXIO, -ENOMEDIUM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-6, -123})/sizeof(int)]; switch(r) { case
 -6: case -123: _found = 1; break; default: break; } _found; }
) ? -ENODATA61 : r;
101}

103_public___attribute__ ((visibility("default"))) int sd_pid_get_owner_uid(pid_t pid, uid_t *uid) {
      int r;

      assert_return(pid >= 0, -EINVAL)do { if (!(((__builtin_expect(!!(pid >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("pid >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 106, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(uid, -EINVAL)do { if (!(((__builtin_expect(!!(uid),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("uid"), "../src/libsystemd/sd-login/sd-login.c"
, 107, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = cg_pid_get_owner_uid(pid, uid);
      return IN_SET(r, -ENXIO, -ENOMEDIUM)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-6, -123})/sizeof(int)]; switch(r) { case
 -6: case -123: _found = 1; break; default: break; } _found; }
) ? -ENODATA61 : r;
111}

113_public___attribute__ ((visibility("default"))) int sd_pid_get_cgroup(pid_t pid, char **cgroup) {
      char *c;
      int r;

      assert_return(pid >= 0, -EINVAL)do { if (!(((__builtin_expect(!!(pid >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("pid >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 117, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(cgroup, -EINVAL)do { if (!(((__builtin_expect(!!(cgroup),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("cgroup"), "../src/libsystemd/sd-login/sd-login.c"
, 118, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER"_systemd", pid, &c);
      if (r < 0)
              return r;

      /* The internal APIs return the empty string for the root
       * cgroup, let's return the "/" in the public APIs instead, as
       * that's easier and less ambiguous for people to grok. */
      if (isempty(c)) {
              free(c);
              c = strdup("/");
              if (!c)
                      return -ENOMEM12;

      }

      *cgroup = c;
      return 0;
137}

139_public___attribute__ ((visibility("default"))) int sd_peer_get_session(int fd, char **session) {
      struct ucred ucred = {};
      int r;

      assert_return(fd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(fd >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("fd >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 143, __PRETTY_FUNCTION__), 0))) return (-9); } while (0);
      assert_return(session, -EINVAL)do { if (!(((__builtin_expect(!!(session),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("session"), "../src/libsystemd/sd-login/sd-login.c"
, 144, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

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

      return cg_pid_get_session(ucred.pid, session);
151}

153_public___attribute__ ((visibility("default"))) int sd_peer_get_owner_uid(int fd, uid_t *uid) {
      struct ucred ucred;
      int r;

      assert_return(fd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(fd >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("fd >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 157, __PRETTY_FUNCTION__), 0))) return (-9); } while (0);
      assert_return(uid, -EINVAL)do { if (!(((__builtin_expect(!!(uid),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("uid"), "../src/libsystemd/sd-login/sd-login.c"
, 158, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

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

      return cg_pid_get_owner_uid(ucred.pid, uid);
165}

167_public___attribute__ ((visibility("default"))) int sd_peer_get_unit(int fd, char **unit) {
      struct ucred ucred;
      int r;

      assert_return(fd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(fd >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("fd >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 171, __PRETTY_FUNCTION__), 0))) return (-9); } while (0);
      assert_return(unit, -EINVAL)do { if (!(((__builtin_expect(!!(unit),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("unit"), "../src/libsystemd/sd-login/sd-login.c"
, 172, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

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

      return cg_pid_get_unit(ucred.pid, unit);
179}

181_public___attribute__ ((visibility("default"))) int sd_peer_get_user_unit(int fd, char **unit) {
      struct ucred ucred;
      int r;

      assert_return(fd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(fd >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("fd >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 185, __PRETTY_FUNCTION__), 0))) return (-9); } while (0);
      assert_return(unit, -EINVAL)do { if (!(((__builtin_expect(!!(unit),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("unit"), "../src/libsystemd/sd-login/sd-login.c"
, 186, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

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

      return cg_pid_get_user_unit(ucred.pid, unit);
193}

195_public___attribute__ ((visibility("default"))) int sd_peer_get_machine_name(int fd, char **machine) {
      struct ucred ucred;
      int r;

      assert_return(fd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(fd >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("fd >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 199, __PRETTY_FUNCTION__), 0))) return (-9); } while (0);
      assert_return(machine, -EINVAL)do { if (!(((__builtin_expect(!!(machine),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("machine"), "../src/libsystemd/sd-login/sd-login.c"
, 200, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

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

      return cg_pid_get_machine_name(ucred.pid, machine);
207}

209_public___attribute__ ((visibility("default"))) int sd_peer_get_slice(int fd, char **slice) {
      struct ucred ucred;
      int r;

      assert_return(fd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(fd >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("fd >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 213, __PRETTY_FUNCTION__), 0))) return (-9); } while (0);
      assert_return(slice, -EINVAL)do { if (!(((__builtin_expect(!!(slice),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("slice"), "../src/libsystemd/sd-login/sd-login.c"
, 214, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

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

      return cg_pid_get_slice(ucred.pid, slice);
221}

223_public___attribute__ ((visibility("default"))) int sd_peer_get_user_slice(int fd, char **slice) {
      struct ucred ucred;
      int r;

      assert_return(fd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(fd >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("fd >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 227, __PRETTY_FUNCTION__), 0))) return (-9); } while (0);
      assert_return(slice, -EINVAL)do { if (!(((__builtin_expect(!!(slice),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("slice"), "../src/libsystemd/sd-login/sd-login.c"
, 228, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

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

      return cg_pid_get_user_slice(ucred.pid, slice);
235}

237_public___attribute__ ((visibility("default"))) int sd_peer_get_cgroup(int fd, char **cgroup) {
      struct ucred ucred;
      int r;

      assert_return(fd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(fd >= 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("fd >= 0"), "../src/libsystemd/sd-login/sd-login.c"
, 241, __PRETTY_FUNCTION__), 0))) return (-9); } while (0);
      assert_return(cgroup, -EINVAL)do { if (!(((__builtin_expect(!!(cgroup),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("cgroup"), "../src/libsystemd/sd-login/sd-login.c"
, 242, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

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

      return sd_pid_get_cgroup(ucred.pid, cgroup);
249}

251static int file_of_uid(uid_t uid, char **p) {

      assert_return(uid_is_valid(uid), -EINVAL)do { if (!(((__builtin_expect(!!(uid_is_valid(uid)),1))) ? (1
) : (log_assert_failed_return_realm(LOG_REALM_UDEV, ("uid_is_valid(uid)"
), "../src/libsystemd/sd-login/sd-login.c", 253, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);
      assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_UDEV, ("p"), "../src/libsystemd/sd-login/sd-login.c"
, 254, __PRETTY_FUNCTION__); } while (0);

      if (asprintf(p, "/run/systemd/users/" UID_FMT"%" "u", uid) < 0)
              return -ENOMEM12;

      return 0;
260}

262_public___attribute__ ((visibility("default"))) int sd_uid_get_state(uid_t uid, char**state) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      char *s = NULL((void*)0);
      int r;

      assert_return(state, -EINVAL)do { if (!(((__builtin_expect(!!(state),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("state"), "../src/libsystemd/sd-login/sd-login.c"
, 267, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = file_of_uid(uid, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", "STATE", &s, NULL((void*)0));
      if (r == -ENOENT2) {
              free(s);
              s = strdup("offline");
              if (!s)
                      return -ENOMEM12;

      }
      else if (r < 0) {
              free(s);
              return r;
      }
      if (isempty(s)) {
              free(s);
              return -EIO5;
      }

      *state = s;
      return 0;
292}

294_public___attribute__ ((visibility("default"))) int sd_uid_get_display(uid_t uid, char **session) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0);
      int r;

      assert_return(session, -EINVAL)do { if (!(((__builtin_expect(!!(session),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("session"), "../src/libsystemd/sd-login/sd-login.c"
, 298, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = file_of_uid(uid, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", "DISPLAY", &s, NULL((void*)0));
      if (r == -ENOENT2)
              return -ENODATA61;
      if (r < 0)
              return r;
      if (isempty(s))
              return -ENODATA61;

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

      return 0;
315}

317static int file_of_seat(const char *seat, char **_p) {
      char *p;
      int r;

      assert(_p)do { if ((__builtin_expect(!!(!(_p)),0))) log_assert_failed_realm
(LOG_REALM_UDEV, ("_p"), "../src/libsystemd/sd-login/sd-login.c"
, 321, __PRETTY_FUNCTION__); } while (0);

      if (seat) {
              if (!filename_is_valid(seat))
                      return -EINVAL22;

              p = strappend("/run/systemd/seats/", seat);
      } else {
              _cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);

              r = sd_session_get_seat(NULL((void*)0), &buf);
              if (r < 0)
                      return r;

              p = strappend("/run/systemd/seats/", buf);
      }

      if (!p)
              return -ENOMEM12;

      *_p = TAKE_PTR(p)({ typeof(p) _ptr_ = (p); (p) = ((void*)0); _ptr_; });
      return 0;
343}

345_public___attribute__ ((visibility("default"))) int sd_uid_is_on_seat(uid_t uid, int require_active, const char *seat) {
      _cleanup_free___attribute__((cleanup(freep))) char *t = NULL((void*)0), *s = NULL((void*)0), *p = NULL((void*)0);
      size_t l;
      int r;
      const char *word, *variable, *state;

      assert_return(uid_is_valid(uid), -EINVAL)do { if (!(((__builtin_expect(!!(uid_is_valid(uid)),1))) ? (1
) : (log_assert_failed_return_realm(LOG_REALM_UDEV, ("uid_is_valid(uid)"
), "../src/libsystemd/sd-login/sd-login.c", 351, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);

      r = file_of_seat(seat, &p);
      if (r < 0)
              return r;

      variable = require_active ? "ACTIVE_UID" : "UIDS";

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", variable, &s, NULL((void*)0));
      if (r == -ENOENT2)
              return 0;
      if (r < 0)
              return r;
      if (isempty(s))
              return 0;

      if (asprintf(&t, UID_FMT"%" "u", uid) < 0)
              return -ENOMEM12;

      FOREACH_WORD(word, l, s, state)for ((state) = (s), (word) = split(&(state), &(l), (" \t\n\r"
), (0)); (word); (word) = split(&(state), &(l), (" \t\n\r"
), (0)))
              if (strneq(t, word, l)(strncmp((t), (word), (l)) == 0))
                      return 1;

      return 0;
375}

377static int uid_get_array(uid_t uid, const char *variable, char ***array) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0);
      char **a;
      int r;

      assert(variable)do { if ((__builtin_expect(!!(!(variable)),0))) log_assert_failed_realm
(LOG_REALM_UDEV, ("variable"), "../src/libsystemd/sd-login/sd-login.c"
, 382, __PRETTY_FUNCTION__); } while (0);

      r = file_of_uid(uid, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", variable, &s, NULL((void*)0));
      if (r == -ENOENT2 || (r >= 0 && isempty(s))) {
              if (array)
                      *array = NULL((void*)0);
              return 0;
      }
      if (r < 0)
              return r;

      a = strv_split(s, " ");
      if (!a)
              return -ENOMEM12;

      strv_uniq(a);
      r = (int) strv_length(a);

      if (array)
              *array = a;
      else
              strv_free(a);

      return r;
410}

412_public___attribute__ ((visibility("default"))) int sd_uid_get_sessions(uid_t uid, int require_active, char ***sessions) {
      return uid_get_array(
                      uid,
                      require_active == 0 ? "ONLINE_SESSIONS" :
                      require_active > 0  ? "ACTIVE_SESSIONS" :
                                            "SESSIONS",
                      sessions);
419}

421_public___attribute__ ((visibility("default"))) int sd_uid_get_seats(uid_t uid, int require_active, char ***seats) {
      return uid_get_array(
                      uid,
                      require_active == 0 ? "ONLINE_SEATS" :
                      require_active > 0  ? "ACTIVE_SEATS" :
                                            "SEATS",
                      seats);
428}

430static int file_of_session(const char *session, char **_p) {
      char *p;
      int r;

      assert(_p)do { if ((__builtin_expect(!!(!(_p)),0))) log_assert_failed_realm
(LOG_REALM_UDEV, ("_p"), "../src/libsystemd/sd-login/sd-login.c"
, 434, __PRETTY_FUNCTION__); } while (0);

      if (session) {
              if (!session_id_valid(session))
                      return -EINVAL22;

              p = strappend("/run/systemd/sessions/", session);
      } else {
              _cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);

              r = sd_pid_get_session(0, &buf);
              if (r < 0)
                      return r;

              p = strappend("/run/systemd/sessions/", buf);
      }

      if (!p)
              return -ENOMEM12;

      *_p = p;
      return 0;
456}

458_public___attribute__ ((visibility("default"))) int sd_session_is_active(const char *session) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0);
      int r;

      r = file_of_session(session, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", "ACTIVE", &s, NULL((void*)0));
      if (r == -ENOENT2)
              return -ENXIO6;
      if (r < 0)
              return r;
      if (isempty(s))
              return -EIO5;

      return parse_boolean(s);
475}

477_public___attribute__ ((visibility("default"))) int sd_session_is_remote(const char *session) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0);
      int r;

      r = file_of_session(session, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", "REMOTE", &s, NULL((void*)0));
      if (r == -ENOENT2)
              return -ENXIO6;
      if (r < 0)
              return r;
      if (isempty(s))
              return -ENODATA61;

      return parse_boolean(s);
494}

496_public___attribute__ ((visibility("default"))) int sd_session_get_state(const char *session, char **state) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0);
      int r;

      assert_return(state, -EINVAL)do { if (!(((__builtin_expect(!!(state),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("state"), "../src/libsystemd/sd-login/sd-login.c"
, 500, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = file_of_session(session, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", "STATE", &s, NULL((void*)0));
      if (r == -ENOENT2)
              return -ENXIO6;
      if (r < 0)
              return r;
      if (isempty(s))
              return -EIO5;

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

      return 0;
517}

519_public___attribute__ ((visibility("default"))) int sd_session_get_uid(const char *session, uid_t *uid) {
      int r;
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0);

      assert_return(uid, -EINVAL)do { if (!(((__builtin_expect(!!(uid),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("uid"), "../src/libsystemd/sd-login/sd-login.c"
, 523, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = file_of_session(session, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", "UID", &s, NULL((void*)0));
      if (r == -ENOENT2)
              return -ENXIO6;
      if (r < 0)
              return r;
      if (isempty(s))
              return -EIO5;

      return parse_uid(s, uid);
538}

540static int session_get_string(const char *session, const char *field, char **value) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0);
      int r;

      assert_return(value, -EINVAL)do { if (!(((__builtin_expect(!!(value),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("value"), "../src/libsystemd/sd-login/sd-login.c"
, 544, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert(field)do { if ((__builtin_expect(!!(!(field)),0))) log_assert_failed_realm
(LOG_REALM_UDEV, ("field"), "../src/libsystemd/sd-login/sd-login.c"
, 545, __PRETTY_FUNCTION__); } while (0);

      r = file_of_session(session, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", field, &s, NULL((void*)0));
      if (r == -ENOENT2)
              return -ENXIO6;
      if (r < 0)
              return r;
      if (isempty(s))
              return -ENODATA61;

      *value = TAKE_PTR(s)({ typeof(s) _ptr_ = (s); (s) = ((void*)0); _ptr_; });
      return 0;
561}

563_public___attribute__ ((visibility("default"))) int sd_session_get_seat(const char *session, char **seat) {
      return session_get_string(session, "SEAT", seat);
565}

567_public___attribute__ ((visibility("default"))) int sd_session_get_tty(const char *session, char **tty) {
      return session_get_string(session, "TTY", tty);
569}

571_public___attribute__ ((visibility("default"))) int sd_session_get_vt(const char *session, unsigned *vtnr) {
      _cleanup_free___attribute__((cleanup(freep))) char *vtnr_string = NULL((void*)0);
      unsigned u;
      int r;

      assert_return(vtnr, -EINVAL)do { if (!(((__builtin_expect(!!(vtnr),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("vtnr"), "../src/libsystemd/sd-login/sd-login.c"
, 576, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = session_get_string(session, "VTNR", &vtnr_string);
      if (r < 0)
              return r;

      r = safe_atou(vtnr_string, &u);
      if (r < 0)
              return r;

      *vtnr = u;
      return 0;
588}

590_public___attribute__ ((visibility("default"))) int sd_session_get_service(const char *session, char **service) {
      return session_get_string(session, "SERVICE", service);
592}

594_public___attribute__ ((visibility("default"))) int sd_session_get_type(const char *session, char **type) {
      return session_get_string(session, "TYPE", type);
596}

598_public___attribute__ ((visibility("default"))) int sd_session_get_class(const char *session, char **class) {
      return session_get_string(session, "CLASS", class);
600}

602_public___attribute__ ((visibility("default"))) int sd_session_get_desktop(const char *session, char **desktop) {
      _cleanup_free___attribute__((cleanup(freep))) char *escaped = NULL((void*)0);
      char *t;
      int r;

      assert_return(desktop, -EINVAL)do { if (!(((__builtin_expect(!!(desktop),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("desktop"), "../src/libsystemd/sd-login/sd-login.c"
, 607, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = session_get_string(session, "DESKTOP", &escaped);
      if (r < 0)
              return r;

      r = cunescape(escaped, 0, &t);
      if (r < 0)
              return r;

      *desktop = t;
      return 0;
619}

621_public___attribute__ ((visibility("default"))) int sd_session_get_display(const char *session, char **display) {
      return session_get_string(session, "DISPLAY", display);
623}

625_public___attribute__ ((visibility("default"))) int sd_session_get_remote_user(const char *session, char **remote_user) {
      return session_get_string(session, "REMOTE_USER", remote_user);
627}

629_public___attribute__ ((visibility("default"))) int sd_session_get_remote_host(const char *session, char **remote_host) {
      return session_get_string(session, "REMOTE_HOST", remote_host);
631}

633_public___attribute__ ((visibility("default"))) int sd_seat_get_active(const char *seat, char **session, uid_t *uid) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0), *t = NULL((void*)0);
      int r;

      assert_return(session || uid, -EINVAL)do { if (!(((__builtin_expect(!!(session || uid),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_UDEV, ("session || uid"
), "../src/libsystemd/sd-login/sd-login.c", 637, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);

      r = file_of_seat(seat, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r",
                         "ACTIVE", &s,
                         "ACTIVE_UID", &t,
                         NULL((void*)0));
      if (r == -ENOENT2)
              return -ENXIO6;
      if (r < 0)
              return r;

      if (session && !s)
              return -ENODATA61;

      if (uid && !t)
              return -ENODATA61;

      if (uid && t) {
              r = parse_uid(t, uid);
              if (r < 0)
                      return r;
      }

      if (session && s)
              *session = TAKE_PTR(s)({ typeof(s) _ptr_ = (s); (s) = ((void*)0); _ptr_; });

      return 0;
668}

670_public___attribute__ ((visibility("default"))) int sd_seat_get_sessions(const char *seat, char ***sessions, uid_t **uids, unsigned *n_uids) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0), *t = NULL((void*)0);
      _cleanup_strv_free___attribute__((cleanup(strv_freep))) char **a = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) uid_t *b = NULL((void*)0);
      unsigned n = 0;
      int r;

      r = file_of_seat(seat, &p);
      if (r0.1
'r' is >= 0
1
'r' is >= 0
 < 0)
1
Taking false branch→
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r",
                         "SESSIONS", &s,
                         "UIDS", &t,
                         NULL((void*)0));
      if (r == -ENOENT2)
2
←
Assuming the condition is false→
3
←
Taking false branch→
              return -ENXIO6;
      if (r < 0)
4
←
Assuming 'r' is >= 0→
5
←
Taking false branch→
              return r;

      if (s) {
6
←
Assuming 's' is null→
7
←
Taking false branch→
              a = strv_split(s, " ");
              if (!a)
                      return -ENOMEM12;
      }

      if (uids && t) {
8
←
Assuming 'uids' is non-null→
9
←
Assuming 't' is non-null→
10
←
Taking true branch→
              const char *word, *state;
              size_t l;

              FOREACH_WORD(word, l, t, state)for ((state) = (t), (word) = split(&(state), &(l), (" \t\n\r"
), (0)); (word); (word) = split(&(state), &(l), (" \t\n\r"
), (0)))
11
←
Loop condition is true.  Entering loop body→
12
←
Loop condition is false. Execution continues on line 703→
                      n++;

              if (n12.1
'n' is > 0
1
'n' is > 0
 > 0) {
13
←
Taking true branch→
                      unsigned i = 0;

                      b = new(uid_t, n)((uid_t*) malloc_multiply(sizeof(uid_t), (n)));
14
←
Calling 'malloc_multiply'→
17
←
Returned allocated memory→
                      if (!b)
18
←
Assuming 'b' is non-null→
19
←
Taking false branch→
                              return -ENOMEM12;

                      FOREACH_WORD(word, l, t, state)for ((state) = (t), (word) = split(&(state), &(l), (" \t\n\r"
), (0)); (word); (word) = split(&(state), &(l), (" \t\n\r"
), (0))) {
20
←
Loop condition is true.  Entering loop body→
                              _cleanup_free___attribute__((cleanup(freep))) char *k = NULL((void*)0);

                              k = strndup(word, l);
                              if (!k)
21
←
Assuming 'k' is null→
22
←
Taking true branch→
                                      return -ENOMEM12;
23
←
Potential leak of memory pointed to by 'b'

                              r = parse_uid(k, b + i);
                              if (r < 0)
                                      return r;

                              i++;
                      }
              }
      }

      r = (int) strv_length(a);

      if (sessions)
              *sessions = TAKE_PTR(a)({ typeof(a) _ptr_ = (a); (a) = ((void*)0); _ptr_; });

      if (uids)
              *uids = TAKE_PTR(b)({ typeof(b) _ptr_ = (b); (b) = ((void*)0); _ptr_; });

      if (n_uids)
              *n_uids = n;

      return r;
738}

740static int seat_get_can(const char *seat, const char *variable) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0);
      int r;

      assert(variable)do { if ((__builtin_expect(!!(!(variable)),0))) log_assert_failed_realm
(LOG_REALM_UDEV, ("variable"), "../src/libsystemd/sd-login/sd-login.c"
, 744, __PRETTY_FUNCTION__); } while (0);

      r = file_of_seat(seat, &p);
      if (r < 0)
              return r;

      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r",
                         variable, &s,
                         NULL((void*)0));
      if (r == -ENOENT2)
              return -ENXIO6;
      if (r < 0)
              return r;
      if (isempty(s))
              return -ENODATA61;

      return parse_boolean(s);
761}

763_public___attribute__ ((visibility("default"))) int sd_seat_can_multi_session(const char *seat) {
      return seat_get_can(seat, "CAN_MULTI_SESSION");
765}

767_public___attribute__ ((visibility("default"))) int sd_seat_can_tty(const char *seat) {
      return seat_get_can(seat, "CAN_TTY");
769}

771_public___attribute__ ((visibility("default"))) int sd_seat_can_graphical(const char *seat) {
      return seat_get_can(seat, "CAN_GRAPHICAL");
773}

775_public___attribute__ ((visibility("default"))) int sd_get_seats(char ***seats) {
      int r;

      r = get_files_in_directory("/run/systemd/seats/", seats);
      if (r == -ENOENT2) {
              if (seats)
                      *seats = NULL((void*)0);
              return 0;
      }
      return r;
785}

787_public___attribute__ ((visibility("default"))) int sd_get_sessions(char ***sessions) {
      int r;

      r = get_files_in_directory("/run/systemd/sessions/", sessions);
      if (r == -ENOENT2) {
              if (sessions)
                      *sessions = NULL((void*)0);
              return 0;
      }
      return r;
797}

799_public___attribute__ ((visibility("default"))) int sd_get_uids(uid_t **users) {
      _cleanup_closedir___attribute__((cleanup(closedirp))) DIR *d;
      struct dirent *de;
      int r = 0;
      unsigned n = 0;
      _cleanup_free___attribute__((cleanup(freep))) uid_t *l = NULL((void*)0);

      d = opendir("/run/systemd/users/");
      if (!d) {
              if (errno(*__errno_location ()) == ENOENT2) {
                      if (users)
                              *users = NULL((void*)0);
                      return 0;
              }
              return -errno(*__errno_location ());
      }

      FOREACH_DIRENT_ALL(de, d, return -errno)for ((*__errno_location ()) = 0, de = readdir(d);; (*__errno_location
 ()) = 0, de = readdir(d)) if (!de) { if ((*__errno_location (
)) > 0) { return -(*__errno_location ()); } break; } else {
              int k;
              uid_t uid;

              dirent_ensure_type(d, de);

              if (!dirent_is_file(de))
                      continue;

              k = parse_uid(de->d_name, &uid);
              if (k < 0)
                      continue;

              if (users) {
                      if ((unsigned) r >= n) {
                              uid_t *t;

                              n = MAX(16, 2*r)__extension__ ({ const typeof((16)) __unique_prefix_A12 = ((16
)); const typeof((2*r)) __unique_prefix_B13 = ((2*r)); __unique_prefix_A12
 > __unique_prefix_B13 ? __unique_prefix_A12 : __unique_prefix_B13
; });
                              t = realloc(l, sizeof(uid_t) * n);
                              if (!t)
                                      return -ENOMEM12;

                              l = t;
                      }

                      assert((unsigned) r < n)do { if ((__builtin_expect(!!(!((unsigned) r < n)),0))) log_assert_failed_realm
(LOG_REALM_UDEV, ("(unsigned) r < n"), "../src/libsystemd/sd-login/sd-login.c"
, 841, __PRETTY_FUNCTION__); } while (0);
                      l[r++] = uid;
              } else
                      r++;
      }

      if (users)
              *users = TAKE_PTR(l)({ typeof(l) _ptr_ = (l); (l) = ((void*)0); _ptr_; });

      return r;
851}

853_public___attribute__ ((visibility("default"))) int sd_get_machine_names(char ***machines) {
      _cleanup_strv_free___attribute__((cleanup(strv_freep))) char **l = NULL((void*)0);
      char **a, **b;
      int r;

      r = get_files_in_directory("/run/systemd/machines/", &l);
      if (r == -ENOENT2) {
              if (machines)
                      *machines = NULL((void*)0);
              return 0;
      }
      if (r < 0)
              return r;

      if (l) {
              r = 0;

              /* Filter out the unit: symlinks */
              for (a = b = l; *a; a++) {
                      if (startswith(*a, "unit:") || !machine_name_is_valid(*a)hostname_is_valid(*a, 0))
                              free(*a);
                      else {
                              *b = *a;
                              b++;
                              r++;
                      }
              }

              *b = NULL((void*)0);
      }

      if (machines)
              *machines = TAKE_PTR(l)({ typeof(l) _ptr_ = (l); (l) = ((void*)0); _ptr_; });

      return r;
888}

890_public___attribute__ ((visibility("default"))) int sd_machine_get_class(const char *machine, char **class) {
      _cleanup_free___attribute__((cleanup(freep))) char *c = NULL((void*)0);
      const char *p;
      int r;

      assert_return(class, -EINVAL)do { if (!(((__builtin_expect(!!(class),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("class"), "../src/libsystemd/sd-login/sd-login.c"
, 895, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (streq(machine, ".host")(strcmp((machine),(".host")) == 0)) {
              c = strdup("host");
              if (!c)
                      return -ENOMEM12;
      } else {
              if (!machine_name_is_valid(machine)hostname_is_valid(machine, 0))
                      return -EINVAL22;

              p = strjoina("/run/systemd/machines/", machine)({ const char *_appendees_[] = { "/run/systemd/machines/", machine
 }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ =
 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
 (_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });
              r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", "CLASS", &c, NULL((void*)0));
              if (r == -ENOENT2)
                      return -ENXIO6;
              if (r < 0)
                      return r;
              if (!c)
                      return -EIO5;
      }

      *class = TAKE_PTR(c)({ typeof(c) _ptr_ = (c); (c) = ((void*)0); _ptr_; });
      return 0;
917}

919_public___attribute__ ((visibility("default"))) int sd_machine_get_ifindices(const char *machine, int **ifindices) {
      _cleanup_free___attribute__((cleanup(freep))) char *netif = NULL((void*)0);
      size_t l, allocated = 0, nr = 0;
      int *ni = NULL((void*)0);
      const char *p, *word, *state;
      int r;

      assert_return(machine_name_is_valid(machine), -EINVAL)do { if (!(((__builtin_expect(!!(hostname_is_valid(machine, 0
)),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_UDEV
, ("machine_name_is_valid(machine)"), "../src/libsystemd/sd-login/sd-login.c"
, 926, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(ifindices, -EINVAL)do { if (!(((__builtin_expect(!!(ifindices),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("ifindices"), "../src/libsystemd/sd-login/sd-login.c"
, 927, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      p = strjoina("/run/systemd/machines/", machine)({ const char *_appendees_[] = { "/run/systemd/machines/", machine
 }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ =
 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
 (_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });
      r = parse_env_file(NULL((void*)0), p, NEWLINE"\n\r", "NETIF", &netif, NULL((void*)0));
      if (r == -ENOENT2)
              return -ENXIO6;
      if (r < 0)
              return r;
      if (!netif) {
              *ifindices = NULL((void*)0);
              return 0;
      }

      FOREACH_WORD(word, l, netif, state)for ((state) = (netif), (word) = split(&(state), &(l)
, (" \t\n\r"), (0)); (word); (word) = split(&(state), &
(l), (" \t\n\r"), (0))) {
              char buf[l+1];
              int ifi;

              *(char*) (mempcpy(buf, word, l)) = 0;

              if (parse_ifindex(buf, &ifi) < 0)
                      continue;

              if (!GREEDY_REALLOC(ni, allocated, nr+1)greedy_realloc((void**) &(ni), &(allocated), (nr+1), sizeof
((ni)[0]))) {
                      free(ni);
                      return -ENOMEM12;
              }

              ni[nr++] = ifi;
      }

      *ifindices = ni;
      return nr;
959}

961static inline int MONITOR_TO_FD(sd_login_monitor *m) {
      return (int) (unsigned long) m - 1;
963}

965static inline sd_login_monitor* FD_TO_MONITOR(int fd) {
      return (sd_login_monitor*) (unsigned long) (fd + 1);
967}

969_public___attribute__ ((visibility("default"))) int sd_login_monitor_new(const char *category, sd_login_monitor **m) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;
      bool_Bool good = false0;
      int k;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("m"), "../src/libsystemd/sd-login/sd-login.c"
, 974, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      fd = inotify_init1(IN_NONBLOCKIN_NONBLOCK|IN_CLOEXECIN_CLOEXEC);
      if (fd < 0)
              return -errno(*__errno_location ());

      if (!category || streq(category, "seat")(strcmp((category),("seat")) == 0)) {
              k = inotify_add_watch(fd, "/run/systemd/seats/", IN_MOVED_TO0x00000080|IN_DELETE0x00000200);
              if (k < 0)
                      return -errno(*__errno_location ());

              good = true1;
      }

      if (!category || streq(category, "session")(strcmp((category),("session")) == 0)) {
              k = inotify_add_watch(fd, "/run/systemd/sessions/", IN_MOVED_TO0x00000080|IN_DELETE0x00000200);
              if (k < 0)
                      return -errno(*__errno_location ());

              good = true1;
      }

      if (!category || streq(category, "uid")(strcmp((category),("uid")) == 0)) {
              k = inotify_add_watch(fd, "/run/systemd/users/", IN_MOVED_TO0x00000080|IN_DELETE0x00000200);
              if (k < 0)
                      return -errno(*__errno_location ());

              good = true1;
      }

      if (!category || streq(category, "machine")(strcmp((category),("machine")) == 0)) {
              k = inotify_add_watch(fd, "/run/systemd/machines/", IN_MOVED_TO0x00000080|IN_DELETE0x00000200);
              if (k < 0)
                      return -errno(*__errno_location ());

              good = true1;
      }

      if (!good)
              return -EINVAL22;

      *m = FD_TO_MONITOR(fd);
      fd = -1;

      return 0;
1019}

1021_public___attribute__ ((visibility("default"))) sd_login_monitor* sd_login_monitor_unref(sd_login_monitor *m) {
      int fd;

      if (!m)
              return NULL((void*)0);

      fd = MONITOR_TO_FD(m);
      close_nointr(fd);

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

1033_public___attribute__ ((visibility("default"))) int sd_login_monitor_flush(sd_login_monitor *m) {
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("m"), "../src/libsystemd/sd-login/sd-login.c"
, 1036, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = flush_fd(MONITOR_TO_FD(m));
      if (r < 0)
              return r;

      return 0;
1043}

1045_public___attribute__ ((visibility("default"))) int sd_login_monitor_get_fd(sd_login_monitor *m) {

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("m"), "../src/libsystemd/sd-login/sd-login.c"
, 1047, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      return MONITOR_TO_FD(m);
1050}

1052_public___attribute__ ((visibility("default"))) int sd_login_monitor_get_events(sd_login_monitor *m) {

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("m"), "../src/libsystemd/sd-login/sd-login.c"
, 1054, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      /* For now we will only return POLLIN here, since we don't
       * need anything else ever for inotify.  However, let's have
       * this API to keep our options open should we later on need
       * it. */
      return POLLIN0x001;
1061}

1063_public___attribute__ ((visibility("default"))) int sd_login_monitor_get_timeout(sd_login_monitor *m, uint64_t *timeout_usec) {

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_UDEV, ("m"), "../src/libsystemd/sd-login/sd-login.c"
, 1065, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(timeout_usec, -EINVAL)do { if (!(((__builtin_expect(!!(timeout_usec),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_UDEV, ("timeout_usec"
), "../src/libsystemd/sd-login/sd-login.c", 1066, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);

      /* For now we will only return (uint64_t) -1, since we don't
       * need any timeout. However, let's have this API to keep our
       * options open should we later on need it. */
      *timeout_usec = (uint64_t) -1;
      return 0;
1073}

←

../src/basic/alloc-util.h

1/* SPDX-License-Identifier: LGPL-2.1+ */
2#pragma once
3 
4#include <alloca.h>
5#include <stddef.h>
6#include <stdlib.h>
7#include <string.h>
8 
9#include "macro.h"
10 
11#define new(t, n)((t*) malloc_multiply(sizeof(t), (n))) ((t*) malloc_multiply(sizeof(t), (n)))
12 
13#define new0(t, n)((t*) calloc((n), sizeof(t))) ((t*) calloc((n), sizeof(t)))
14 
15#define newa(t, n)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(t), n))),0))) log_assert_failed_realm(LOG_REALM_UDEV, ("!size_multiply_overflow(sizeof(t), n)"
), "../src/basic/alloc-util.h", 15, __PRETTY_FUNCTION__); } while
 (0); (t*) __builtin_alloca (sizeof(t)*(n)); })                                              \
16        ({                                                      \
17                assert(!size_multiply_overflow(sizeof(t), n))do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(t), n))),0))) log_assert_failed_realm(LOG_REALM_UDEV, ("!size_multiply_overflow(sizeof(t), n)"
), "../src/basic/alloc-util.h", 17, __PRETTY_FUNCTION__); } while
 (0);  \
18                (t*) alloca(sizeof(t)*(n))__builtin_alloca (sizeof(t)*(n));                     \
19        })
20 
21#define newa0(t, n)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(t), n))),0))) log_assert_failed_realm(LOG_REALM_UDEV, ("!size_multiply_overflow(sizeof(t), n)"
), "../src/basic/alloc-util.h", 21, __PRETTY_FUNCTION__); } while
 (0); (t*) ({ char *_new_; size_t _len_ = sizeof(t)*(n); _new_
 = __builtin_alloca (_len_); (void *) memset(_new_, 0, _len_)
; }); })                                             \
22        ({                                                      \
23                assert(!size_multiply_overflow(sizeof(t), n))do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(t), n))),0))) log_assert_failed_realm(LOG_REALM_UDEV, ("!size_multiply_overflow(sizeof(t), n)"
), "../src/basic/alloc-util.h", 23, __PRETTY_FUNCTION__); } while
 (0);  \
24                (t*) alloca0(sizeof(t)*(n))({ char *_new_; size_t _len_ = sizeof(t)*(n); _new_ = __builtin_alloca
 (_len_); (void *) memset(_new_, 0, _len_); });                    \
25        })
26 
27#define newdup(t, p, n)((t*) memdup_multiply(p, sizeof(t), (n))) ((t*) memdup_multiply(p, sizeof(t), (n)))
28 
29#define newdup_suffix0(t, p, n)((t*) memdup_suffix0_multiply(p, sizeof(t), (n))) ((t*) memdup_suffix0_multiply(p, sizeof(t), (n)))
30 
31#define malloc0(n)(calloc(1, (n))) (calloc(1, (n)))
32 
33static inline void *mfree(void *memory) {
34        free(memory);
35        return NULL((void*)0);
36}
37 
38#define free_and_replace(a, b)({ free(a); (a) = (b); (b) = ((void*)0); 0; })                  \
39        ({                                      \
40                free(a);                        \
41                (a) = (b);                      \
42                (b) = NULL((void*)0);                     \
43                0;                              \
44        })
45 
46void* memdup(const void *p, size_t l) _alloc_(2);
47void* memdup_suffix0(const void *p, size_t l) _alloc_(2);
48 
49static inline void freep(void *p) {
50        free(*(void**) p);
51}
52 
53#define _cleanup_free___attribute__((cleanup(freep))) _cleanup_(freep)__attribute__((cleanup(freep)))
54 
55static inline bool_Bool size_multiply_overflow(size_t size, size_t need) {
56        return _unlikely_(need != 0 && size > (SIZE_MAX / need))(__builtin_expect(!!(need != 0 && size > ((18446744073709551615UL
) / need)),0));
57}
58 
59_malloc___attribute__ ((malloc))  _alloc_(1, 2) static inline void *malloc_multiply(size_t size, size_t need) {
60        if (size_multiply_overflow(size, need))
15
←
Taking false branch→
61                return NULL((void*)0);
62 
63        return malloc(size * need);
16
←
Memory is allocated→
64}
65 
66#if !HAVE_REALLOCARRAY1
67_alloc_(2, 3) static inline void *reallocarray(void *p, size_t need, size_t size) {
68        if (size_multiply_overflow(size, need))
69                return NULL((void*)0);
70 
71        return realloc(p, size * need);
72}
73#endif
74 
75_alloc_(2, 3) static inline void *memdup_multiply(const void *p, size_t size, size_t need) {
76        if (size_multiply_overflow(size, need))
77                return NULL((void*)0);
78 
79        return memdup(p, size * need);
80}
81 
82_alloc_(2, 3) static inline void *memdup_suffix0_multiply(const void *p, size_t size, size_t need) {
83        if (size_multiply_overflow(size, need))
84                return NULL((void*)0);
85 
86        return memdup_suffix0(p, size * need);
87}
88 
89void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size);
90void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size);
91 
92#define GREEDY_REALLOC(array, allocated, need)greedy_realloc((void**) &(array), &(allocated), (need
), sizeof((array)[0]))                          \
93        greedy_realloc((void**) &(array), &(allocated), (need), sizeof((array)[0]))
94 
95#define GREEDY_REALLOC0(array, allocated, need)greedy_realloc0((void**) &(array), &(allocated), (need
), sizeof((array)[0]))                         \
96        greedy_realloc0((void**) &(array), &(allocated), (need), sizeof((array)[0]))
97 
98#define alloca0(n)({ char *_new_; size_t _len_ = n; _new_ = __builtin_alloca (_len_
); (void *) memset(_new_, 0, _len_); })                                      \
99        ({                                              \
100                char *_new_;                            \
101                size_t _len_ = n;                       \
102                _new_ = alloca(_len_)__builtin_alloca (_len_);                  \
103                (void *) memset(_new_, 0, _len_);       \
104        })
105 
106/* It's not clear what alignment glibc/gcc alloca() guarantee, hence provide a guaranteed safe version */
107#define alloca_align(size, align)({ void *_ptr_; size_t _mask_ = (align) - 1; _ptr_ = __builtin_alloca
 ((size) + _mask_); (void*)(((uintptr_t)_ptr_ + _mask_) &
 ~_mask_); })                                       \
108        ({                                                              \
109                void *_ptr_;                                            \
110                size_t _mask_ = (align) - 1;                            \
111                _ptr_ = alloca((size) + _mask_)__builtin_alloca ((size) + _mask_);                        \
112                (void*)(((uintptr_t)_ptr_ + _mask_) & ~_mask_);         \
113        })
114 
115#define alloca0_align(size, align)({ void *_new_; size_t _size_ = (size); _new_ = ({ void *_ptr_
; size_t _mask_ = ((align)) - 1; _ptr_ = __builtin_alloca ((_size_
) + _mask_); (void*)(((uintptr_t)_ptr_ + _mask_) & ~_mask_
); }); (void*)memset(_new_, 0, _size_); })                                      \
116        ({                                                              \
117                void *_new_;                                            \
118                size_t _size_ = (size);                                 \
119                _new_ = alloca_align(_size_, (align))({ void *_ptr_; size_t _mask_ = ((align)) - 1; _ptr_ = __builtin_alloca
 ((_size_) + _mask_); (void*)(((uintptr_t)_ptr_ + _mask_) &
 ~_mask_); });                  \
120                (void*)memset(_new_, 0, _size_);                        \
121        })
122 
123/* Takes inspiration from Rusts's Option::take() method: reads and returns a pointer, but at the same time resets it to
124 * NULL. See: https://doc.rust-lang.org/std/option/enum.Option.html#method.take */
125#define TAKE_PTR(ptr)({ typeof(ptr) _ptr_ = (ptr); (ptr) = ((void*)0); _ptr_; })                           \
126        ({                                      \
127                typeof(ptr) _ptr_ = (ptr);      \
128                (ptr) = NULL((void*)0);                   \
129                _ptr_;                          \
130        })