1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
12 #include <sys/types.h>
15 #include "alloc-util.h"
19 #include "hexdecoct.h"
23 #include "parse-util.h"
24 #include "path-util.h"
25 #include "socket-util.h"
26 #include "stdio-util.h"
27 #include "string-util.h"
28 #include "tmpfile-util.h"
30 #define READ_FULL_BYTES_MAX (4U*1024U*1024U)
32 int fopen_unlocked(const char *path
, const char *options
, FILE **ret
) {
35 FILE *f
= fopen(path
, options
);
39 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
45 int fdopen_unlocked(int fd
, const char *options
, FILE **ret
) {
48 FILE *f
= fdopen(fd
, options
);
52 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
58 int take_fdopen_unlocked(int *fd
, const char *options
, FILE **ret
) {
63 r
= fdopen_unlocked(*fd
, options
, ret
);
72 FILE* take_fdopen(int *fd
, const char *options
) {
75 FILE *f
= fdopen(*fd
, options
);
84 DIR* take_fdopendir(int *dfd
) {
87 DIR *d
= fdopendir(*dfd
);
96 FILE* open_memstream_unlocked(char **ptr
, size_t *sizeloc
) {
97 FILE *f
= open_memstream(ptr
, sizeloc
);
101 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
106 FILE* fmemopen_unlocked(void *buf
, size_t size
, const char *mode
) {
107 FILE *f
= fmemopen(buf
, size
, mode
);
111 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
116 int write_string_stream_ts(
119 WriteStringFileFlags flags
,
120 const struct timespec
*ts
) {
132 /* If we shall set the timestamp we need the fd. But fmemopen() streams generally don't have
133 * an fd. Let's fail early in that case. */
139 needs_nl
= !(flags
& WRITE_STRING_FILE_AVOID_NEWLINE
) && !endswith(line
, "\n");
141 if (needs_nl
&& (flags
& WRITE_STRING_FILE_DISABLE_BUFFER
)) {
142 /* If STDIO buffering was disabled, then let's append the newline character to the string itself, so
143 * that the write goes out in one go, instead of two */
145 line
= strjoina(line
, "\n");
149 if (fputs(line
, f
) == EOF
)
153 if (fputc('\n', f
) == EOF
)
156 if (flags
& WRITE_STRING_FILE_SYNC
)
157 r
= fflush_sync_and_check(f
);
159 r
= fflush_and_check(f
);
164 const struct timespec twice
[2] = {*ts
, *ts
};
166 if (futimens(fd
, twice
) < 0)
173 static int write_string_file_atomic(
176 WriteStringFileFlags flags
,
177 const struct timespec
*ts
) {
179 _cleanup_fclose_
FILE *f
= NULL
;
180 _cleanup_free_
char *p
= NULL
;
186 /* Note that we'd really like to use O_TMPFILE here, but can't really, since we want replacement
187 * semantics here, and O_TMPFILE can't offer that. i.e. rename() replaces but linkat() doesn't. */
189 r
= fopen_temporary(fn
, &f
, &p
);
193 r
= write_string_stream_ts(f
, line
, flags
, ts
);
197 r
= fchmod_umask(fileno(f
), FLAGS_SET(flags
, WRITE_STRING_FILE_MODE_0600
) ? 0600 : 0644);
201 if (rename(p
, fn
) < 0) {
206 if (FLAGS_SET(flags
, WRITE_STRING_FILE_SYNC
)) {
207 /* Sync the rename, too */
208 r
= fsync_directory_of_file(fileno(f
));
220 int write_string_file_ts(
223 WriteStringFileFlags flags
,
224 const struct timespec
*ts
) {
226 _cleanup_fclose_
FILE *f
= NULL
;
232 /* We don't know how to verify whether the file contents was already on-disk. */
233 assert(!((flags
& WRITE_STRING_FILE_VERIFY_ON_FAILURE
) && (flags
& WRITE_STRING_FILE_SYNC
)));
235 if (flags
& WRITE_STRING_FILE_MKDIR_0755
) {
236 r
= mkdir_parents(fn
, 0755);
241 if (flags
& WRITE_STRING_FILE_ATOMIC
) {
242 assert(flags
& WRITE_STRING_FILE_CREATE
);
244 r
= write_string_file_atomic(fn
, line
, flags
, ts
);
252 /* We manually build our own version of fopen(..., "we") that works without O_CREAT and with O_NOFOLLOW if needed. */
253 fd
= open(fn
, O_WRONLY
|O_CLOEXEC
|O_NOCTTY
|
254 (FLAGS_SET(flags
, WRITE_STRING_FILE_NOFOLLOW
) ? O_NOFOLLOW
: 0) |
255 (FLAGS_SET(flags
, WRITE_STRING_FILE_CREATE
) ? O_CREAT
: 0) |
256 (FLAGS_SET(flags
, WRITE_STRING_FILE_TRUNCATE
) ? O_TRUNC
: 0),
257 (FLAGS_SET(flags
, WRITE_STRING_FILE_MODE_0600
) ? 0600 : 0666));
263 r
= fdopen_unlocked(fd
, "w", &f
);
269 if (flags
& WRITE_STRING_FILE_DISABLE_BUFFER
)
270 setvbuf(f
, NULL
, _IONBF
, 0);
272 r
= write_string_stream_ts(f
, line
, flags
, ts
);
279 if (!(flags
& WRITE_STRING_FILE_VERIFY_ON_FAILURE
))
284 /* OK, the operation failed, but let's see if the right
285 * contents in place already. If so, eat up the error. */
287 q
= verify_file(fn
, line
, !(flags
& WRITE_STRING_FILE_AVOID_NEWLINE
));
294 int write_string_filef(
296 WriteStringFileFlags flags
,
297 const char *format
, ...) {
299 _cleanup_free_
char *p
= NULL
;
303 va_start(ap
, format
);
304 r
= vasprintf(&p
, format
, ap
);
310 return write_string_file(fn
, p
, flags
);
313 int read_one_line_file(const char *fn
, char **line
) {
314 _cleanup_fclose_
FILE *f
= NULL
;
320 r
= fopen_unlocked(fn
, "re", &f
);
324 return read_line(f
, LONG_LINE_MAX
, line
);
327 int verify_file(const char *fn
, const char *blob
, bool accept_extra_nl
) {
328 _cleanup_fclose_
FILE *f
= NULL
;
329 _cleanup_free_
char *buf
= NULL
;
338 if (accept_extra_nl
&& endswith(blob
, "\n"))
339 accept_extra_nl
= false;
341 buf
= malloc(l
+ accept_extra_nl
+ 1);
345 r
= fopen_unlocked(fn
, "re", &f
);
349 /* We try to read one byte more than we need, so that we know whether we hit eof */
351 k
= fread(buf
, 1, l
+ accept_extra_nl
+ 1, f
);
353 return errno_or_else(EIO
);
355 if (k
!= l
&& k
!= l
+ accept_extra_nl
)
357 if (memcmp(buf
, blob
, l
) != 0)
359 if (k
> l
&& buf
[l
] != '\n')
365 int read_full_virtual_file(const char *filename
, char **ret_contents
, size_t *ret_size
) {
366 _cleanup_free_
char *buf
= NULL
;
367 _cleanup_close_
int fd
= -1;
373 assert(ret_contents
);
375 /* Virtual filesystems such as sysfs or procfs use kernfs, and kernfs can work
376 * with two sorts of virtual files. One sort uses "seq_file", and the results of
377 * the first read are buffered for the second read. The other sort uses "raw"
378 * reads which always go direct to the device. In the latter case, the content of
379 * the virtual file must be retrieved with a single read otherwise a second read
380 * might get the new value instead of finding EOF immediately. That's the reason
381 * why the usage of fread(3) is prohibited in this case as it always performs a
382 * second call to read(2) looking for EOF. See issue 13585. */
384 fd
= open(filename
, O_RDONLY
|O_CLOEXEC
);
388 /* Start size for files in /proc which usually report a file size of 0. */
391 /* Limit the number of attempts to read the number of bytes returned by fstat(). */
398 if (fstat(fd
, &st
) < 0)
401 if (!S_ISREG(st
.st_mode
))
404 /* Be prepared for files from /proc which generally report a file size of 0. */
405 if (st
.st_size
> 0) {
411 if (size
> READ_FULL_BYTES_MAX
)
414 p
= realloc(buf
, size
+ 1);
422 /* Read one more byte so we can detect whether the content of the
423 * file has already changed or the guessed size for files from /proc
424 * wasn't large enough . */
425 k
= read(fd
, buf
, size
+ 1);
435 /* Consider a short read as EOF */
439 /* Hmm... either we read too few bytes from /proc or less likely the content
440 * of the file might have been changed (and is now bigger) while we were
441 * processing, let's try again either with a bigger guessed size or the new
444 if (lseek(fd
, 0, SEEK_SET
) < 0)
449 p
= realloc(buf
, n
+ 1);
456 /* Safety check: if the caller doesn't want to know the size of what we
457 * just read it will rely on the trailing NUL byte. But if there's an
458 * embedded NUL byte, then we should refuse operation as otherwise
459 * there'd be ambiguity about what we just read. */
461 if (memchr(buf
, 0, n
))
467 *ret_contents
= TAKE_PTR(buf
);
472 int read_full_stream_full(
474 const char *filename
,
475 ReadFullFileFlags flags
,
479 _cleanup_free_
char *buf
= NULL
;
485 assert(ret_contents
);
486 assert(!FLAGS_SET(flags
, READ_FULL_FILE_UNBASE64
| READ_FULL_FILE_UNHEX
));
488 n_next
= LINE_MAX
; /* Start size */
491 if (fd
>= 0) { /* If the FILE* object is backed by an fd (as opposed to memory or such, see fmemopen()), let's
492 * optimize our buffering */
494 if (fstat(fd
, &st
) < 0)
497 if (S_ISREG(st
.st_mode
)) {
500 if (st
.st_size
> READ_FULL_BYTES_MAX
)
503 /* Start with the right file size. Note that we increase the size
504 * to read here by one, so that the first read attempt already
505 * makes us notice the EOF. */
507 n_next
= st
.st_size
+ 1;
509 if (flags
& READ_FULL_FILE_WARN_WORLD_READABLE
)
510 (void) warn_file_is_world_accessible(filename
, &st
, NULL
, 0);
519 if (flags
& READ_FULL_FILE_SECURE
) {
520 t
= malloc(n_next
+ 1);
525 memcpy_safe(t
, buf
, n
);
526 explicit_bzero_safe(buf
, n
);
529 t
= realloc(buf
, n_next
+ 1);
538 k
= fread(buf
+ l
, 1, n
- l
, f
);
544 r
= errno_or_else(EIO
);
550 assert(k
> 0); /* we can't have read zero bytes because that would have been EOF */
553 if (n
>= READ_FULL_BYTES_MAX
) {
558 n_next
= MIN(n
* 2, READ_FULL_BYTES_MAX
);
561 if (flags
& (READ_FULL_FILE_UNBASE64
| READ_FULL_FILE_UNHEX
)) {
562 _cleanup_free_
void *decoded
= NULL
;
566 if (flags
& READ_FULL_FILE_UNBASE64
)
567 r
= unbase64mem_full(buf
, l
, flags
& READ_FULL_FILE_SECURE
, &decoded
, &decoded_size
);
569 r
= unhexmem_full(buf
, l
, flags
& READ_FULL_FILE_SECURE
, &decoded
, &decoded_size
);
573 if (flags
& READ_FULL_FILE_SECURE
)
574 explicit_bzero_safe(buf
, n
);
575 free_and_replace(buf
, decoded
);
576 n
= l
= decoded_size
;
580 /* Safety check: if the caller doesn't want to know the size of what we just read it will rely on the
581 * trailing NUL byte. But if there's an embedded NUL byte, then we should refuse operation as otherwise
582 * there'd be ambiguity about what we just read. */
584 if (memchr(buf
, 0, l
)) {
591 *ret_contents
= TAKE_PTR(buf
);
599 if (flags
& READ_FULL_FILE_SECURE
)
600 explicit_bzero_safe(buf
, n
);
605 int read_full_file_full(
607 const char *filename
,
608 ReadFullFileFlags flags
,
609 const char *bind_name
,
610 char **contents
, size_t *size
) {
612 _cleanup_fclose_
FILE *f
= NULL
;
618 r
= xfopenat(dir_fd
, filename
, "re", 0, &f
);
620 _cleanup_close_
int dfd
= -1, sk
= -1;
621 union sockaddr_union sa
;
623 /* ENXIO is what Linux returns if we open a node that is an AF_UNIX socket */
627 /* If this is enabled, let's try to connect to it */
628 if (!FLAGS_SET(flags
, READ_FULL_FILE_CONNECT_SOCKET
))
631 if (dir_fd
== AT_FDCWD
)
632 r
= sockaddr_un_set_path(&sa
.un
, filename
);
634 char procfs_path
[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
636 /* If we shall operate relative to some directory, then let's use O_PATH first to
637 * open the socket inode, and then connect to it via /proc/self/fd/. We have to do
638 * this since there's not connectat() that takes a directory fd as first arg. */
640 dfd
= openat(dir_fd
, filename
, O_PATH
|O_CLOEXEC
);
644 xsprintf(procfs_path
, "/proc/self/fd/%i", dfd
);
645 r
= sockaddr_un_set_path(&sa
.un
, procfs_path
);
650 sk
= socket(AF_UNIX
, SOCK_STREAM
|SOCK_CLOEXEC
, 0);
655 /* If the caller specified a socket name to bind to, do so before connecting. This is
656 * useful to communicate some minor, short meta-information token from the client to
658 union sockaddr_union bsa
;
660 r
= sockaddr_un_set_path(&bsa
.un
, bind_name
);
664 if (bind(sk
, &bsa
.sa
, r
) < 0)
668 if (connect(sk
, &sa
.sa
, SOCKADDR_UN_LEN(sa
.un
)) < 0)
669 return errno
== ENOTSOCK
? -ENXIO
: -errno
; /* propagate original error if this is
670 * not a socket after all */
672 if (shutdown(sk
, SHUT_WR
) < 0)
682 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
684 return read_full_stream_full(f
, filename
, flags
, contents
, size
);
687 int executable_is_script(const char *path
, char **interpreter
) {
688 _cleanup_free_
char *line
= NULL
;
695 r
= read_one_line_file(path
, &line
);
696 if (r
== -ENOBUFS
) /* First line overly long? if so, then it's not a script */
701 if (!startswith(line
, "#!"))
704 ans
= strstrip(line
+ 2);
705 len
= strcspn(ans
, " \t");
710 ans
= strndup(ans
, len
);
719 * Retrieve one field from a file like /proc/self/status. pattern
720 * should not include whitespace or the delimiter (':'). pattern matches only
721 * the beginning of a line. Whitespace before ':' is skipped. Whitespace and
722 * zeros after the ':' will be skipped. field must be freed afterwards.
723 * terminator specifies the terminating characters of the field value (not
724 * included in the value).
726 int get_proc_field(const char *filename
, const char *pattern
, const char *terminator
, char **field
) {
727 _cleanup_free_
char *status
= NULL
;
737 r
= read_full_virtual_file(filename
, &status
, NULL
);
747 t
= strstr(t
, pattern
);
751 /* Check that pattern occurs in beginning of line. */
752 pattern_ok
= (t
== status
|| t
[-1] == '\n');
754 t
+= strlen(pattern
);
756 } while (!pattern_ok
);
758 t
+= strspn(t
, " \t");
767 t
+= strspn(t
, " \t");
769 /* Also skip zeros, because when this is used for
770 * capabilities, we don't want the zeros. This way the
771 * same capability set always maps to the same string,
772 * irrespective of the total capability set size. For
773 * other numbers it shouldn't matter. */
775 /* Back off one char if there's nothing but whitespace
777 if (!*t
|| isspace(*t
))
781 len
= strcspn(t
, terminator
);
791 DIR *xopendirat(int fd
, const char *name
, int flags
) {
795 assert(!(flags
& O_CREAT
));
797 nfd
= openat(fd
, name
, O_RDONLY
|O_NONBLOCK
|O_DIRECTORY
|O_CLOEXEC
|flags
, 0);
810 static int mode_to_flags(const char *mode
) {
814 if ((p
= startswith(mode
, "r+")))
816 else if ((p
= startswith(mode
, "r")))
818 else if ((p
= startswith(mode
, "w+")))
819 flags
= O_RDWR
|O_CREAT
|O_TRUNC
;
820 else if ((p
= startswith(mode
, "w")))
821 flags
= O_WRONLY
|O_CREAT
|O_TRUNC
;
822 else if ((p
= startswith(mode
, "a+")))
823 flags
= O_RDWR
|O_CREAT
|O_APPEND
;
824 else if ((p
= startswith(mode
, "a")))
825 flags
= O_WRONLY
|O_CREAT
|O_APPEND
;
829 for (; *p
!= 0; p
++) {
842 /* ignore this here, fdopen() might care later though */
845 case 'c': /* not sure what to do about this one */
854 int xfopenat(int dir_fd
, const char *path
, const char *mode
, int flags
, FILE **ret
) {
857 /* A combination of fopen() with openat() */
859 if (dir_fd
== AT_FDCWD
&& flags
== 0) {
860 f
= fopen(path
, mode
);
866 mode_flags
= mode_to_flags(mode
);
870 fd
= openat(dir_fd
, path
, mode_flags
| flags
);
874 f
= fdopen(fd
, mode
);
885 static int search_and_fopen_internal(const char *path
, const char *mode
, const char *root
, char **search
, FILE **_f
) {
892 if (!path_strv_resolve_uniq(search
, root
))
895 STRV_FOREACH(i
, search
) {
896 _cleanup_free_
char *p
= NULL
;
899 p
= path_join(root
, *i
, path
);
916 int search_and_fopen(const char *path
, const char *mode
, const char *root
, const char **search
, FILE **_f
) {
917 _cleanup_strv_free_
char **copy
= NULL
;
923 if (path_is_absolute(path
)) {
926 f
= fopen(path
, mode
);
935 copy
= strv_copy((char**) search
);
939 return search_and_fopen_internal(path
, mode
, root
, copy
, _f
);
942 int search_and_fopen_nulstr(const char *path
, const char *mode
, const char *root
, const char *search
, FILE **_f
) {
943 _cleanup_strv_free_
char **s
= NULL
;
945 if (path_is_absolute(path
)) {
948 f
= fopen(path
, mode
);
957 s
= strv_split_nulstr(search
);
961 return search_and_fopen_internal(path
, mode
, root
, s
, _f
);
964 int chase_symlinks_and_fopen_unlocked(
967 unsigned chase_flags
,
968 const char *open_flags
,
972 _cleanup_close_
int fd
= -1;
973 _cleanup_free_
char *final_path
= NULL
;
981 mode_flags
= mode_to_flags(open_flags
);
985 fd
= chase_symlinks_and_open(path
, root
, chase_flags
, mode_flags
, ret_path
? &final_path
: NULL
);
989 r
= fdopen_unlocked(fd
, open_flags
, &f
);
996 *ret_path
= TAKE_PTR(final_path
);
1000 int fflush_and_check(FILE *f
) {
1007 return errno_or_else(EIO
);
1012 int fflush_sync_and_check(FILE *f
) {
1017 r
= fflush_and_check(f
);
1021 /* Not all file streams have an fd associated (think: fmemopen()), let's handle this gracefully and
1022 * assume that in that case we need no explicit syncing */
1030 r
= fsync_directory_of_file(fd
);
1037 int write_timestamp_file_atomic(const char *fn
, usec_t n
) {
1038 char ln
[DECIMAL_STR_MAX(n
)+2];
1040 /* Creates a "timestamp" file, that contains nothing but a
1041 * usec_t timestamp, formatted in ASCII. */
1043 if (n
<= 0 || n
>= USEC_INFINITY
)
1046 xsprintf(ln
, USEC_FMT
"\n", n
);
1048 return write_string_file(fn
, ln
, WRITE_STRING_FILE_CREATE
|WRITE_STRING_FILE_ATOMIC
);
1051 int read_timestamp_file(const char *fn
, usec_t
*ret
) {
1052 _cleanup_free_
char *ln
= NULL
;
1056 r
= read_one_line_file(fn
, &ln
);
1060 r
= safe_atou64(ln
, &t
);
1064 if (t
<= 0 || t
>= (uint64_t) USEC_INFINITY
)
1071 int fputs_with_space(FILE *f
, const char *s
, const char *separator
, bool *space
) {
1076 /* Outputs the specified string with fputs(), but optionally prefixes it with a separator. The *space parameter
1077 * when specified shall initially point to a boolean variable initialized to false. It is set to true after the
1078 * first invocation. This call is supposed to be use in loops, where a separator shall be inserted between each
1079 * element, but not before the first one. */
1089 r
= fputs(separator
, f
);
1100 /* A bitmask of the EOL markers we know */
1101 typedef enum EndOfLineMarker
{
1103 EOL_ZERO
= 1 << 0, /* \0 (aka NUL) */
1104 EOL_TEN
= 1 << 1, /* \n (aka NL, aka LF) */
1105 EOL_THIRTEEN
= 1 << 2, /* \r (aka CR) */
1108 static EndOfLineMarker
categorize_eol(char c
, ReadLineFlags flags
) {
1110 if (!IN_SET(flags
, READ_LINE_ONLY_NUL
)) {
1114 return EOL_THIRTEEN
;
1123 DEFINE_TRIVIAL_CLEANUP_FUNC(FILE*, funlockfile
);
1125 int read_line_full(FILE *f
, size_t limit
, ReadLineFlags flags
, char **ret
) {
1126 size_t n
= 0, allocated
= 0, count
= 0;
1127 _cleanup_free_
char *buffer
= NULL
;
1132 /* Something like a bounded version of getline().
1134 * Considers EOF, \n, \r and \0 end of line delimiters (or combinations of these), and does not include these
1135 * delimiters in the string returned. Specifically, recognizes the following combinations of markers as line
1148 * Returns the number of bytes read from the files (i.e. including delimiters — this hence usually differs from
1149 * the number of characters in the returned string). When EOF is hit, 0 is returned.
1151 * The input parameter limit is the maximum numbers of characters in the returned string, i.e. excluding
1152 * delimiters. If the limit is hit we fail and return -ENOBUFS.
1154 * If a line shall be skipped ret may be initialized as NULL. */
1157 if (!GREEDY_REALLOC(buffer
, allocated
, 1))
1162 _unused_
_cleanup_(funlockfilep
) FILE *flocked
= f
;
1163 EndOfLineMarker previous_eol
= EOL_NONE
;
1167 EndOfLineMarker eol
;
1173 if (count
>= INT_MAX
) /* We couldn't return the counter anymore as "int", hence refuse this */
1176 r
= safe_fgetc(f
, &c
);
1179 if (r
== 0) /* EOF is definitely EOL */
1182 eol
= categorize_eol(c
, flags
);
1184 if (FLAGS_SET(previous_eol
, EOL_ZERO
) ||
1185 (eol
== EOL_NONE
&& previous_eol
!= EOL_NONE
) ||
1186 (eol
!= EOL_NONE
&& (previous_eol
& eol
) != 0)) {
1187 /* Previous char was a NUL? This is not an EOL, but the previous char was? This type of
1188 * EOL marker has been seen right before? In either of these three cases we are
1189 * done. But first, let's put this character back in the queue. (Note that we have to
1190 * cast this to (unsigned char) here as ungetc() expects a positive 'int', and if we
1191 * are on an architecture where 'char' equals 'signed char' we need to ensure we don't
1192 * pass a negative value here. That said, to complicate things further ungetc() is
1193 * actually happy with most negative characters and implicitly casts them back to
1194 * positive ones as needed, except for \xff (aka -1, aka EOF), which it refuses. What a
1196 assert_se(ungetc((unsigned char) c
, f
) != EOF
);
1202 if (eol
!= EOL_NONE
) {
1203 /* If we are on a tty, we can't shouldn't wait for more input, because that
1204 * generally means waiting for the user, interactively. In the case of a TTY
1205 * we expect only \n as the single EOL marker, so we are in the lucky
1206 * position that there is no need to wait. We check this condition last, to
1207 * avoid isatty() check if not necessary. */
1209 if ((flags
& (READ_LINE_IS_A_TTY
|READ_LINE_NOT_A_TTY
)) == 0) {
1213 if (fd
< 0) /* Maybe an fmemopen() stream? Handle this gracefully,
1214 * and don't call isatty() on an invalid fd */
1215 flags
|= READ_LINE_NOT_A_TTY
;
1217 flags
|= isatty(fd
) ? READ_LINE_IS_A_TTY
: READ_LINE_NOT_A_TTY
;
1219 if (FLAGS_SET(flags
, READ_LINE_IS_A_TTY
))
1223 if (eol
!= EOL_NONE
) {
1224 previous_eol
|= eol
;
1229 if (!GREEDY_REALLOC(buffer
, allocated
, n
+ 2))
1242 *ret
= TAKE_PTR(buffer
);
1248 int safe_fgetc(FILE *f
, char *ret
) {
1253 /* A safer version of plain fgetc(): let's propagate the error that happened while reading as such, and
1254 * separate the EOF condition from the byte read, to avoid those confusion signed/unsigned issues fgetc()
1261 return errno_or_else(EIO
);
1275 int warn_file_is_world_accessible(const char *filename
, struct stat
*st
, const char *unit
, unsigned line
) {
1282 if (stat(filename
, &_st
) < 0)
1287 if ((st
->st_mode
& S_IRWXO
) == 0)
1291 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1292 "%s has %04o mode that is too permissive, please adjust the ownership and access mode.",
1293 filename
, st
->st_mode
& 07777);
1295 log_warning("%s has %04o mode that is too permissive, please adjust the ownership and access mode.",
1296 filename
, st
->st_mode
& 07777);
1300 int sync_rights(int from
, int to
) {
1303 if (fstat(from
, &st
) < 0)
1306 return fchmod_and_chown(to
, st
.st_mode
& 07777, st
.st_uid
, st
.st_gid
);
1309 int rename_and_apply_smack_floor_label(const char *from
, const char *to
) {
1311 if (rename(from
, to
) < 0)
1314 #ifdef SMACK_RUN_LABEL
1315 r
= mac_smack_apply(to
, SMACK_ATTR_ACCESS
, SMACK_FLOOR_LABEL
);