]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/basic/fd-util.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 #include "parse-util.h"
26 int close_nointr(int fd
) {
33 * Just ignore EINTR; a retry loop is the wrong thing to do on
36 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
37 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
38 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
39 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
47 int safe_close(int fd
) {
50 * Like close_nointr() but cannot fail. Guarantees errno is
51 * unchanged. Is a NOP with negative fds passed, and returns
52 * -1, so that it can be used in this syntax:
54 * fd = safe_close(fd);
60 /* The kernel might return pretty much any error code
61 * via close(), but the fd will be closed anyway. The
62 * only condition we want to check for here is whether
63 * the fd was invalid at all... */
65 assert_se(close_nointr(fd
) != -EBADF
);
71 void safe_close_pair(int p
[]) {
75 /* Special case pairs which use the same fd in both
77 p
[0] = p
[1] = safe_close(p
[0]);
81 p
[0] = safe_close(p
[0]);
82 p
[1] = safe_close(p
[1]);
85 void close_many(const int fds
[], unsigned n_fd
) {
88 assert(fds
|| n_fd
<= 0);
90 for (i
= 0; i
< n_fd
; i
++)
94 int fclose_nointr(FILE *f
) {
97 /* Same as close_nointr(), but for fclose() */
108 FILE* safe_fclose(FILE *f
) {
110 /* Same as safe_close(), but for fclose() */
115 assert_se(fclose_nointr(f
) != EBADF
);
121 DIR* safe_closedir(DIR *d
) {
126 assert_se(closedir(d
) >= 0 || errno
!= EBADF
);
132 int fd_nonblock(int fd
, bool nonblock
) {
137 flags
= fcntl(fd
, F_GETFL
, 0);
142 nflags
= flags
| O_NONBLOCK
;
144 nflags
= flags
& ~O_NONBLOCK
;
149 if (fcntl(fd
, F_SETFL
, nflags
) < 0)
155 int fd_cloexec(int fd
, bool cloexec
) {
160 flags
= fcntl(fd
, F_GETFD
, 0);
165 nflags
= flags
| FD_CLOEXEC
;
167 nflags
= flags
& ~FD_CLOEXEC
;
172 if (fcntl(fd
, F_SETFD
, nflags
) < 0)
178 _pure_
static bool fd_in_set(int fd
, const int fdset
[], unsigned n_fdset
) {
181 assert(n_fdset
== 0 || fdset
);
183 for (i
= 0; i
< n_fdset
; i
++)
190 int close_all_fds(const int except
[], unsigned n_except
) {
191 _cleanup_closedir_
DIR *d
= NULL
;
195 assert(n_except
== 0 || except
);
197 d
= opendir("/proc/self/fd");
202 /* When /proc isn't available (for example in chroots)
203 * the fallback is brute forcing through the fd
206 assert_se(getrlimit(RLIMIT_NOFILE
, &rl
) >= 0);
207 for (fd
= 3; fd
< (int) rl
.rlim_max
; fd
++) {
209 if (fd_in_set(fd
, except
, n_except
))
212 if (close_nointr(fd
) < 0)
213 if (errno
!= EBADF
&& r
== 0)
220 while ((de
= readdir(d
))) {
223 if (hidden_file(de
->d_name
))
226 if (safe_atoi(de
->d_name
, &fd
) < 0)
227 /* Let's better ignore this, just in case */
236 if (fd_in_set(fd
, except
, n_except
))
239 if (close_nointr(fd
) < 0) {
240 /* Valgrind has its own FD and doesn't want to have it closed */
241 if (errno
!= EBADF
&& r
== 0)
249 int same_fd(int a
, int b
) {
250 struct stat sta
, stb
;
257 /* Compares two file descriptors. Note that semantics are
258 * quite different depending on whether we have kcmp() or we
259 * don't. If we have kcmp() this will only return true for
260 * dup()ed file descriptors, but not otherwise. If we don't
261 * have kcmp() this will also return true for two fds of the same
262 * file, created by separate open() calls. Since we use this
263 * call mostly for filtering out duplicates in the fd store
264 * this difference hopefully doesn't matter too much. */
269 /* Try to use kcmp() if we have it. */
271 r
= kcmp(pid
, pid
, KCMP_FILE
, a
, b
);
279 /* We don't have kcmp(), use fstat() instead. */
280 if (fstat(a
, &sta
) < 0)
283 if (fstat(b
, &stb
) < 0)
286 if ((sta
.st_mode
& S_IFMT
) != (stb
.st_mode
& S_IFMT
))
289 /* We consider all device fds different, since two device fds
290 * might refer to quite different device contexts even though
291 * they share the same inode and backing dev_t. */
293 if (S_ISCHR(sta
.st_mode
) || S_ISBLK(sta
.st_mode
))
296 if (sta
.st_dev
!= stb
.st_dev
|| sta
.st_ino
!= stb
.st_ino
)
299 /* The fds refer to the same inode on disk, let's also check
300 * if they have the same fd flags. This is useful to
301 * distinguish the read and write side of a pipe created with
303 fa
= fcntl(a
, F_GETFL
);
307 fb
= fcntl(b
, F_GETFL
);
314 void cmsg_close_all(struct msghdr
*mh
) {
315 struct cmsghdr
*cmsg
;
319 CMSG_FOREACH(cmsg
, mh
)
320 if (cmsg
->cmsg_level
== SOL_SOCKET
&& cmsg
->cmsg_type
== SCM_RIGHTS
)
321 close_many((int*) CMSG_DATA(cmsg
), (cmsg
->cmsg_len
- CMSG_LEN(0)) / sizeof(int));