]>
Commit | Line | Data |
---|---|---|
e7145211 | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
ea733a2f | 2 | |
07630cea LP |
3 | #include <errno.h> |
4 | #include <fcntl.h> | |
5 | #include <stdbool.h> | |
6 | #include <stddef.h> | |
7 | #include <stdio.h> | |
8 | #include <string.h> | |
32ff5bca | 9 | #include <sys/stat.h> |
07630cea | 10 | #include <unistd.h> |
ea733a2f | 11 | |
c67f84b0 | 12 | #include "device-nodes.h" |
8fb3f009 | 13 | #include "dirent-util.h" |
f97b34a6 | 14 | #include "format-util.h" |
f4f15635 | 15 | #include "fs-util.h" |
07630cea LP |
16 | #include "selinux-util.h" |
17 | #include "smack-util.h" | |
d054f0a4 | 18 | #include "stdio-util.h" |
07630cea LP |
19 | #include "string-util.h" |
20 | #include "udev.h" | |
9825617b | 21 | |
9ec6e95b | 22 | static int node_symlink(struct udev_device *dev, const char *node, const char *slink) { |
912541b0 KS |
23 | struct stat stats; |
24 | char target[UTIL_PATH_SIZE]; | |
25 | char *s; | |
26 | size_t l; | |
38d70045 | 27 | char slink_tmp[UTIL_PATH_SIZE + 32]; |
912541b0 KS |
28 | int i = 0; |
29 | int tail = 0; | |
30 | int err = 0; | |
31 | ||
32 | /* use relative link */ | |
33 | target[0] = '\0'; | |
34 | while (node[i] && (node[i] == slink[i])) { | |
35 | if (node[i] == '/') | |
36 | tail = i+1; | |
37 | i++; | |
38 | } | |
39 | s = target; | |
40 | l = sizeof(target); | |
41 | while (slink[i] != '\0') { | |
42 | if (slink[i] == '/') | |
d5a89d7d | 43 | l = strpcpy(&s, l, "../"); |
912541b0 KS |
44 | i++; |
45 | } | |
d5a89d7d | 46 | l = strscpy(s, l, &node[tail]); |
912541b0 KS |
47 | if (l == 0) { |
48 | err = -EINVAL; | |
49 | goto exit; | |
50 | } | |
51 | ||
52 | /* preserve link with correct target, do not replace node of other device */ | |
53 | if (lstat(slink, &stats) == 0) { | |
54 | if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode)) { | |
9f6445e3 | 55 | log_error("conflicting device node '%s' found, link to '%s' will not be created", slink, node); |
2be7287b | 56 | goto exit; |
912541b0 KS |
57 | } else if (S_ISLNK(stats.st_mode)) { |
58 | char buf[UTIL_PATH_SIZE]; | |
59 | int len; | |
60 | ||
912541b0 KS |
61 | len = readlink(slink, buf, sizeof(buf)); |
62 | if (len > 0 && len < (int)sizeof(buf)) { | |
63 | buf[len] = '\0'; | |
090be865 | 64 | if (streq(target, buf)) { |
9f6445e3 | 65 | log_debug("preserve already existing symlink '%s' to '%s'", slink, target); |
08c84981 | 66 | (void) label_fix(slink, LABEL_IGNORE_ENOENT); |
912541b0 KS |
67 | utimensat(AT_FDCWD, slink, NULL, AT_SYMLINK_NOFOLLOW); |
68 | goto exit; | |
69 | } | |
70 | } | |
71 | } | |
72 | } else { | |
9f6445e3 | 73 | log_debug("creating symlink '%s' to '%s'", slink, target); |
912541b0 | 74 | do { |
d2e54fae | 75 | err = mkdir_parents_label(slink, 0755); |
4c701096 | 76 | if (!IN_SET(err, 0, -ENOENT)) |
912541b0 | 77 | break; |
ecabcf8b | 78 | mac_selinux_create_file_prepare(slink, S_IFLNK); |
912541b0 KS |
79 | err = symlink(target, slink); |
80 | if (err != 0) | |
81 | err = -errno; | |
ecabcf8b | 82 | mac_selinux_create_file_clear(); |
912541b0 KS |
83 | } while (err == -ENOENT); |
84 | if (err == 0) | |
85 | goto exit; | |
86 | } | |
87 | ||
9f6445e3 | 88 | log_debug("atomically replace '%s'", slink); |
38d70045 | 89 | strscpyl(slink_tmp, sizeof(slink_tmp), slink, ".tmp-", udev_device_get_id_filename(dev), NULL); |
912541b0 KS |
90 | unlink(slink_tmp); |
91 | do { | |
d2e54fae | 92 | err = mkdir_parents_label(slink_tmp, 0755); |
4c701096 | 93 | if (!IN_SET(err, 0, -ENOENT)) |
912541b0 | 94 | break; |
ecabcf8b | 95 | mac_selinux_create_file_prepare(slink_tmp, S_IFLNK); |
912541b0 KS |
96 | err = symlink(target, slink_tmp); |
97 | if (err != 0) | |
98 | err = -errno; | |
ecabcf8b | 99 | mac_selinux_create_file_clear(); |
912541b0 KS |
100 | } while (err == -ENOENT); |
101 | if (err != 0) { | |
56f64d95 | 102 | log_error_errno(errno, "symlink '%s' '%s' failed: %m", target, slink_tmp); |
912541b0 KS |
103 | goto exit; |
104 | } | |
105 | err = rename(slink_tmp, slink); | |
106 | if (err != 0) { | |
56f64d95 | 107 | log_error_errno(errno, "rename '%s' '%s' failed: %m", slink_tmp, slink); |
912541b0 KS |
108 | unlink(slink_tmp); |
109 | } | |
fa33d857 | 110 | exit: |
912541b0 | 111 | return err; |
fa33d857 KS |
112 | } |
113 | ||
6c29f2b9 | 114 | /* find device node of device with highest priority */ |
9ec6e95b | 115 | static const char *link_find_prioritized(struct udev_device *dev, bool add, const char *stackdir, char *buf, size_t bufsize) { |
912541b0 KS |
116 | struct udev *udev = udev_device_get_udev(dev); |
117 | DIR *dir; | |
8fb3f009 | 118 | struct dirent *dent; |
912541b0 KS |
119 | int priority = 0; |
120 | const char *target = NULL; | |
121 | ||
122 | if (add) { | |
123 | priority = udev_device_get_devlink_priority(dev); | |
d5a89d7d | 124 | strscpy(buf, bufsize, udev_device_get_devnode(dev)); |
912541b0 KS |
125 | target = buf; |
126 | } | |
127 | ||
128 | dir = opendir(stackdir); | |
129 | if (dir == NULL) | |
130 | return target; | |
8fb3f009 | 131 | FOREACH_DIRENT_ALL(dent, dir, break) { |
912541b0 | 132 | struct udev_device *dev_db; |
912541b0 | 133 | |
8fb3f009 | 134 | if (dent->d_name[0] == '\0') |
912541b0 KS |
135 | break; |
136 | if (dent->d_name[0] == '.') | |
137 | continue; | |
138 | ||
9f6445e3 | 139 | log_debug("found '%s' claiming '%s'", dent->d_name, stackdir); |
912541b0 KS |
140 | |
141 | /* did we find ourself? */ | |
090be865 | 142 | if (streq(dent->d_name, udev_device_get_id_filename(dev))) |
912541b0 KS |
143 | continue; |
144 | ||
dbf61afb | 145 | dev_db = udev_device_new_from_device_id(udev, dent->d_name); |
912541b0 KS |
146 | if (dev_db != NULL) { |
147 | const char *devnode; | |
148 | ||
149 | devnode = udev_device_get_devnode(dev_db); | |
150 | if (devnode != NULL) { | |
912541b0 | 151 | if (target == NULL || udev_device_get_devlink_priority(dev_db) > priority) { |
9f6445e3 | 152 | log_debug("'%s' claims priority %i for '%s'", |
baa30fbc | 153 | udev_device_get_syspath(dev_db), udev_device_get_devlink_priority(dev_db), stackdir); |
912541b0 | 154 | priority = udev_device_get_devlink_priority(dev_db); |
d5a89d7d | 155 | strscpy(buf, bufsize, devnode); |
912541b0 KS |
156 | target = buf; |
157 | } | |
158 | } | |
159 | udev_device_unref(dev_db); | |
160 | } | |
161 | } | |
162 | closedir(dir); | |
163 | return target; | |
aa8734ff KS |
164 | } |
165 | ||
6c29f2b9 | 166 | /* manage "stack of names" with possibly specified device priorities */ |
9ec6e95b | 167 | static void link_update(struct udev_device *dev, const char *slink, bool add) { |
912541b0 KS |
168 | char name_enc[UTIL_PATH_SIZE]; |
169 | char filename[UTIL_PATH_SIZE * 2]; | |
170 | char dirname[UTIL_PATH_SIZE]; | |
171 | const char *target; | |
172 | char buf[UTIL_PATH_SIZE]; | |
173 | ||
fbd0b64f | 174 | util_path_encode(slink + STRLEN("/dev"), name_enc, sizeof(name_enc)); |
d5a89d7d KS |
175 | strscpyl(dirname, sizeof(dirname), "/run/udev/links/", name_enc, NULL); |
176 | strscpyl(filename, sizeof(filename), dirname, "/", udev_device_get_id_filename(dev), NULL); | |
912541b0 | 177 | |
baa30fbc KS |
178 | if (!add && unlink(filename) == 0) |
179 | rmdir(dirname); | |
912541b0 KS |
180 | |
181 | target = link_find_prioritized(dev, add, dirname, buf, sizeof(buf)); | |
182 | if (target == NULL) { | |
9f6445e3 | 183 | log_debug("no reference left, remove '%s'", slink); |
912541b0 | 184 | if (unlink(slink) == 0) |
37d52274 | 185 | rmdir_parents(slink, "/"); |
912541b0 | 186 | } else { |
9f6445e3 | 187 | log_debug("creating link '%s' to '%s'", slink, target); |
38d70045 | 188 | node_symlink(dev, target, slink); |
912541b0 KS |
189 | } |
190 | ||
191 | if (add) { | |
192 | int err; | |
193 | ||
912541b0 KS |
194 | do { |
195 | int fd; | |
196 | ||
3cbd5f6b | 197 | err = mkdir_parents(filename, 0755); |
4c701096 | 198 | if (!IN_SET(err, 0, -ENOENT)) |
912541b0 KS |
199 | break; |
200 | fd = open(filename, O_WRONLY|O_CREAT|O_CLOEXEC|O_TRUNC|O_NOFOLLOW, 0444); | |
201 | if (fd >= 0) | |
202 | close(fd); | |
203 | else | |
204 | err = -errno; | |
205 | } while (err == -ENOENT); | |
206 | } | |
24f0605c KS |
207 | } |
208 | ||
9ec6e95b | 209 | void udev_node_update_old_links(struct udev_device *dev, struct udev_device *dev_old) { |
912541b0 KS |
210 | struct udev_list_entry *list_entry; |
211 | ||
212 | /* update possible left-over symlinks */ | |
213 | udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev_old)) { | |
214 | const char *name = udev_list_entry_get_name(list_entry); | |
215 | struct udev_list_entry *list_entry_current; | |
216 | int found; | |
217 | ||
218 | /* check if old link name still belongs to this device */ | |
219 | found = 0; | |
220 | udev_list_entry_foreach(list_entry_current, udev_device_get_devlinks_list_entry(dev)) { | |
221 | const char *name_current = udev_list_entry_get_name(list_entry_current); | |
222 | ||
090be865 | 223 | if (streq(name, name_current)) { |
912541b0 KS |
224 | found = 1; |
225 | break; | |
226 | } | |
227 | } | |
228 | if (found) | |
229 | continue; | |
230 | ||
9f6445e3 | 231 | log_debug("update old name, '%s' no longer belonging to '%s'", |
912541b0 | 232 | name, udev_device_get_devpath(dev)); |
8a173387 | 233 | link_update(dev, name, false); |
912541b0 | 234 | } |
24f0605c KS |
235 | } |
236 | ||
c26547d6 KS |
237 | static int node_permissions_apply(struct udev_device *dev, bool apply, |
238 | mode_t mode, uid_t uid, gid_t gid, | |
239 | struct udev_list *seclabel_list) { | |
912541b0 KS |
240 | const char *devnode = udev_device_get_devnode(dev); |
241 | dev_t devnum = udev_device_get_devnum(dev); | |
242 | struct stat stats; | |
c26547d6 | 243 | struct udev_list_entry *entry; |
912541b0 KS |
244 | int err = 0; |
245 | ||
090be865 | 246 | if (streq(udev_device_get_subsystem(dev), "block")) |
912541b0 KS |
247 | mode |= S_IFBLK; |
248 | else | |
249 | mode |= S_IFCHR; | |
250 | ||
251 | if (lstat(devnode, &stats) != 0) { | |
87ac8d99 | 252 | err = log_debug_errno(errno, "cannot stat() node '%s' (%m)", devnode); |
912541b0 KS |
253 | goto out; |
254 | } | |
255 | ||
256 | if (((stats.st_mode & S_IFMT) != (mode & S_IFMT)) || (stats.st_rdev != devnum)) { | |
257 | err = -EEXIST; | |
9f6445e3 | 258 | log_debug("found node '%s' with non-matching devnum %s, skip handling", |
baa30fbc | 259 | udev_device_get_devnode(dev), udev_device_get_id_filename(dev)); |
912541b0 KS |
260 | goto out; |
261 | } | |
262 | ||
22582bb2 | 263 | if (apply) { |
b7e2b764 | 264 | bool selinux = false; |
b7e2b764 | 265 | bool smack = false; |
b7e2b764 | 266 | |
48a849ee | 267 | if ((stats.st_mode & 0777) != (mode & 0777) || stats.st_uid != uid || stats.st_gid != gid) { |
9f6445e3 | 268 | log_debug("set permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid); |
543afdc6 TG |
269 | err = chmod(devnode, mode); |
270 | if (err < 0) | |
56f64d95 | 271 | log_warning_errno(errno, "setting mode of %s to %#o failed: %m", devnode, mode); |
543afdc6 TG |
272 | err = chown(devnode, uid, gid); |
273 | if (err < 0) | |
56f64d95 | 274 | log_warning_errno(errno, "setting owner of %s to uid=%u, gid=%u failed: %m", devnode, uid, gid); |
48a849ee | 275 | } else { |
9f6445e3 | 276 | log_debug("preserve permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid); |
48a849ee | 277 | } |
c26547d6 | 278 | |
c26547d6 KS |
279 | /* apply SECLABEL{$module}=$label */ |
280 | udev_list_entry_foreach(entry, udev_list_get_entry(seclabel_list)) { | |
281 | const char *name, *label; | |
d53e386d | 282 | int r; |
c26547d6 KS |
283 | |
284 | name = udev_list_entry_get_name(entry); | |
285 | label = udev_list_entry_get_value(entry); | |
286 | ||
287 | if (streq(name, "selinux")) { | |
b7e2b764 | 288 | selinux = true; |
d53e386d | 289 | |
ecabcf8b LP |
290 | r = mac_selinux_apply(devnode, label); |
291 | if (r < 0) | |
da927ba9 | 292 | log_error_errno(r, "SECLABEL: failed to set SELinux label '%s': %m", label); |
463b5dbb KS |
293 | else |
294 | log_debug("SECLABEL: set SELinux label '%s'", label); | |
c26547d6 | 295 | |
9a4e038c | 296 | } else if (streq(name, "smack")) { |
b7e2b764 | 297 | smack = true; |
d53e386d | 298 | |
5ab58c20 | 299 | r = mac_smack_apply(devnode, SMACK_ATTR_ACCESS, label); |
d53e386d | 300 | if (r < 0) |
da927ba9 | 301 | log_error_errno(r, "SECLABEL: failed to set SMACK label '%s': %m", label); |
c26547d6 KS |
302 | else |
303 | log_debug("SECLABEL: set SMACK label '%s'", label); | |
c26547d6 KS |
304 | |
305 | } else | |
306 | log_error("SECLABEL: unknown subsystem, ignoring '%s'='%s'", name, label); | |
307 | } | |
b7e2b764 KS |
308 | |
309 | /* set the defaults */ | |
310 | if (!selinux) | |
08c84981 | 311 | (void) mac_selinux_fix(devnode, LABEL_IGNORE_ENOENT); |
9a4e038c | 312 | if (!smack) |
5ab58c20 | 313 | mac_smack_apply(devnode, SMACK_ATTR_ACCESS, NULL); |
48a849ee | 314 | } |
912541b0 KS |
315 | |
316 | /* always update timestamp when we re-use the node, like on media change events */ | |
317 | utimensat(AT_FDCWD, devnode, NULL, 0); | |
220893b3 | 318 | out: |
912541b0 | 319 | return err; |
220893b3 KS |
320 | } |
321 | ||
c26547d6 KS |
322 | void udev_node_add(struct udev_device *dev, bool apply, |
323 | mode_t mode, uid_t uid, gid_t gid, | |
324 | struct udev_list *seclabel_list) { | |
c67f84b0 | 325 | char filename[DEV_NUM_PATH_MAX]; |
912541b0 | 326 | struct udev_list_entry *list_entry; |
912541b0 | 327 | |
1fa2f38f | 328 | log_debug("handling device node '%s', devnum=%s, mode=%#o, uid="UID_FMT", gid="GID_FMT, |
baa30fbc | 329 | udev_device_get_devnode(dev), udev_device_get_id_filename(dev), mode, uid, gid); |
912541b0 | 330 | |
c26547d6 | 331 | if (node_permissions_apply(dev, apply, mode, uid, gid, seclabel_list) < 0) |
e7f32890 | 332 | return; |
912541b0 KS |
333 | |
334 | /* always add /dev/{block,char}/$major:$minor */ | |
c67f84b0 ZJS |
335 | xsprintf_dev_num_path(filename, |
336 | streq(udev_device_get_subsystem(dev), "block") ? "block" : "char", | |
337 | udev_device_get_devnum(dev)); | |
38d70045 | 338 | node_symlink(dev, udev_device_get_devnode(dev), filename); |
912541b0 KS |
339 | |
340 | /* create/update symlinks, add symlinks to name index */ | |
8a173387 KS |
341 | udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev)) |
342 | link_update(dev, udev_list_entry_get_name(list_entry), true); | |
ea733a2f GKH |
343 | } |
344 | ||
9ec6e95b | 345 | void udev_node_remove(struct udev_device *dev) { |
912541b0 | 346 | struct udev_list_entry *list_entry; |
c67f84b0 | 347 | char filename[DEV_NUM_PATH_MAX]; |
912541b0 KS |
348 | |
349 | /* remove/update symlinks, remove symlinks from name index */ | |
350 | udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev)) | |
8a173387 | 351 | link_update(dev, udev_list_entry_get_name(list_entry), false); |
912541b0 KS |
352 | |
353 | /* remove /dev/{block,char}/$major:$minor */ | |
c67f84b0 ZJS |
354 | xsprintf_dev_num_path(filename, |
355 | streq(udev_device_get_subsystem(dev), "block") ? "block" : "char", | |
356 | udev_device_get_devnum(dev)); | |
912541b0 | 357 | unlink(filename); |
ea733a2f | 358 | } |