chiark / gitweb /
sd-bus: catch up with current kdbus, don't do matches on kdbus monitor connections
[elogind.git] / src / shared / fdset.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
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.
12
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.
17
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/>.
20 ***/
21
22 #include <errno.h>
23 #include <dirent.h>
24 #include <fcntl.h>
25 #include <unistd.h>
26
27 #include "set.h"
28 #include "util.h"
29 #include "macro.h"
30 #include "fdset.h"
31 #include "sd-daemon.h"
32
33 #define MAKE_SET(s) ((Set*) s)
34 #define MAKE_FDSET(s) ((FDSet*) s)
35
36 /* Make sure we can distuingish fd 0 and NULL */
37 #define FD_TO_PTR(fd) INT_TO_PTR((fd)+1)
38 #define PTR_TO_FD(p) (PTR_TO_INT(p)-1)
39
40 FDSet *fdset_new(void) {
41         return MAKE_FDSET(set_new(NULL));
42 }
43
44 void fdset_free(FDSet *s) {
45         void *p;
46
47         while ((p = set_steal_first(MAKE_SET(s)))) {
48                 /* Valgrind's fd might have ended up in this set here,
49                  * due to fdset_new_fill(). We'll ignore all failures
50                  * here, so that the EBADFD that valgrind will return
51                  * us on close() doesn't influence us */
52
53                 /* When reloading duplicates of the private bus
54                  * connection fds and suchlike are closed here, which
55                  * has no effect at all, since they are only
56                  * duplicates. So don't be surprised about these log
57                  * messages. */
58
59                 log_debug("Closing left-over fd %i", PTR_TO_FD(p));
60                 close_nointr(PTR_TO_FD(p));
61         }
62
63         set_free(MAKE_SET(s));
64 }
65
66 int fdset_put(FDSet *s, int fd) {
67         assert(s);
68         assert(fd >= 0);
69
70         return set_put(MAKE_SET(s), FD_TO_PTR(fd));
71 }
72
73 int fdset_put_dup(FDSet *s, int fd) {
74         int copy, r;
75
76         assert(s);
77         assert(fd >= 0);
78
79         copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
80         if (copy < 0)
81                 return -errno;
82
83         r = fdset_put(s, copy);
84         if (r < 0) {
85                 safe_close(copy);
86                 return r;
87         }
88
89         return copy;
90 }
91
92 bool fdset_contains(FDSet *s, int fd) {
93         assert(s);
94         assert(fd >= 0);
95
96         return !!set_get(MAKE_SET(s), FD_TO_PTR(fd));
97 }
98
99 int fdset_remove(FDSet *s, int fd) {
100         assert(s);
101         assert(fd >= 0);
102
103         return set_remove(MAKE_SET(s), FD_TO_PTR(fd)) ? fd : -ENOENT;
104 }
105
106 int fdset_new_fill(FDSet **_s) {
107         _cleanup_closedir_ DIR *d = NULL;
108         struct dirent *de;
109         int r = 0;
110         FDSet *s;
111
112         assert(_s);
113
114         /* Creates an fdset and fills in all currently open file
115          * descriptors. */
116
117         d = opendir("/proc/self/fd");
118         if (!d)
119                 return -errno;
120
121         s = fdset_new();
122         if (!s) {
123                 r = -ENOMEM;
124                 goto finish;
125         }
126
127         while ((de = readdir(d))) {
128                 int fd = -1;
129
130                 if (ignore_file(de->d_name))
131                         continue;
132
133                 r = safe_atoi(de->d_name, &fd);
134                 if (r < 0)
135                         goto finish;
136
137                 if (fd < 3)
138                         continue;
139
140                 if (fd == dirfd(d))
141                         continue;
142
143                 r = fdset_put(s, fd);
144                 if (r < 0)
145                         goto finish;
146         }
147
148         r = 0;
149         *_s = s;
150         s = NULL;
151
152 finish:
153         /* We won't close the fds here! */
154         if (s)
155                 set_free(MAKE_SET(s));
156
157         return r;
158 }
159
160 int fdset_cloexec(FDSet *fds, bool b) {
161         Iterator i;
162         void *p;
163         int r;
164
165         assert(fds);
166
167         SET_FOREACH(p, MAKE_SET(fds), i)
168                 if ((r = fd_cloexec(PTR_TO_FD(p), b)) < 0)
169                         return r;
170
171         return 0;
172 }
173
174 int fdset_new_listen_fds(FDSet **_s, bool unset) {
175         int n, fd, r;
176         FDSet *s;
177
178         assert(_s);
179
180         /* Creates an fdset and fills in all passed file descriptors */
181
182         s = fdset_new();
183         if (!s) {
184                 r = -ENOMEM;
185                 goto fail;
186         }
187
188         n = sd_listen_fds(unset);
189         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
190                 r = fdset_put(s, fd);
191                 if (r < 0)
192                         goto fail;
193         }
194
195         *_s = s;
196         return 0;
197
198
199 fail:
200         if (s)
201                 set_free(MAKE_SET(s));
202
203         return r;
204 }
205
206 int fdset_close_others(FDSet *fds) {
207         void *e;
208         Iterator i;
209         int *a;
210         unsigned j, m;
211
212         j = 0, m = fdset_size(fds);
213         a = alloca(sizeof(int) * m);
214         SET_FOREACH(e, MAKE_SET(fds), i)
215                 a[j++] = PTR_TO_FD(e);
216
217         assert(j == m);
218
219         return close_all_fds(a, j);
220 }
221
222 unsigned fdset_size(FDSet *fds) {
223         return set_size(MAKE_SET(fds));
224 }
225
226 int fdset_iterate(FDSet *s, Iterator *i) {
227         void *p;
228
229         p = set_iterate(MAKE_SET(s), i);
230         if (!p)
231                 return -ENOENT;
232
233         return PTR_TO_FD(p);
234 }