chiark / gitweb /
bus: actually, the kernel does enforce validity of bus names...
[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(trivial_hash_func, trivial_compare_func));
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                 close_nointr_nofail(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         DIR *d;
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         closedir(d);
154
155         /* We won't close the fds here! */
156         if (s)
157                 set_free(MAKE_SET(s));
158
159         return r;
160 }
161
162 int fdset_cloexec(FDSet *fds, bool b) {
163         Iterator i;
164         void *p;
165         int r;
166
167         assert(fds);
168
169         SET_FOREACH(p, MAKE_SET(fds), i)
170                 if ((r = fd_cloexec(PTR_TO_FD(p), b)) < 0)
171                         return r;
172
173         return 0;
174 }
175
176 int fdset_new_listen_fds(FDSet **_s, bool unset) {
177         int n, fd, r;
178         FDSet *s;
179
180         assert(_s);
181
182         /* Creates an fdset and fills in all passed file descriptors */
183
184         s = fdset_new();
185         if (!s) {
186                 r = -ENOMEM;
187                 goto fail;
188         }
189
190         n = sd_listen_fds(unset);
191         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
192                 r = fdset_put(s, fd);
193                 if (r < 0)
194                         goto fail;
195         }
196
197         *_s = s;
198         return 0;
199
200
201 fail:
202         if (s)
203                 set_free(MAKE_SET(s));
204
205         return r;
206 }
207
208 int fdset_close_others(FDSet *fds) {
209         void *e;
210         Iterator i;
211         int *a;
212         unsigned j, m;
213
214         j = 0, m = fdset_size(fds);
215         a = alloca(sizeof(int) * m);
216         SET_FOREACH(e, MAKE_SET(fds), i)
217                 a[j++] = PTR_TO_FD(e);
218
219         assert(j == m);
220
221         return close_all_fds(a, j);
222 }
223
224 unsigned fdset_size(FDSet *fds) {
225         return set_size(MAKE_SET(fds));
226 }
227
228 int fdset_iterate(FDSet *s, Iterator *i) {
229         void *p;
230
231         p = set_iterate(MAKE_SET(s), i);
232         if (!p)
233                 return -ENOENT;
234
235         return PTR_TO_FD(p);
236 }