chiark / gitweb /
service: handle services with racy daemonization gracefully
[elogind.git] / src / logind-acl.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2011 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2 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   General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <assert.h>
23 #include <sys/acl.h>
24 #include <acl/libacl.h>
25 #include <errno.h>
26 #include <string.h>
27
28 #include "logind-acl.h"
29 #include "util.h"
30
31 static int find_acl(acl_t acl, uid_t uid, acl_entry_t *entry) {
32         acl_entry_t i;
33         int found;
34
35         assert(acl);
36         assert(entry);
37
38         for (found = acl_get_entry(acl, ACL_FIRST_ENTRY, &i);
39              found > 0;
40              found = acl_get_entry(acl, ACL_NEXT_ENTRY, &i)) {
41
42                 acl_tag_t tag;
43                 uid_t *u;
44                 bool b;
45
46                 if (acl_get_tag_type(i, &tag) < 0)
47                         return -errno;
48
49                 if (tag != ACL_USER)
50                         continue;
51
52                 u = acl_get_qualifier(i);
53                 if (!u)
54                         return -errno;
55
56                 b = *u == uid;
57                 acl_free(u);
58
59                 if (b) {
60                         *entry = i;
61                         return 1;
62                 }
63         }
64
65         if (found < 0)
66                 return -errno;
67
68         return 0;
69 }
70
71 static int flush_acl(acl_t acl) {
72         acl_entry_t i;
73         int found;
74         bool changed = false;
75
76         assert(acl);
77
78         for (found = acl_get_entry(acl, ACL_FIRST_ENTRY, &i);
79              found > 0;
80              found = acl_get_entry(acl, ACL_NEXT_ENTRY, &i)) {
81
82                 acl_tag_t tag;
83
84                 if (acl_get_tag_type(i, &tag) < 0)
85                         return -errno;
86
87                 if (tag != ACL_USER)
88                         continue;
89
90                 if (acl_delete_entry(acl, i) < 0)
91                         return -errno;
92
93                 changed = true;
94         }
95
96         if (found < 0)
97                 return -errno;
98
99         return changed;
100 }
101
102 int devnode_acl(const char *path,
103                 bool flush,
104                 bool del, uid_t old_uid,
105                 bool add, uid_t new_uid) {
106
107         acl_t acl;
108         int r = 0;
109         bool changed = false;
110
111         assert(path);
112
113         acl = acl_get_file(path, ACL_TYPE_ACCESS);
114         if (!acl)
115                 return -errno;
116
117         if (flush) {
118
119                 r = flush_acl(acl);
120                 if (r < 0)
121                         goto finish;
122                 if (r > 0)
123                         changed = true;
124
125         } else if (del && old_uid > 0) {
126                 acl_entry_t entry;
127
128                 r = find_acl(acl, old_uid, &entry);
129                 if (r < 0)
130                         goto finish;
131
132                 if (r > 0) {
133                         if (acl_delete_entry(acl, entry) < 0) {
134                                 r = -errno;
135                                 goto finish;
136                         }
137
138                         changed = true;
139                 }
140         }
141
142         if (add && new_uid > 0) {
143                 acl_entry_t entry;
144                 acl_permset_t permset;
145                 int rd, wt;
146
147                 r = find_acl(acl, new_uid, &entry);
148                 if (r < 0)
149                         goto finish;
150
151                 if (r == 0) {
152                         if (acl_create_entry(&acl, &entry) < 0) {
153                                 r = -errno;
154                                 goto finish;
155                         }
156
157                         if (acl_set_tag_type(entry, ACL_USER) < 0 ||
158                             acl_set_qualifier(entry, &new_uid) < 0) {
159                                 r = -errno;
160                                 goto finish;
161                         }
162                 }
163
164                 if (acl_get_permset(entry, &permset) < 0) {
165                         r = -errno;
166                         goto finish;
167                 }
168
169                 rd = acl_get_perm(permset, ACL_READ);
170                 if (rd < 0) {
171                         r = -errno;
172                         goto finish;
173                 }
174
175                 wt = acl_get_perm(permset, ACL_WRITE);
176                 if (wt < 0) {
177                         r = -errno;
178                         goto finish;
179                 }
180
181                 if (!rd || !wt) {
182
183                         if (acl_add_perm(permset, ACL_READ|ACL_WRITE) < 0) {
184                                 r = -errno;
185                                 goto finish;
186                         }
187
188                         changed = true;
189                 }
190         }
191
192         if (!changed)
193                 goto finish;
194
195         if (acl_calc_mask(&acl) < 0) {
196                 r = -errno;
197                 goto finish;
198         }
199
200         if (acl_set_file(path, ACL_TYPE_ACCESS, acl) < 0) {
201                 r = -errno;
202                 goto finish;
203         }
204
205         r = 0;
206
207 finish:
208         acl_free(acl);
209
210         return r;
211 }
212
213 int devnode_acl_all(struct udev *udev,
214                     const char *seat,
215                     bool flush,
216                     bool del, uid_t old_uid,
217                     bool add, uid_t new_uid) {
218
219         struct udev_list_entry *item = NULL, *first = NULL;
220         struct udev_enumerate *e;
221         int r;
222
223         assert(udev);
224
225         if (isempty(seat))
226                 seat = "seat0";
227
228         e = udev_enumerate_new(udev);
229         if (!e)
230                 return -ENOMEM;
231
232         /* We can only match by one tag in libudev. We choose
233          * "uaccess" for that. If we could match for two tags here we
234          * could add the seat name as second match tag, but this would
235          * be hardly optimizable in libudev, and hence checking the
236          * second tag manually in our loop is a good solution. */
237
238         r = udev_enumerate_add_match_tag(e, "uaccess");
239         if (r < 0)
240                 goto finish;
241
242         r = udev_enumerate_scan_devices(e);
243         if (r < 0)
244                 goto finish;
245
246         first = udev_enumerate_get_list_entry(e);
247         udev_list_entry_foreach(item, first) {
248                 struct udev_device *d;
249                 const char *node, *sn;
250
251                 d = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
252                 if (!d) {
253                         r = -ENOMEM;
254                         goto finish;
255                 }
256
257                 sn = udev_device_get_property_value(d, "ID_SEAT");
258                 if (isempty(sn))
259                         sn = "seat0";
260
261                 if (!streq(seat, sn)) {
262                         udev_device_unref(d);
263                         continue;
264                 }
265
266                 node = udev_device_get_devnode(d);
267                 if (!node) {
268                         /* In case people mistag devices with nodes, we need to ignore this */
269                         udev_device_unref(d);
270                         continue;
271                 }
272
273                 log_debug("Fixing up %s for seat %s...", node, sn);
274
275                 r = devnode_acl(node, flush, del, old_uid, add, new_uid);
276                 udev_device_unref(d);
277
278                 if (r < 0)
279                         goto finish;
280         }
281
282 finish:
283         if (e)
284                 udev_enumerate_unref(e);
285
286         return r;
287 }