../src/basic/string-util.h

Bug Summary

File:	build-scan/../src/basic/string-util.h
Warning:	line 63, column 13 Null pointer passed to 1st parameter expecting 'nonnull'

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 fileio.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/fileio.c

../src/basic/fileio.c

→

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

3#include <errno(*__errno_location ()).h>
4#include <fcntl.h>
5#include <limits.h>
6#include <stdarg.h>
7#include <stdint.h>
8#include <stdio_ext.h>
9#include <stdlib.h>
10#include <string.h>
11#include <sys/mman.h>
12#include <sys/stat.h>
13#include <sys/types.h>
14#include <unistd.h>

16#include "alloc-util.h"
17#include "ctype.h"
18#include "def.h"
19#include "env-util.h"
20#include "escape.h"
21#include "fd-util.h"
22#include "fileio.h"
23#include "fs-util.h"
24#include "hexdecoct.h"
25#include "log.h"
26#include "macro.h"
27#include "missing.h"
28#include "parse-util.h"
29#include "path-util.h"
30#include "process-util.h"
31#include "random-util.h"
32#include "stdio-util.h"
33#include "string-util.h"
34#include "strv.h"
35#include "time-util.h"
36#include "umask-util.h"
37#include "utf8.h"

39#define READ_FULL_BYTES_MAX(4U*1024U*1024U) (4U*1024U*1024U)

41int write_string_stream_ts(
              FILE *f,
              const char *line,
              WriteStringFileFlags flags,
              struct timespec *ts) {

      bool_Bool needs_nl;
      int r;

      assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/basic/fileio.c", 50, __PRETTY_FUNCTION__
); } while (0);
      assert(line)do { if ((__builtin_expect(!!(!(line)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("line"), "../src/basic/fileio.c", 51, __PRETTY_FUNCTION__
); } while (0);

      if (ferror(f))
              return -EIO5;

      needs_nl = !(flags & WRITE_STRING_FILE_AVOID_NEWLINE) && !endswith(line, "\n");

      if (needs_nl && (flags & WRITE_STRING_FILE_DISABLE_BUFFER)) {
              /* If STDIO buffering was disabled, then let's append the newline character to the string itself, so
               * that the write goes out in one go, instead of two */

              line = strjoina(line, "\n")({ const char *_appendees_[] = { line, "\n" }; 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_; });
              needs_nl = false0;
      }

      if (fputs(line, f) == EOF(-1))
              return -errno(*__errno_location ());

      if (needs_nl)
              if (fputc('\n', f) == EOF(-1))
                      return -errno(*__errno_location ());

      if (flags & WRITE_STRING_FILE_SYNC)
              r = fflush_sync_and_check(f);
      else
              r = fflush_and_check(f);
      if (r < 0)
              return r;

      if (ts) {
              struct timespec twice[2] = {*ts, *ts};

              if (futimens(fileno(f), twice) < 0)
                      return -errno(*__errno_location ());
      }

      return 0;
88}

90static int write_string_file_atomic(
              const char *fn,
              const char *line,
              WriteStringFileFlags flags,
              struct timespec *ts) {

      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      int r;

      assert(fn)do { if ((__builtin_expect(!!(!(fn)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fn"), "../src/basic/fileio.c", 100, __PRETTY_FUNCTION__
); } while (0);
      assert(line)do { if ((__builtin_expect(!!(!(line)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("line"), "../src/basic/fileio.c", 101, __PRETTY_FUNCTION__
); } while (0);

      r = fopen_temporary(fn, &f, &p);
      if (r < 0)
              return r;

      (void) __fsetlocking(f, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);
      (void) fchmod_umask(fileno(f), 0644);

      r = write_string_stream_ts(f, line, flags, ts);
      if (r < 0)
              goto fail;

      if (rename(p, fn) < 0) {
              r = -errno(*__errno_location ());
              goto fail;
      }

      return 0;

121fail:
      (void) unlink(p);
      return r;
124}

126int write_string_file_ts(
              const char *fn,
              const char *line,
              WriteStringFileFlags flags,
              struct timespec *ts) {

      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      int q, r;

      assert(fn)do { if ((__builtin_expect(!!(!(fn)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fn"), "../src/basic/fileio.c", 135, __PRETTY_FUNCTION__
); } while (0);
      assert(line)do { if ((__builtin_expect(!!(!(line)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("line"), "../src/basic/fileio.c", 136, __PRETTY_FUNCTION__
); } while (0);

      /* We don't know how to verify whether the file contents was already on-disk. */
      assert(!((flags & WRITE_STRING_FILE_VERIFY_ON_FAILURE) && (flags & WRITE_STRING_FILE_SYNC)))do { if ((__builtin_expect(!!(!(!((flags & WRITE_STRING_FILE_VERIFY_ON_FAILURE
) && (flags & WRITE_STRING_FILE_SYNC)))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!((flags & WRITE_STRING_FILE_VERIFY_ON_FAILURE) && (flags & WRITE_STRING_FILE_SYNC))"
), "../src/basic/fileio.c", 139, __PRETTY_FUNCTION__); } while
 (0);

      if (flags & WRITE_STRING_FILE_ATOMIC) {
              assert(flags & WRITE_STRING_FILE_CREATE)do { if ((__builtin_expect(!!(!(flags & WRITE_STRING_FILE_CREATE
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("flags & WRITE_STRING_FILE_CREATE"
), "../src/basic/fileio.c", 142, __PRETTY_FUNCTION__); } while
 (0);

              r = write_string_file_atomic(fn, line, flags, ts);
              if (r < 0)
                      goto fail;

              return r;
      } else
              assert(!ts)do { if ((__builtin_expect(!!(!(!ts)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!ts"), "../src/basic/fileio.c", 150, __PRETTY_FUNCTION__
); } while (0);

      if (flags & WRITE_STRING_FILE_CREATE) {
              f = fopen(fn, "we");
              if (!f) {
                      r = -errno(*__errno_location ());
                      goto fail;
              }
      } else {
              int fd;

              /* We manually build our own version of fopen(..., "we") that
               * works without O_CREAT */
              fd = open(fn, O_WRONLY01|O_CLOEXEC02000000|O_NOCTTY0400);
              if (fd < 0) {
                      r = -errno(*__errno_location ());
                      goto fail;
              }

              f = fdopen(fd, "we");
              if (!f) {
                      r = -errno(*__errno_location ());
                      safe_close(fd);
                      goto fail;
              }
      }

      (void) __fsetlocking(f, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);

      if (flags & WRITE_STRING_FILE_DISABLE_BUFFER)
              setvbuf(f, NULL((void*)0), _IONBF2, 0);

      r = write_string_stream_ts(f, line, flags, ts);
      if (r < 0)
              goto fail;

      return 0;

188fail:
      if (!(flags & WRITE_STRING_FILE_VERIFY_ON_FAILURE))
              return r;

      f = safe_fclose(f);

      /* OK, the operation failed, but let's see if the right
       * contents in place already. If so, eat up the error. */

      q = verify_file(fn, line, !(flags & WRITE_STRING_FILE_AVOID_NEWLINE));
      if (q <= 0)
              return r;

      return 0;
202}

204int write_string_filef(
              const char *fn,
              WriteStringFileFlags flags,
              const char *format, ...) {

      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      va_list ap;
      int r;

      va_start(ap, format)__builtin_va_start(ap, format);
      r = vasprintf(&p, format, ap);
      va_end(ap)__builtin_va_end(ap);

      if (r < 0)
              return -ENOMEM12;

      return write_string_file(fn, p, flags);
221}

223int read_one_line_file(const char *fn, char **line) {
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      int r;

      assert(fn)do { if ((__builtin_expect(!!(!(fn)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fn"), "../src/basic/fileio.c", 227, __PRETTY_FUNCTION__
); } while (0);
6
←
Taking false branch→
7
←
Loop condition is false.  Exiting loop→
      assert(line)do { if ((__builtin_expect(!!(!(line)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("line"), "../src/basic/fileio.c", 228, __PRETTY_FUNCTION__
); } while (0);
8
←
Taking false branch→
9
←
Loop condition is false.  Exiting loop→

      f = fopen(fn, "re");
      if (!f)
10
←
Assuming 'f' is null→
11
←
Taking true branch→
              return -errno(*__errno_location ());
12
←
Returning without writing to '*line'→

      (void) __fsetlocking(f, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);

      r = read_line(f, LONG_LINE_MAX(1U*1024U*1024U), line);
      return r < 0 ? r : 0;
238}

240int verify_file(const char *fn, const char *blob, bool_Bool accept_extra_nl) {
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);
      size_t l, k;

      assert(fn)do { if ((__builtin_expect(!!(!(fn)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fn"), "../src/basic/fileio.c", 245, __PRETTY_FUNCTION__
); } while (0);
      assert(blob)do { if ((__builtin_expect(!!(!(blob)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("blob"), "../src/basic/fileio.c", 246, __PRETTY_FUNCTION__
); } while (0);

      l = strlen(blob);

      if (accept_extra_nl && endswith(blob, "\n"))
              accept_extra_nl = false0;

      buf = malloc(l + accept_extra_nl + 1);
      if (!buf)
              return -ENOMEM12;

      f = fopen(fn, "re");
      if (!f)
              return -errno(*__errno_location ());

      (void) __fsetlocking(f, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);

      /* We try to read one byte more than we need, so that we know whether we hit eof */
      errno(*__errno_location ()) = 0;
      k = fread(buf, 1, l + accept_extra_nl + 1, f);
      if (ferror(f))
              return errno(*__errno_location ()) > 0 ? -errno(*__errno_location ()) : -EIO5;

      if (k != l && k != l + accept_extra_nl)
              return 0;
      if (memcmp(buf, blob, l) != 0)
              return 0;
      if (k > l && buf[l] != '\n')
              return 0;

      return 1;
277}

279int read_full_stream(FILE *f, char **contents, size_t *size) {
      _cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);
      struct stat st;
      size_t n, l;
      int fd;

      assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/basic/fileio.c", 285, __PRETTY_FUNCTION__
); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/basic/fileio.c", 286
, __PRETTY_FUNCTION__); } while (0);

      n = LINE_MAX2048;

      fd = fileno(f);
      if (fd >= 0) { /* If the FILE* object is backed by an fd (as opposed to memory or such, see fmemopen(), let's
                      * optimize our buffering) */

              if (fstat(fileno(f), &st) < 0)
                      return -errno(*__errno_location ());

              if (S_ISREG(st.st_mode)((((st.st_mode)) & 0170000) == (0100000))) {

                      /* Safety check */
                      if (st.st_size > READ_FULL_BYTES_MAX(4U*1024U*1024U))
                              return -E2BIG7;

                      /* Start with the right file size, but be prepared for files from /proc which generally report a file
                       * size of 0. Note that we increase the size to read here by one, so that the first read attempt
                       * already makes us notice the EOF. */
                      if (st.st_size > 0)
                              n = st.st_size + 1;
              }
      }

      l = 0;
      for (;;) {
              char *t;
              size_t k;

              t = realloc(buf, n + 1);
              if (!t)
                      return -ENOMEM12;

              buf = t;
              errno(*__errno_location ()) = 0;
              k = fread(buf + l, 1, n - l, f);
              if (k > 0)
                      l += k;

              if (ferror(f))
                      return errno(*__errno_location ()) > 0 ? -errno(*__errno_location ()) : -EIO5;

              if (feof(f))
                      break;

              /* We aren't expecting fread() to return a short read outside
               * of (error && eof), assert buffer is full and enlarge buffer.
               */
              assert(l == n)do { if ((__builtin_expect(!!(!(l == n)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("l == n"), "../src/basic/fileio.c", 335,
 __PRETTY_FUNCTION__); } while (0);

              /* Safety check */
              if (n >= READ_FULL_BYTES_MAX(4U*1024U*1024U))
                      return -E2BIG7;

              n = MIN(n * 2, READ_FULL_BYTES_MAX)__extension__ ({ const typeof((n * 2)) __unique_prefix_A11 = (
(n * 2)); const typeof(((4U*1024U*1024U))) __unique_prefix_B12
 = (((4U*1024U*1024U))); __unique_prefix_A11 < __unique_prefix_B12
 ? __unique_prefix_A11 : __unique_prefix_B12; });
      }

      buf[l] = 0;
      *contents = TAKE_PTR(buf)({ typeof(buf) _ptr_ = (buf); (buf) = ((void*)0); _ptr_; });

      if (size)
              *size = l;

      return 0;
351}

353int read_full_file(const char *fn, char **contents, size_t *size) {
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);

      assert(fn)do { if ((__builtin_expect(!!(!(fn)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fn"), "../src/basic/fileio.c", 356, __PRETTY_FUNCTION__
); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/basic/fileio.c", 357
, __PRETTY_FUNCTION__); } while (0);

      f = fopen(fn, "re");
      if (!f)
              return -errno(*__errno_location ());

      (void) __fsetlocking(f, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);

      return read_full_stream(f, contents, size);
366}

368static int parse_env_file_internal(
              FILE *f,
              const char *fname,
              const char *newline,
              int (*push) (const char *filename, unsigned line,
                           const char *key, char *value, void *userdata, int *n_pushed),
              void *userdata,
              int *n_pushed) {

      size_t key_alloc = 0, n_key = 0, value_alloc = 0, n_value = 0, last_value_whitespace = (size_t) -1, last_key_whitespace = (size_t) -1;
      _cleanup_free___attribute__((cleanup(freep))) char *contents = NULL((void*)0), *key = NULL((void*)0), *value = NULL((void*)0);
      unsigned line = 1;
      char *p;
      int r;

      enum {
              PRE_KEY,
              KEY,
              PRE_VALUE,
              VALUE,
              VALUE_ESCAPE,
              SINGLE_QUOTE_VALUE,
              SINGLE_QUOTE_VALUE_ESCAPE,
              DOUBLE_QUOTE_VALUE,
              DOUBLE_QUOTE_VALUE_ESCAPE,
              COMMENT,
              COMMENT_ESCAPE
      } state = PRE_KEY;

      assert(newline)do { if ((__builtin_expect(!!(!(newline)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("newline"), "../src/basic/fileio.c", 397
, __PRETTY_FUNCTION__); } while (0);

      if (f)
              r = read_full_stream(f, &contents, NULL((void*)0));
      else
              r = read_full_file(fname, &contents, NULL((void*)0));
      if (r < 0)
              return r;

      for (p = contents; *p; p++) {
              char c = *p;

              switch (state) {

              case PRE_KEY:
                      if (strchr(COMMENTS"#;", c))
                              state = COMMENT;
                      else if (!strchr(WHITESPACE" \t\n\r", c)) {
                              state = KEY;
                              last_key_whitespace = (size_t) -1;

                              if (!GREEDY_REALLOC(key, key_alloc, n_key+2)greedy_realloc((void**) &(key), &(key_alloc), (n_key+
2), sizeof((key)[0])))
                                      return -ENOMEM12;

                              key[n_key++] = c;
                      }
                      break;

              case KEY:
                      if (strchr(newline, c)) {
                              state = PRE_KEY;
                              line++;
                              n_key = 0;
                      } else if (c == '=') {
                              state = PRE_VALUE;
                              last_value_whitespace = (size_t) -1;
                      } else {
                              if (!strchr(WHITESPACE" \t\n\r", c))
                                      last_key_whitespace = (size_t) -1;
                              else if (last_key_whitespace == (size_t) -1)
                                       last_key_whitespace = n_key;

                              if (!GREEDY_REALLOC(key, key_alloc, n_key+2)greedy_realloc((void**) &(key), &(key_alloc), (n_key+
2), sizeof((key)[0])))
                                      return -ENOMEM12;

                              key[n_key++] = c;
                      }

                      break;

              case PRE_VALUE:
                      if (strchr(newline, c)) {
                              state = PRE_KEY;
                              line++;
                              key[n_key] = 0;

                              if (value)
                                      value[n_value] = 0;

                              /* strip trailing whitespace from key */
                              if (last_key_whitespace != (size_t) -1)
                                      key[last_key_whitespace] = 0;

                              r = push(fname, line, key, value, userdata, n_pushed);
                              if (r < 0)
                                      return r;

                              n_key = 0;
                              value = NULL((void*)0);
                              value_alloc = n_value = 0;

                      } else if (c == '\'')
                              state = SINGLE_QUOTE_VALUE;
                      else if (c == '\"')
                              state = DOUBLE_QUOTE_VALUE;
                      else if (c == '\\')
                              state = VALUE_ESCAPE;
                      else if (!strchr(WHITESPACE" \t\n\r", c)) {
                              state = VALUE;

                              if (!GREEDY_REALLOC(value, value_alloc, n_value+2)greedy_realloc((void**) &(value), &(value_alloc), (n_value
+2), sizeof((value)[0])))
                                      return  -ENOMEM12;

                              value[n_value++] = c;
                      }

                      break;

              case VALUE:
                      if (strchr(newline, c)) {
                              state = PRE_KEY;
                              line++;

                              key[n_key] = 0;

                              if (value)
                                      value[n_value] = 0;

                              /* Chomp off trailing whitespace from value */
                              if (last_value_whitespace != (size_t) -1)
                                      value[last_value_whitespace] = 0;

                              /* strip trailing whitespace from key */
                              if (last_key_whitespace != (size_t) -1)
                                      key[last_key_whitespace] = 0;

                              r = push(fname, line, key, value, userdata, n_pushed);
                              if (r < 0)
                                      return r;

                              n_key = 0;
                              value = NULL((void*)0);
                              value_alloc = n_value = 0;

                      } else if (c == '\\') {
                              state = VALUE_ESCAPE;
                              last_value_whitespace = (size_t) -1;
                      } else {
                              if (!strchr(WHITESPACE" \t\n\r", c))
                                      last_value_whitespace = (size_t) -1;
                              else if (last_value_whitespace == (size_t) -1)
                                      last_value_whitespace = n_value;

                              if (!GREEDY_REALLOC(value, value_alloc, n_value+2)greedy_realloc((void**) &(value), &(value_alloc), (n_value
+2), sizeof((value)[0])))
                                      return -ENOMEM12;

                              value[n_value++] = c;
                      }

                      break;

              case VALUE_ESCAPE:
                      state = VALUE;

                      if (!strchr(newline, c)) {
                              /* Escaped newlines we eat up entirely */
                              if (!GREEDY_REALLOC(value, value_alloc, n_value+2)greedy_realloc((void**) &(value), &(value_alloc), (n_value
+2), sizeof((value)[0])))
                                      return -ENOMEM12;

                              value[n_value++] = c;
                      }
                      break;

              case SINGLE_QUOTE_VALUE:
                      if (c == '\'')
                              state = PRE_VALUE;
                      else if (c == '\\')
                              state = SINGLE_QUOTE_VALUE_ESCAPE;
                      else {
                              if (!GREEDY_REALLOC(value, value_alloc, n_value+2)greedy_realloc((void**) &(value), &(value_alloc), (n_value
+2), sizeof((value)[0])))
                                      return -ENOMEM12;

                              value[n_value++] = c;
                      }

                      break;

              case SINGLE_QUOTE_VALUE_ESCAPE:
                      state = SINGLE_QUOTE_VALUE;

                      if (!strchr(newline, c)) {
                              if (!GREEDY_REALLOC(value, value_alloc, n_value+2)greedy_realloc((void**) &(value), &(value_alloc), (n_value
+2), sizeof((value)[0])))
                                      return -ENOMEM12;

                              value[n_value++] = c;
                      }
                      break;

              case DOUBLE_QUOTE_VALUE:
                      if (c == '\"')
                              state = PRE_VALUE;
                      else if (c == '\\')
                              state = DOUBLE_QUOTE_VALUE_ESCAPE;
                      else {
                              if (!GREEDY_REALLOC(value, value_alloc, n_value+2)greedy_realloc((void**) &(value), &(value_alloc), (n_value
+2), sizeof((value)[0])))
                                      return -ENOMEM12;

                              value[n_value++] = c;
                      }

                      break;

              case DOUBLE_QUOTE_VALUE_ESCAPE:
                      state = DOUBLE_QUOTE_VALUE;

                      if (!strchr(newline, c)) {
                              if (!GREEDY_REALLOC(value, value_alloc, n_value+2)greedy_realloc((void**) &(value), &(value_alloc), (n_value
+2), sizeof((value)[0])))
                                      return -ENOMEM12;

                              value[n_value++] = c;
                      }
                      break;

              case COMMENT:
                      if (c == '\\')
                              state = COMMENT_ESCAPE;
                      else if (strchr(newline, c)) {
                              state = PRE_KEY;
                              line++;
                      }
                      break;

              case COMMENT_ESCAPE:
                      state = COMMENT;
                      break;
              }
      }

      if (IN_SET(state,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){PRE_VALUE, VALUE, VALUE_ESCAPE, SINGLE_QUOTE_VALUE
, SINGLE_QUOTE_VALUE_ESCAPE, DOUBLE_QUOTE_VALUE, DOUBLE_QUOTE_VALUE_ESCAPE
})/sizeof(int)]; switch(state) { case PRE_VALUE: case VALUE: case
 VALUE_ESCAPE: case SINGLE_QUOTE_VALUE: case SINGLE_QUOTE_VALUE_ESCAPE
: case DOUBLE_QUOTE_VALUE: case DOUBLE_QUOTE_VALUE_ESCAPE: _found
 = 1; break; default: break; } _found; })
                 PRE_VALUE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){PRE_VALUE, VALUE, VALUE_ESCAPE, SINGLE_QUOTE_VALUE
, SINGLE_QUOTE_VALUE_ESCAPE, DOUBLE_QUOTE_VALUE, DOUBLE_QUOTE_VALUE_ESCAPE
})/sizeof(int)]; switch(state) { case PRE_VALUE: case VALUE: case
 VALUE_ESCAPE: case SINGLE_QUOTE_VALUE: case SINGLE_QUOTE_VALUE_ESCAPE
: case DOUBLE_QUOTE_VALUE: case DOUBLE_QUOTE_VALUE_ESCAPE: _found
 = 1; break; default: break; } _found; })
                 VALUE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){PRE_VALUE, VALUE, VALUE_ESCAPE, SINGLE_QUOTE_VALUE
, SINGLE_QUOTE_VALUE_ESCAPE, DOUBLE_QUOTE_VALUE, DOUBLE_QUOTE_VALUE_ESCAPE
})/sizeof(int)]; switch(state) { case PRE_VALUE: case VALUE: case
 VALUE_ESCAPE: case SINGLE_QUOTE_VALUE: case SINGLE_QUOTE_VALUE_ESCAPE
: case DOUBLE_QUOTE_VALUE: case DOUBLE_QUOTE_VALUE_ESCAPE: _found
 = 1; break; default: break; } _found; })
                 VALUE_ESCAPE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){PRE_VALUE, VALUE, VALUE_ESCAPE, SINGLE_QUOTE_VALUE
, SINGLE_QUOTE_VALUE_ESCAPE, DOUBLE_QUOTE_VALUE, DOUBLE_QUOTE_VALUE_ESCAPE
})/sizeof(int)]; switch(state) { case PRE_VALUE: case VALUE: case
 VALUE_ESCAPE: case SINGLE_QUOTE_VALUE: case SINGLE_QUOTE_VALUE_ESCAPE
: case DOUBLE_QUOTE_VALUE: case DOUBLE_QUOTE_VALUE_ESCAPE: _found
 = 1; break; default: break; } _found; })
                 SINGLE_QUOTE_VALUE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){PRE_VALUE, VALUE, VALUE_ESCAPE, SINGLE_QUOTE_VALUE
, SINGLE_QUOTE_VALUE_ESCAPE, DOUBLE_QUOTE_VALUE, DOUBLE_QUOTE_VALUE_ESCAPE
})/sizeof(int)]; switch(state) { case PRE_VALUE: case VALUE: case
 VALUE_ESCAPE: case SINGLE_QUOTE_VALUE: case SINGLE_QUOTE_VALUE_ESCAPE
: case DOUBLE_QUOTE_VALUE: case DOUBLE_QUOTE_VALUE_ESCAPE: _found
 = 1; break; default: break; } _found; })
                 SINGLE_QUOTE_VALUE_ESCAPE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){PRE_VALUE, VALUE, VALUE_ESCAPE, SINGLE_QUOTE_VALUE
, SINGLE_QUOTE_VALUE_ESCAPE, DOUBLE_QUOTE_VALUE, DOUBLE_QUOTE_VALUE_ESCAPE
})/sizeof(int)]; switch(state) { case PRE_VALUE: case VALUE: case
 VALUE_ESCAPE: case SINGLE_QUOTE_VALUE: case SINGLE_QUOTE_VALUE_ESCAPE
: case DOUBLE_QUOTE_VALUE: case DOUBLE_QUOTE_VALUE_ESCAPE: _found
 = 1; break; default: break; } _found; })
                 DOUBLE_QUOTE_VALUE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){PRE_VALUE, VALUE, VALUE_ESCAPE, SINGLE_QUOTE_VALUE
, SINGLE_QUOTE_VALUE_ESCAPE, DOUBLE_QUOTE_VALUE, DOUBLE_QUOTE_VALUE_ESCAPE
})/sizeof(int)]; switch(state) { case PRE_VALUE: case VALUE: case
 VALUE_ESCAPE: case SINGLE_QUOTE_VALUE: case SINGLE_QUOTE_VALUE_ESCAPE
: case DOUBLE_QUOTE_VALUE: case DOUBLE_QUOTE_VALUE_ESCAPE: _found
 = 1; break; default: break; } _found; })
                 DOUBLE_QUOTE_VALUE_ESCAPE)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){PRE_VALUE, VALUE, VALUE_ESCAPE, SINGLE_QUOTE_VALUE
, SINGLE_QUOTE_VALUE_ESCAPE, DOUBLE_QUOTE_VALUE, DOUBLE_QUOTE_VALUE_ESCAPE
})/sizeof(int)]; switch(state) { case PRE_VALUE: case VALUE: case
 VALUE_ESCAPE: case SINGLE_QUOTE_VALUE: case SINGLE_QUOTE_VALUE_ESCAPE
: case DOUBLE_QUOTE_VALUE: case DOUBLE_QUOTE_VALUE_ESCAPE: _found
 = 1; break; default: break; } _found; })) {

              key[n_key] = 0;

              if (value)
                      value[n_value] = 0;

              if (state == VALUE)
                      if (last_value_whitespace != (size_t) -1)
                              value[last_value_whitespace] = 0;

              /* strip trailing whitespace from key */
              if (last_key_whitespace != (size_t) -1)
                      key[last_key_whitespace] = 0;

              r = push(fname, line, key, value, userdata, n_pushed);
              if (r < 0)
                      return r;

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

      return 0;
635}

637static int check_utf8ness_and_warn(
              const char *filename, unsigned line,
              const char *key, char *value) {

      if (!utf8_is_valid(key)) {
              _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

              p = utf8_escape_invalid(key);
              log_error("%s:%u: invalid UTF-8 in key '%s', ignoring.", strna(filename), line, p)({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/fileio.c", 645, __func__, "%s:%u: invalid UTF-8 in key '%s', ignoring."
, strna(filename), line, p) : -abs(_e); });
              return -EINVAL22;
      }

      if (value && !utf8_is_valid(value)) {
              _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

              p = utf8_escape_invalid(value);
              log_error("%s:%u: invalid UTF-8 value for key %s: '%s', ignoring.", strna(filename), line, key, p)({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/fileio.c", 653, __func__, "%s:%u: invalid UTF-8 value for key %s: '%s', ignoring."
, strna(filename), line, key, p) : -abs(_e); });
              return -EINVAL22;
      }

      return 0;
658}

660static int parse_env_file_push(
              const char *filename, unsigned line,
              const char *key, char *value,
              void *userdata,
              int *n_pushed) {

      const char *k;
      va_list aq, *ap = userdata;
      int r;

      r = check_utf8ness_and_warn(filename, line, key, value);
      if (r < 0)
              return r;

      va_copy(aq, *ap)__builtin_va_copy(aq, *ap);

      while ((k = va_arg(aq, const char *)__builtin_va_arg(aq, const char *))) {
              char **v;

              v = va_arg(aq, char **)__builtin_va_arg(aq, char **);

              if (streq(key, k)(strcmp((key),(k)) == 0)) {
                      va_end(aq)__builtin_va_end(aq);
                      free(*v);
                      *v = value;

                      if (n_pushed)
                              (*n_pushed)++;

                      return 1;
              }
      }

      va_end(aq)__builtin_va_end(aq);
      free(value);

      return 0;
697}

699int parse_env_filev(
              FILE *f,
              const char *fname,
              const char *newline,
              va_list ap) {

      int r, n_pushed = 0;
      va_list aq;

      if (!newline)
              newline = NEWLINE"\n\r";

      va_copy(aq, ap)__builtin_va_copy(aq, ap);
      r = parse_env_file_internal(f, fname, newline, parse_env_file_push, &aq, &n_pushed);
      va_end(aq)__builtin_va_end(aq);
      if (r < 0)
              return r;

      return n_pushed;
718}

720int parse_env_file(
              FILE *f,
              const char *fname,
              const char *newline,
              ...) {

      va_list ap;
      int r;

      va_start(ap, newline)__builtin_va_start(ap, newline);
      r = parse_env_filev(f, fname, newline, ap);
      va_end(ap)__builtin_va_end(ap);

      return r;
734}

736static int load_env_file_push(
              const char *filename, unsigned line,
              const char *key, char *value,
              void *userdata,
              int *n_pushed) {
      char ***m = userdata;
      char *p;
      int r;

      r = check_utf8ness_and_warn(filename, line, key, value);
      if (r < 0)
              return r;

      p = strjoin(key, "=", value)strjoin_real((key), "=", value, ((void*)0));
      if (!p)
              return -ENOMEM12;

      r = strv_env_replace(m, p);
      if (r < 0) {
              free(p);
              return r;
      }

      if (n_pushed)
              (*n_pushed)++;

      free(value);
      return 0;
764}

766int load_env_file(FILE *f, const char *fname, const char *newline, char ***rl) {
      char **m = NULL((void*)0);
      int r;

      if (!newline)
              newline = NEWLINE"\n\r";

      r = parse_env_file_internal(f, fname, newline, load_env_file_push, &m, NULL((void*)0));
      if (r < 0) {
              strv_free(m);
              return r;
      }

      *rl = m;
      return 0;
781}

783static int load_env_file_push_pairs(
              const char *filename, unsigned line,
              const char *key, char *value,
              void *userdata,
              int *n_pushed) {
      char ***m = userdata;
      int r;

      r = check_utf8ness_and_warn(filename, line, key, value);
      if (r < 0)
              return r;

      r = strv_extend(m, key);
      if (r < 0)
              return -ENOMEM12;

      if (!value) {
              r = strv_extend(m, "");
              if (r < 0)
                      return -ENOMEM12;
      } else {
              r = strv_push(m, value);
              if (r < 0)
                      return r;
      }

      if (n_pushed)
              (*n_pushed)++;

      return 0;
813}

815int load_env_file_pairs(FILE *f, const char *fname, const char *newline, char ***rl) {
      char **m = NULL((void*)0);
      int r;

      if (!newline)
              newline = NEWLINE"\n\r";

      r = parse_env_file_internal(f, fname, newline, load_env_file_push_pairs, &m, NULL((void*)0));
      if (r < 0) {
              strv_free(m);
              return r;
      }

      *rl = m;
      return 0;
830}

832static int merge_env_file_push(
              const char *filename, unsigned line,
              const char *key, char *value,
              void *userdata,
              int *n_pushed) {

      char ***env = userdata;
      char *expanded_value;

      assert(env)do { if ((__builtin_expect(!!(!(env)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("env"), "../src/basic/fileio.c", 841, __PRETTY_FUNCTION__
); } while (0);

      if (!value) {
              log_error("%s:%u: invalid syntax (around \"%s\"), ignoring.", strna(filename), line, key)({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/fileio.c", 844, __func__, "%s:%u: invalid syntax (around \"%s\"), ignoring."
, strna(filename), line, key) : -abs(_e); });
              return 0;
      }

      if (!env_name_is_valid(key)) {
              log_error("%s:%u: invalid variable name \"%s\", ignoring.", strna(filename), line, key)({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/fileio.c", 849, __func__, "%s:%u: invalid variable name \"%s\", ignoring."
, strna(filename), line, key) : -abs(_e); });
              free(value);
              return 0;
      }

      expanded_value = replace_env(value, *env,
                                   REPLACE_ENV_USE_ENVIRONMENT|
                                   REPLACE_ENV_ALLOW_BRACELESS|
                                   REPLACE_ENV_ALLOW_EXTENDED);
      if (!expanded_value)
              return -ENOMEM12;

      free_and_replace(value, expanded_value)({ free(value); (value) = (expanded_value); (expanded_value) =
 ((void*)0); 0; });

      return load_env_file_push(filename, line, key, value, env, n_pushed);
864}

866int merge_env_file(
              char ***env,
              FILE *f,
              const char *fname) {

      /* NOTE: this function supports braceful and braceless variable expansions,
       * plus "extended" substitutions, unlike other exported parsing functions.
       */

      return parse_env_file_internal(f, fname, NEWLINE"\n\r", merge_env_file_push, env, NULL((void*)0));
876}

878static void write_env_var(FILE *f, const char *v) {
      const char *p;

      p = strchr(v, '=');
      if (!p) {
              /* Fallback */
              fputs_unlocked(v, f);
              fputc_unlocked('\n', f);
              return;
      }

      p++;
      fwrite_unlocked(v, 1, p-v, f);

      if (string_has_cc(p, NULL((void*)0)) || chars_intersect(p, WHITESPACE" \t\n\r" SHELL_NEED_QUOTES"\"\\`$" "*?[" "'()<>|&;!")) {
              fputc_unlocked('\"', f);

              for (; *p; p++) {
                      if (strchr(SHELL_NEED_ESCAPE"\"\\`$", *p))
                              fputc_unlocked('\\', f);

                      fputc_unlocked(*p, f);
              }

              fputc_unlocked('\"', f);
      } else
              fputs_unlocked(p, f);

      fputc_unlocked('\n', f);
907}

909int write_env_file(const char *fname, char **l) {
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      char **i;
      int r;

      assert(fname)do { if ((__builtin_expect(!!(!(fname)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fname"), "../src/basic/fileio.c", 915, __PRETTY_FUNCTION__
); } while (0);

      r = fopen_temporary(fname, &f, &p);
      if (r < 0)
              return r;

      (void) __fsetlocking(f, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);
      (void) fchmod_umask(fileno(f), 0644);

      STRV_FOREACH(i, l)for ((i) = (l); (i) && *(i); (i)++)
              write_env_var(f, *i);

      r = fflush_and_check(f);
      if (r >= 0) {
              if (rename(p, fname) >= 0)
                      return 0;

              r = -errno(*__errno_location ());
      }

      unlink(p);
      return r;
937}

939int executable_is_script(const char *path, char **interpreter) {
      _cleanup_free___attribute__((cleanup(freep))) char *line = NULL((void*)0);
1
'line' initialized to a null pointer value→
      size_t len;
      char *ans;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/fileio.c", 945, __PRETTY_FUNCTION__
); } while (0);
2
←
Assuming 'path' is non-null→
3
←
Taking false branch→
4
←
Loop condition is false.  Exiting loop→

      r = read_one_line_file(path, &line);
5
←
Calling 'read_one_line_file'→
13
←
Returning from 'read_one_line_file'→
      if (r == -ENOBUFS105) /* First line overly long? if so, then it's not a script */
14
←
Assuming the condition is false→
15
←
Taking false branch→
              return 0;
      if (r < 0)
16
←
Assuming 'r' is >= 0→
17
←
Taking false branch→
              return r;

      if (!startswith(line, "#!"))
18
←
Passing null pointer value via 1st parameter 's'→
19
←
Calling 'startswith'→
              return 0;

      ans = strstrip(line + 2);
      len = strcspn(ans, " \t");

      if (len == 0)
              return 0;

      ans = strndup(ans, len);
      if (!ans)
              return -ENOMEM12;

      *interpreter = ans;
      return 1;
968}

970/**
* Retrieve one field from a file like /proc/self/status.  pattern
* should not include whitespace or the delimiter (':'). pattern matches only
* the beginning of a line. Whitespace before ':' is skipped. Whitespace and
* zeros after the ':' will be skipped. field must be freed afterwards.
* terminator specifies the terminating characters of the field value (not
* included in the value).
*/
978int get_proc_field(const char *filename, const char *pattern, const char *terminator, char **field) {
      _cleanup_free___attribute__((cleanup(freep))) char *status = NULL((void*)0);
      char *t, *f;
      size_t len;
      int r;

      assert(terminator)do { if ((__builtin_expect(!!(!(terminator)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("terminator"), "../src/basic/fileio.c", 984
, __PRETTY_FUNCTION__); } while (0);
      assert(filename)do { if ((__builtin_expect(!!(!(filename)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("filename"), "../src/basic/fileio.c", 985
, __PRETTY_FUNCTION__); } while (0);
      assert(pattern)do { if ((__builtin_expect(!!(!(pattern)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pattern"), "../src/basic/fileio.c", 986
, __PRETTY_FUNCTION__); } while (0);
      assert(field)do { if ((__builtin_expect(!!(!(field)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("field"), "../src/basic/fileio.c", 987, __PRETTY_FUNCTION__
); } while (0);

      r = read_full_file(filename, &status, NULL((void*)0));
      if (r < 0)
              return r;

      t = status;

      do {
              bool_Bool pattern_ok;

              do {
                      t = strstr(t, pattern);
                      if (!t)
                              return -ENOENT2;

                      /* Check that pattern occurs in beginning of line. */
                      pattern_ok = (t == status || t[-1] == '\n');

                      t += strlen(pattern);

              } while (!pattern_ok);

              t += strspn(t, " \t");
              if (!*t)
                      return -ENOENT2;

      } while (*t != ':');

      t++;

      if (*t) {
              t += strspn(t, " \t");

              /* Also skip zeros, because when this is used for
               * capabilities, we don't want the zeros. This way the
               * same capability set always maps to the same string,
               * irrespective of the total capability set size. For
               * other numbers it shouldn't matter. */
              t += strspn(t, "0");
              /* Back off one char if there's nothing but whitespace
                 and zeros */
              if (!*t || isspace(*t)((*__ctype_b_loc ())[(int) ((*t))] & (unsigned short int)
 _ISspace))
                      t--;
      }

      len = strcspn(t, terminator);

      f = strndup(t, len);
      if (!f)
              return -ENOMEM12;

      *field = f;
      return 0;
1041}

1043DIR *xopendirat(int fd, const char *name, int flags) {
      int nfd;
      DIR *d;

      assert(!(flags & O_CREAT))do { if ((__builtin_expect(!!(!(!(flags & 0100))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!(flags & O_CREAT)"), "../src/basic/fileio.c"
, 1047, __PRETTY_FUNCTION__); } while (0);

      nfd = openat(fd, name, O_RDONLY00|O_NONBLOCK04000|O_DIRECTORY0200000|O_CLOEXEC02000000|flags, 0);
      if (nfd < 0)
              return NULL((void*)0);

      d = fdopendir(nfd);
      if (!d) {
              safe_close(nfd);
              return NULL((void*)0);
      }

      return d;
1060}

1062static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
      char **i;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/fileio.c", 1065, __PRETTY_FUNCTION__
); } while (0);
      assert(mode)do { if ((__builtin_expect(!!(!(mode)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("mode"), "../src/basic/fileio.c", 1066, __PRETTY_FUNCTION__
); } while (0);
      assert(_f)do { if ((__builtin_expect(!!(!(_f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_f"), "../src/basic/fileio.c", 1067, __PRETTY_FUNCTION__
); } while (0);

      if (!path_strv_resolve_uniq(search, root))
              return -ENOMEM12;

      STRV_FOREACH(i, search)for ((i) = (search); (i) && *(i); (i)++) {
              _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
              FILE *f;

              if (root)
                      p = strjoin(root, *i, "/", path)strjoin_real((root), *i, "/", path, ((void*)0));
              else
                      p = strjoin(*i, "/", path)strjoin_real((*i), "/", path, ((void*)0));
              if (!p)
                      return -ENOMEM12;

              f = fopen(p, mode);
              if (f) {
                      *_f = f;
                      return 0;
              }

              if (errno(*__errno_location ()) != ENOENT2)
                      return -errno(*__errno_location ());
      }

      return -ENOENT2;
1094}

1096int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
      _cleanup_strv_free___attribute__((cleanup(strv_freep))) char **copy = NULL((void*)0);

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/fileio.c", 1099, __PRETTY_FUNCTION__
); } while (0);
      assert(mode)do { if ((__builtin_expect(!!(!(mode)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("mode"), "../src/basic/fileio.c", 1100, __PRETTY_FUNCTION__
); } while (0);
      assert(_f)do { if ((__builtin_expect(!!(!(_f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_f"), "../src/basic/fileio.c", 1101, __PRETTY_FUNCTION__
); } while (0);

      if (path_is_absolute(path)) {
              FILE *f;

              f = fopen(path, mode);
              if (f) {
                      *_f = f;
                      return 0;
              }

              return -errno(*__errno_location ());
      }

      copy = strv_copy((char**) search);
      if (!copy)
              return -ENOMEM12;

      return search_and_fopen_internal(path, mode, root, copy, _f);
1120}

1122int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
      _cleanup_strv_free___attribute__((cleanup(strv_freep))) char **s = NULL((void*)0);

      if (path_is_absolute(path)) {
              FILE *f;

              f = fopen(path, mode);
              if (f) {
                      *_f = f;
                      return 0;
              }

              return -errno(*__errno_location ());
      }

      s = strv_split_nulstr(search);
      if (!s)
              return -ENOMEM12;

      return search_and_fopen_internal(path, mode, root, s, _f);
1142}

1144int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
      FILE *f;
      char *t;
      int r, fd;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/fileio.c", 1149, __PRETTY_FUNCTION__
); } while (0);
      assert(_f)do { if ((__builtin_expect(!!(!(_f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_f"), "../src/basic/fileio.c", 1150, __PRETTY_FUNCTION__
); } while (0);
      assert(_temp_path)do { if ((__builtin_expect(!!(!(_temp_path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_temp_path"), "../src/basic/fileio.c", 1151
, __PRETTY_FUNCTION__); } while (0);

      r = tempfn_xxxxxx(path, NULL((void*)0), &t);
      if (r < 0)
              return r;

      fd = mkostemp_safe(t);
      if (fd < 0) {
              free(t);
              return -errno(*__errno_location ());
      }

      f = fdopen(fd, "we");
      if (!f) {
              unlink_noerrno(t);
              free(t);
              safe_close(fd);
              return -errno(*__errno_location ());
      }

      *_f = f;
      *_temp_path = t;

      return 0;
1175}

1177int fflush_and_check(FILE *f) {
      assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/basic/fileio.c", 1178, __PRETTY_FUNCTION__
); } while (0);

      errno(*__errno_location ()) = 0;
      fflush(f);

      if (ferror(f))
              return errno(*__errno_location ()) > 0 ? -errno(*__errno_location ()) : -EIO5;

      return 0;
1187}

1189int fflush_sync_and_check(FILE *f) {
      int r;

      assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/basic/fileio.c", 1192, __PRETTY_FUNCTION__
); } while (0);

      r = fflush_and_check(f);
      if (r < 0)
              return r;

      if (fsync(fileno(f)) < 0)
              return -errno(*__errno_location ());

      r = fsync_directory_of_file(fileno(f));
      if (r < 0)
              return r;

      return 0;
1206}

1208/* This is much like mkostemp() but is subject to umask(). */
1209int mkostemp_safe(char *pattern) {
      _cleanup_umask___attribute__((cleanup(umaskp))) mode_t u = 0;
      int fd;

      assert(pattern)do { if ((__builtin_expect(!!(!(pattern)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pattern"), "../src/basic/fileio.c", 1213
, __PRETTY_FUNCTION__); } while (0);

      u = umask(077);

      fd = mkostemp(pattern, O_CLOEXEC02000000);
      if (fd < 0)
              return -errno(*__errno_location ());

      return fd;
1222}

1224int tempfn_xxxxxx(const char *p, const char *extra, char **ret) {
      const char *fn;
      char *t;

      assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("p"), "../src/basic/fileio.c", 1228, __PRETTY_FUNCTION__
); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/fileio.c", 1229, __PRETTY_FUNCTION__
); } while (0);

      /*
       * Turns this:
       *         /foo/bar/waldo
       *
       * Into this:
       *         /foo/bar/.#<extra>waldoXXXXXX
       */

      fn = basename(p);
      if (!filename_is_valid(fn))
              return -EINVAL22;

      extra = strempty(extra);

      t = new(char, strlen(p) + 2 + strlen(extra) + 6 + 1)((char*) malloc_multiply(sizeof(char), (strlen(p) + 2 + strlen
(extra) + 6 + 1)));
      if (!t)
              return -ENOMEM12;

      strcpy(stpcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), extra), fn), "XXXXXX");

      *ret = path_simplify(t, false0);
      return 0;
1253}

1255int tempfn_random(const char *p, const char *extra, char **ret) {
      const char *fn;
      char *t, *x;
      uint64_t u;
      unsigned i;

      assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("p"), "../src/basic/fileio.c", 1261, __PRETTY_FUNCTION__
); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/fileio.c", 1262, __PRETTY_FUNCTION__
); } while (0);

      /*
       * Turns this:
       *         /foo/bar/waldo
       *
       * Into this:
       *         /foo/bar/.#<extra>waldobaa2a261115984a9
       */

      fn = basename(p);
      if (!filename_is_valid(fn))
              return -EINVAL22;

      extra = strempty(extra);

      t = new(char, strlen(p) + 2 + strlen(extra) + 16 + 1)((char*) malloc_multiply(sizeof(char), (strlen(p) + 2 + strlen
(extra) + 16 + 1)));
      if (!t)
              return -ENOMEM12;

      x = stpcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), extra), fn);

      u = random_u64();
      for (i = 0; i < 16; i++) {
              *(x++) = hexchar(u & 0xF);
              u >>= 4;
      }

      *x = 0;

      *ret = path_simplify(t, false0);
      return 0;
1294}

1296int tempfn_random_child(const char *p, const char *extra, char **ret) {
      char *t, *x;
      uint64_t u;
      unsigned i;
      int r;

      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/fileio.c", 1302, __PRETTY_FUNCTION__
); } while (0);

      /* Turns this:
       *         /foo/bar/waldo
       * Into this:
       *         /foo/bar/waldo/.#<extra>3c2b6219aa75d7d0
       */

      if (!p) {
              r = tmp_dir(&p);
              if (r < 0)
                      return r;
      }

      extra = strempty(extra);

      t = new(char, strlen(p) + 3 + strlen(extra) + 16 + 1)((char*) malloc_multiply(sizeof(char), (strlen(p) + 3 + strlen
(extra) + 16 + 1)));
      if (!t)
              return -ENOMEM12;

      x = stpcpy(stpcpy(stpcpy(t, p), "/.#"), extra);

      u = random_u64();
      for (i = 0; i < 16; i++) {
              *(x++) = hexchar(u & 0xF);
              u >>= 4;
      }

      *x = 0;

      *ret = path_simplify(t, false0);
      return 0;
1334}

1336int write_timestamp_file_atomic(const char *fn, usec_t n) {
      char ln[DECIMAL_STR_MAX(n)(2+(sizeof(n) <= 1 ? 3 : sizeof(n) <= 2 ? 5 : sizeof(n)
 <= 4 ? 10 : sizeof(n) <= 8 ? 20 : sizeof(int[-2*(sizeof
(n) > 8)])))+2];

      /* Creates a "timestamp" file, that contains nothing but a
       * usec_t timestamp, formatted in ASCII. */

      if (n <= 0 || n >= USEC_INFINITY((usec_t) -1))
              return -ERANGE34;

      xsprintf(ln, USEC_FMT "\n", n)do { if ((__builtin_expect(!!(!(((size_t) snprintf(ln, __extension__
 (__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(ln), typeof(&*(ln))), sizeof(ln)/sizeof((ln)[0]), ((void
)0))), "%" "l" "u" "\n", n) < (__extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(ln), typeof(&*(ln)
)), sizeof(ln)/sizeof((ln)[0]), ((void)0))))))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("xsprintf: " "ln" "[] must be big enough"
), "../src/basic/fileio.c", 1345, __PRETTY_FUNCTION__); } while
 (0);

      return write_string_file(fn, ln, WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_ATOMIC);
1348}

1350int read_timestamp_file(const char *fn, usec_t *ret) {
      _cleanup_free___attribute__((cleanup(freep))) char *ln = NULL((void*)0);
      uint64_t t;
      int r;

      r = read_one_line_file(fn, &ln);
      if (r < 0)
              return r;

      r = safe_atou64(ln, &t);
      if (r < 0)
              return r;

      if (t <= 0 || t >= (uint64_t) USEC_INFINITY((usec_t) -1))
              return -ERANGE34;

      *ret = (usec_t) t;
      return 0;
1368}

1370int fputs_with_space(FILE *f, const char *s, const char *separator, bool_Bool *space) {
      int r;

      assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/basic/fileio.c", 1373, __PRETTY_FUNCTION__
); } while (0);

      /* Outputs the specified string with fputs(), but optionally prefixes it with a separator. The *space parameter
       * when specified shall initially point to a boolean variable initialized to false. It is set to true after the
       * first invocation. This call is supposed to be use in loops, where a separator shall be inserted between each
       * element, but not before the first one. */

      if (!f)
              f = stdoutstdout;

      if (space) {
              if (!separator)
                      separator = " ";

              if (*space) {
                      r = fputs(separator, f);
                      if (r < 0)
                              return r;
              }

              *space = true1;
      }

      return fputs(s, f);
1397}

1399int open_tmpfile_unlinkable(const char *directory, int flags) {
      char *p;
      int fd, r;

      if (!directory) {
              r = tmp_dir(&directory);
              if (r < 0)
                      return r;
      }

      /* Returns an unlinked temporary file that cannot be linked into the file system anymore */

      /* Try O_TMPFILE first, if it is supported */
      fd = open(directory, flags|O_TMPFILE(020000000 | 0200000)|O_EXCL0200, S_IRUSR0400|S_IWUSR0200);
      if (fd >= 0)
              return fd;

      /* Fall back to unguessable name + unlinking */
      p = strjoina(directory, "/systemd-tmp-XXXXXX")({ const char *_appendees_[] = { directory, "/systemd-tmp-XXXXXX"
 }; 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_; });

      fd = mkostemp_safe(p);
      if (fd < 0)
              return fd;

      (void) unlink(p);

      return fd;
1426}

1428int open_tmpfile_linkable(const char *target, int flags, char **ret_path) {
      _cleanup_free___attribute__((cleanup(freep))) char *tmp = NULL((void*)0);
      int r, fd;

      assert(target)do { if ((__builtin_expect(!!(!(target)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("target"), "../src/basic/fileio.c", 1432
, __PRETTY_FUNCTION__); } while (0);
      assert(ret_path)do { if ((__builtin_expect(!!(!(ret_path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret_path"), "../src/basic/fileio.c", 1433
, __PRETTY_FUNCTION__); } while (0);

      /* Don't allow O_EXCL, as that has a special meaning for O_TMPFILE */
      assert((flags & O_EXCL) == 0)do { if ((__builtin_expect(!!(!((flags & 0200) == 0)),0))
) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("(flags & O_EXCL) == 0"
), "../src/basic/fileio.c", 1436, __PRETTY_FUNCTION__); } while
 (0);

      /* Creates a temporary file, that shall be renamed to "target" later. If possible, this uses O_TMPFILE – in
       * which case "ret_path" will be returned as NULL. If not possible a the tempoary path name used is returned in
       * "ret_path". Use link_tmpfile() below to rename the result after writing the file in full. */

      {
              _cleanup_free___attribute__((cleanup(freep))) char *dn = NULL((void*)0);

              dn = dirname_malloc(target);
              if (!dn)
                      return -ENOMEM12;

              fd = open(dn, O_TMPFILE(020000000 | 0200000)|flags, 0640);
              if (fd >= 0) {
                      *ret_path = NULL((void*)0);
                      return fd;
              }

              log_debug_errno(errno, "Failed to use O_TMPFILE on %s: %m", dn)({ int _level = ((7)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/basic/fileio.c", 1455, __func__,
 "Failed to use O_TMPFILE on %s: %m", dn) : -abs(_e); });
      }

      r = tempfn_random(target, NULL((void*)0), &tmp);
      if (r < 0)
              return r;

      fd = open(tmp, O_CREAT0100|O_EXCL0200|O_NOFOLLOW0400000|O_NOCTTY0400|flags, 0640);
      if (fd < 0)
              return -errno(*__errno_location ());

      *ret_path = TAKE_PTR(tmp)({ typeof(tmp) _ptr_ = (tmp); (tmp) = ((void*)0); _ptr_; });

      return fd;
1469}

1471int open_serialization_fd(const char *ident) {
      int fd = -1;

      fd = memfd_create(ident, MFD_CLOEXEC1U);
      if (fd < 0) {
              const char *path;

              path = getpid_cached() == 1 ? "/run/systemd" : "/tmp";
              fd = open_tmpfile_unlinkable(path, O_RDWR02|O_CLOEXEC02000000);
              if (fd < 0)
                      return fd;

              log_debug("Serializing %s to %s.", ident, path)({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/fileio.c", 1483, __func__, "Serializing %s to %s."
, ident, path) : -abs(_e); });
      } else
              log_debug("Serializing %s to memfd.", ident)({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/fileio.c", 1485, __func__, "Serializing %s to memfd."
, ident) : -abs(_e); });

      return fd;
1488}

1490int link_tmpfile(int fd, const char *path, const char *target) {

      assert(fd >= 0)do { if ((__builtin_expect(!!(!(fd >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fd >= 0"), "../src/basic/fileio.c", 1492
, __PRETTY_FUNCTION__); } while (0);
      assert(target)do { if ((__builtin_expect(!!(!(target)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("target"), "../src/basic/fileio.c", 1493
, __PRETTY_FUNCTION__); } while (0);

      /* Moves a temporary file created with open_tmpfile() above into its final place. if "path" is NULL an fd
       * created with O_TMPFILE is assumed, and linkat() is used. Otherwise it is assumed O_TMPFILE is not supported
       * on the directory, and renameat2() is used instead.
       *
       * Note that in both cases we will not replace existing files. This is because linkat() does not support this
       * operation currently (renameat2() does), and there is no nice way to emulate this. */

      if (path) {
              if (rename_noreplace(AT_FDCWD-100, path, AT_FDCWD-100, target) < 0)
                      return -errno(*__errno_location ());
      } else {
              char proc_fd_path[STRLEN("/proc/self/fd/")(sizeof("""/proc/self/fd/""") - 1) + DECIMAL_STR_MAX(fd)(2+(sizeof(fd) <= 1 ? 3 : sizeof(fd) <= 2 ? 5 : sizeof(
fd) <= 4 ? 10 : sizeof(fd) <= 8 ? 20 : sizeof(int[-2*(sizeof
(fd) > 8)]))) + 1];

              xsprintf(proc_fd_path, "/proc/self/fd/%i", fd)do { if ((__builtin_expect(!!(!(((size_t) snprintf(proc_fd_path
, __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(proc_fd_path), typeof(&*(proc_fd_path))), sizeof(
proc_fd_path)/sizeof((proc_fd_path)[0]), ((void)0))), "/proc/self/fd/%i"
, fd) < (__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(proc_fd_path), typeof(&*(proc_fd_path))), sizeof(
proc_fd_path)/sizeof((proc_fd_path)[0]), ((void)0))))))),0)))
 log_assert_failed_realm(LOG_REALM_SYSTEMD, ("xsprintf: " "proc_fd_path"
 "[] must be big enough"), "../src/basic/fileio.c", 1508, __PRETTY_FUNCTION__
); } while (0);

              if (linkat(AT_FDCWD-100, proc_fd_path, AT_FDCWD-100, target, AT_SYMLINK_FOLLOW0x400) < 0)
                      return -errno(*__errno_location ());
      }

      return 0;
1515}

1517int read_nul_string(FILE *f, char **ret) {
      _cleanup_free___attribute__((cleanup(freep))) char *x = NULL((void*)0);
      size_t allocated = 0, n = 0;

      assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/basic/fileio.c", 1521, __PRETTY_FUNCTION__
); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/fileio.c", 1522, __PRETTY_FUNCTION__
); } while (0);

      /* Reads a NUL-terminated string from the specified file. */

      for (;;) {
              int c;

              if (!GREEDY_REALLOC(x, allocated, n+2)greedy_realloc((void**) &(x), &(allocated), (n+2), sizeof
((x)[0])))
                      return -ENOMEM12;

              c = fgetc(f);
              if (c == 0) /* Terminate at NUL byte */
                      break;
              if (c == EOF(-1)) {
                      if (ferror(f))
                              return -errno(*__errno_location ());
                      break; /* Terminate at EOF */
              }

              x[n++] = (char) c;
      }

      if (x)
              x[n] = 0;
      else {
              x = new0(char, 1)((char*) calloc((1), sizeof(char)));
              if (!x)
                      return -ENOMEM12;
      }

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

      return 0;
1555}

1557int mkdtemp_malloc(const char *template, char **ret) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      int r;

      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/fileio.c", 1561, __PRETTY_FUNCTION__
); } while (0);

      if (template)
              p = strdup(template);
      else {
              const char *tmp;

              r = tmp_dir(&tmp);
              if (r < 0)
                      return r;

              p = strjoin(tmp, "/XXXXXX")strjoin_real((tmp), "/XXXXXX", ((void*)0));
      }
      if (!p)
              return -ENOMEM12;

      if (!mkdtemp(p))
              return -errno(*__errno_location ());

      *ret = TAKE_PTR(p)({ typeof(p) _ptr_ = (p); (p) = ((void*)0); _ptr_; });
      return 0;
1582}

1584DEFINE_TRIVIAL_CLEANUP_FUNC(FILE*, funlockfile)static inline void funlockfilep(FILE* *p) { if (*p) funlockfile
(*p); };

1586int read_line(FILE *f, size_t limit, char **ret) {
      _cleanup_free___attribute__((cleanup(freep))) char *buffer = NULL((void*)0);
      size_t n = 0, allocated = 0, count = 0;

      assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/basic/fileio.c", 1590, __PRETTY_FUNCTION__
); } while (0);

      /* Something like a bounded version of getline().
       *
       * Considers EOF, \n and \0 end of line delimiters, and does not include these delimiters in the string
       * returned.
       *
       * Returns the number of bytes read from the files (i.e. including delimiters — this hence usually differs from
       * the number of characters in the returned string). When EOF is hit, 0 is returned.
       *
       * The input parameter limit is the maximum numbers of characters in the returned string, i.e. excluding
       * delimiters. If the limit is hit we fail and return -ENOBUFS.
       *
       * If a line shall be skipped ret may be initialized as NULL. */

      if (ret) {
              if (!GREEDY_REALLOC(buffer, allocated, 1)greedy_realloc((void**) &(buffer), &(allocated), (1),
 sizeof((buffer)[0])))
                      return -ENOMEM12;
      }

      {
              _unused___attribute__ ((unused)) _cleanup_(funlockfilep)__attribute__((cleanup(funlockfilep))) FILE *flocked = f;
              flockfile(f);

              for (;;) {
                      int c;

                      if (n >= limit)
                              return -ENOBUFS105;

                      errno(*__errno_location ()) = 0;
                      c = fgetc_unlocked(f);
                      if (c == EOF(-1)) {
                              /* if we read an error, and have no data to return, then propagate the error */
                              if (ferror_unlocked(f) && n == 0)
                                      return errno(*__errno_location ()) > 0 ? -errno(*__errno_location ()) : -EIO5;

                              break;
                      }

                      count++;

                      if (IN_SET(c, '\n', 0)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){'\n', 0})/sizeof(int)]; switch(c) { case
 '\n': case 0: _found = 1; break; default: break; } _found; }
)) /* Reached a delimiter */
                              break;

                      if (ret) {
                              if (!GREEDY_REALLOC(buffer, allocated, n + 2)greedy_realloc((void**) &(buffer), &(allocated), (n +
 2), sizeof((buffer)[0])))
                                      return -ENOMEM12;

                              buffer[n] = (char) c;
                      }

                      n++;
              }
      }

      if (ret) {
              buffer[n] = 0;

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

      return (int) count;
1653}

←

../src/basic/string-util.h

1/* SPDX-License-Identifier: LGPL-2.1+ */
2#pragma once
3 
4#include <alloca.h>
5#include <stdbool.h>
6#include <stddef.h>
7#include <string.h>
8 
9#include "macro.h"
10 
11/* What is interpreted as whitespace? */
12#define WHITESPACE" \t\n\r"        " \t\n\r"
13#define NEWLINE"\n\r"           "\n\r"
14#define QUOTES"\"\'"            "\"\'"
15#define COMMENTS"#;"          "#;"
16#define GLOB_CHARS"*?["        "*?["
17#define DIGITS"0123456789"            "0123456789"
18#define LOWERCASE_LETTERS"abcdefghijklmnopqrstuvwxyz" "abcdefghijklmnopqrstuvwxyz"
19#define UPPERCASE_LETTERS"ABCDEFGHIJKLMNOPQRSTUVWXYZ" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
20#define LETTERS"abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"           LOWERCASE_LETTERS"abcdefghijklmnopqrstuvwxyz" UPPERCASE_LETTERS"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
21#define ALPHANUMERICAL"abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789"    LETTERS"abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" DIGITS"0123456789"
22#define HEXDIGITS"0123456789" "abcdefABCDEF"         DIGITS"0123456789" "abcdefABCDEF"
23 
24#define streq(a,b)(strcmp((a),(b)) == 0) (strcmp((a),(b)) == 0)
25#define strneq(a, b, n)(strncmp((a), (b), (n)) == 0) (strncmp((a), (b), (n)) == 0)
26#define strcaseeq(a,b)(strcasecmp((a),(b)) == 0) (strcasecmp((a),(b)) == 0)
27#define strncaseeq(a, b, n)(strncasecmp((a), (b), (n)) == 0) (strncasecmp((a), (b), (n)) == 0)
28 
29int strcmp_ptr(const char *a, const char *b) _pure___attribute__ ((pure));
30 
31static inline bool_Bool streq_ptr(const char *a, const char *b) {
32        return strcmp_ptr(a, b) == 0;
33}
34 
35static inline const char* strempty(const char *s) {
36        return s ?: "";
37}
38 
39static inline const char* strnull(const char *s) {
40        return s ?: "(null)";
41}
42 
43static inline const char *strna(const char *s) {
44        return s ?: "n/a";
45}
46 
47static inline bool_Bool isempty(const char *p) {
48        return !p || !p[0];
49}
50 
51static inline const char *empty_to_null(const char *p) {
52        return isempty(p) ? NULL((void*)0) : p;
53}
54 
55static inline const char *empty_to_dash(const char *str) {
56        return isempty(str) ? "-" : str;
57}
58 
59static inline char *startswith(const char *s, const char *prefix) {
60        size_t l;
61 
62        l = strlen(prefix);
63        if (strncmp(s, prefix, l) == 0)
20
←
Null pointer passed to 1st parameter expecting 'nonnull'
64                return (char*) s + l;
65 
66        return NULL((void*)0);
67}
68 
69static inline char *startswith_no_case(const char *s, const char *prefix) {
70        size_t l;
71 
72        l = strlen(prefix);
73        if (strncasecmp(s, prefix, l) == 0)
74                return (char*) s + l;
75 
76        return NULL((void*)0);
77}
78 
79char *endswith(const char *s, const char *postfix) _pure___attribute__ ((pure));
80char *endswith_no_case(const char *s, const char *postfix) _pure___attribute__ ((pure));
81 
82char *first_word(const char *s, const char *word) _pure___attribute__ ((pure));
83 
84const char* split(const char **state, size_t *l, const char *separator, bool_Bool quoted);
85 
86#define FOREACH_WORD(word, length, s, state)for ((state) = (s), (word) = split(&(state), &(length
), (" \t\n\r"), (0)); (word); (word) = split(&(state), &
(length), (" \t\n\r"), (0)))                            \
87        _FOREACH_WORD(word, length, s, WHITESPACE, false, state)for ((state) = (s), (word) = split(&(state), &(length
), (" \t\n\r"), (0)); (word); (word) = split(&(state), &
(length), (" \t\n\r"), (0)))
88 
89#define FOREACH_WORD_SEPARATOR(word, length, s, separator, state)for ((state) = (s), (word) = split(&(state), &(length
), (separator), (0)); (word); (word) = split(&(state), &
(length), (separator), (0)))       \
90        _FOREACH_WORD(word, length, s, separator, false, state)for ((state) = (s), (word) = split(&(state), &(length
), (separator), (0)); (word); (word) = split(&(state), &
(length), (separator), (0)))
91 
92#define _FOREACH_WORD(word, length, s, separator, quoted, state)for ((state) = (s), (word) = split(&(state), &(length
), (separator), (quoted)); (word); (word) = split(&(state
), &(length), (separator), (quoted)))        \
93        for ((state) = (s), (word) = split(&(state), &(length), (separator), (quoted)); (word); (word) = split(&(state), &(length), (separator), (quoted)))
94 
95char *strappend(const char *s, const char *suffix);
96char *strnappend(const char *s, const char *suffix, size_t length);
97 
98char *strjoin_real(const char *x, ...) _sentinel___attribute__ ((sentinel));
99#define strjoin(a, ...)strjoin_real((a), ..., ((void*)0)) strjoin_real((a), __VA_ARGS__, NULL((void*)0))
100 
101#define strjoina(a, ...)({ const char *_appendees_[] = { a, ... }; 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_; })                                                \
102        ({                                                              \
103                const char *_appendees_[] = { a, __VA_ARGS__ };         \
104                char *_d_, *_p_;                                        \
105                size_t _len_ = 0;                                          \
106                size_t _i_;                                           \
107                for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_[_i_]; _i_++) \
108                        _len_ += strlen(_appendees_[_i_]);              \
109                _p_ = _d_ = alloca(_len_ + 1)__builtin_alloca (_len_ + 1);                          \
110                for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_[_i_]; _i_++) \
111                        _p_ = stpcpy(_p_, _appendees_[_i_]);            \
112                *_p_ = 0;                                               \
113                _d_;                                                    \
114        })
115 
116char *strstrip(char *s);
117char *delete_chars(char *s, const char *bad);
118char *delete_trailing_chars(char *s, const char *bad);
119char *truncate_nl(char *s);
120 
121static inline char *skip_leading_chars(const char *s, const char *bad) {
122 
123        if (!s)
124                return NULL((void*)0);
125 
126        if (!bad)
127                bad = WHITESPACE" \t\n\r";
128 
129        return (char*) s + strspn(s, bad);
130}
131 
132char ascii_tolower(char x);
133char *ascii_strlower(char *s);
134char *ascii_strlower_n(char *s, size_t n);
135 
136char ascii_toupper(char x);
137char *ascii_strupper(char *s);
138 
139int ascii_strcasecmp_n(const char *a, const char *b, size_t n);
140int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m);
141 
142bool_Bool chars_intersect(const char *a, const char *b) _pure___attribute__ ((pure));
143 
144static inline bool_Bool _pure___attribute__ ((pure)) in_charset(const char *s, const char* charset) {
145        assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/basic/string-util.h", 145,
 __PRETTY_FUNCTION__); } while (0);
146        assert(charset)do { if ((__builtin_expect(!!(!(charset)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("charset"), "../src/basic/string-util.h"
, 146, __PRETTY_FUNCTION__); } while (0);
147        return s[strspn(s, charset)] == '\0';
148}
149 
150bool_Bool string_has_cc(const char *p, const char *ok) _pure___attribute__ ((pure));
151 
152char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent);
153static inline char *ellipsize(const char *s, size_t length, unsigned percent) {
154        return ellipsize_mem(s, strlen(s), length, percent);
155}
156 
157char *cellescape(char *buf, size_t len, const char *s);
158 
159/* This limit is arbitrary, enough to give some idea what the string contains */
160#define CELLESCAPE_DEFAULT_LENGTH64 64
161 
162bool_Bool nulstr_contains(const char *nulstr, const char *needle);
163 
164char* strshorten(char *s, size_t l);
165 
166char *strreplace(const char *text, const char *old_string, const char *new_string);
167 
168char *strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]);
169 
170char *strextend_with_separator(char **x, const char *separator, ...) _sentinel___attribute__ ((sentinel));
171 
172#define strextend(x, ...)strextend_with_separator(x, ((void*)0), ...) strextend_with_separator(x, NULL((void*)0), __VA_ARGS__)
173 
174char *strrep(const char *s, unsigned n);
175 
176int split_pair(const char *s, const char *sep, char **l, char **r);
177 
178int free_and_strdup(char **p, const char *s);
179int free_and_strndup(char **p, const char *s, size_t l);
180 
181/* Normal memmem() requires haystack to be nonnull, which is annoying for zero-length buffers */
182static inline void *memmem_safe(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen) {
183 
184        if (needlelen <= 0)
185                return (void*) haystack;
186 
187        if (haystacklen < needlelen)
188                return NULL((void*)0);
189 
190        assert(haystack)do { if ((__builtin_expect(!!(!(haystack)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("haystack"), "../src/basic/string-util.h"
, 190, __PRETTY_FUNCTION__); } while (0);
191        assert(needle)do { if ((__builtin_expect(!!(!(needle)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("needle"), "../src/basic/string-util.h",
 191, __PRETTY_FUNCTION__); } while (0);
192 
193        return memmem(haystack, haystacklen, needle, needlelen);
194}
195 
196#if !HAVE_EXPLICIT_BZERO1
197void explicit_bzero(void *p, size_t l);
198#endif
199 
200char *string_erase(char *x);
201 
202char *string_free_erase(char *s);
203DEFINE_TRIVIAL_CLEANUP_FUNC(char *, string_free_erase)static inline void string_free_erasep(char * *p) { if (*p) string_free_erase
(*p); };
204#define _cleanup_string_free_erase___attribute__((cleanup(string_free_erasep))) _cleanup_(string_free_erasep)__attribute__((cleanup(string_free_erasep)))
205 
206bool_Bool string_is_safe(const char *p) _pure___attribute__ ((pure));
207 
208static inline size_t strlen_ptr(const char *s) {
209        if (!s)
210                return 0;
211 
212        return strlen(s);
213}
214 
215/* Like startswith(), but operates on arbitrary memory blocks */
216static inline void *memory_startswith(const void *p, size_t sz, const char *token) {
217        size_t n;
218 
219        assert(token)do { if ((__builtin_expect(!!(!(token)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("token"), "../src/basic/string-util.h", 219
, __PRETTY_FUNCTION__); } while (0);
220 
221        n = strlen(token);
222        if (sz < n)
223                return NULL((void*)0);
224 
225        assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("p"), "../src/basic/string-util.h", 225,
 __PRETTY_FUNCTION__); } while (0);
226 
227        if (memcmp(p, token, n) != 0)
228                return NULL((void*)0);
229 
230        return (uint8_t*) p + n;
231}