]>
Commit | Line | Data |
---|---|---|
ea733a2f | 1 | /* |
0ec5b5e1 | 2 | * Copyright (C) 2003-2010 Kay Sievers <kay.sievers@vrfy.org> |
ea733a2f | 3 | * |
55e9959b KS |
4 | * This program is free software: you can redistribute it and/or modify |
5 | * it under the terms of the GNU General Public License as published by | |
6 | * the Free Software Foundation, either version 2 of the License, or | |
7 | * (at your option) any later version. | |
ea733a2f | 8 | * |
55e9959b KS |
9 | * This program is distributed in the hope that it will be useful, |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
ea733a2f GKH |
16 | */ |
17 | ||
18 | #include <stdlib.h> | |
19 | #include <string.h> | |
20 | #include <stdio.h> | |
1aa1e248 | 21 | #include <stddef.h> |
6c29f2b9 | 22 | #include <stdbool.h> |
ea733a2f GKH |
23 | #include <fcntl.h> |
24 | #include <unistd.h> | |
25 | #include <errno.h> | |
67f69ae1 | 26 | #include <grp.h> |
24f0605c | 27 | #include <dirent.h> |
56073914 | 28 | #include <sys/time.h> |
32ff5bca | 29 | #include <sys/stat.h> |
10950dfe | 30 | #include <sys/types.h> |
ea733a2f GKH |
31 | |
32 | #include "udev.h" | |
9825617b | 33 | |
912541b0 | 34 | #define TMP_FILE_EXT ".udev-tmp" |
ea733a2f | 35 | |
aa8734ff | 36 | static int node_symlink(struct udev *udev, const char *node, const char *slink) |
fa33d857 | 37 | { |
912541b0 KS |
38 | struct stat stats; |
39 | char target[UTIL_PATH_SIZE]; | |
40 | char *s; | |
41 | size_t l; | |
42 | char slink_tmp[UTIL_PATH_SIZE + sizeof(TMP_FILE_EXT)]; | |
43 | int i = 0; | |
44 | int tail = 0; | |
45 | int err = 0; | |
46 | ||
47 | /* use relative link */ | |
48 | target[0] = '\0'; | |
49 | while (node[i] && (node[i] == slink[i])) { | |
50 | if (node[i] == '/') | |
51 | tail = i+1; | |
52 | i++; | |
53 | } | |
54 | s = target; | |
55 | l = sizeof(target); | |
56 | while (slink[i] != '\0') { | |
57 | if (slink[i] == '/') | |
58 | l = util_strpcpy(&s, l, "../"); | |
59 | i++; | |
60 | } | |
61 | l = util_strscpy(s, l, &node[tail]); | |
62 | if (l == 0) { | |
63 | err = -EINVAL; | |
64 | goto exit; | |
65 | } | |
66 | ||
67 | /* preserve link with correct target, do not replace node of other device */ | |
68 | if (lstat(slink, &stats) == 0) { | |
69 | if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode)) { | |
70 | struct stat stats2; | |
71 | ||
baa30fbc | 72 | log_debug("found existing node instead of symlink '%s'\n", slink); |
912541b0 KS |
73 | if (lstat(node, &stats2) == 0) { |
74 | if ((stats.st_mode & S_IFMT) == (stats2.st_mode & S_IFMT) && | |
75 | stats.st_rdev == stats2.st_rdev && stats.st_ino != stats2.st_ino) { | |
baa30fbc | 76 | log_debug("replace device node '%s' with symlink to our node '%s'\n", |
912541b0 KS |
77 | slink, node); |
78 | } else { | |
baa30fbc | 79 | log_error("device node '%s' already exists, " |
912541b0 KS |
80 | "link to '%s' will not overwrite it\n", |
81 | slink, node); | |
82 | goto exit; | |
83 | } | |
84 | } | |
85 | } else if (S_ISLNK(stats.st_mode)) { | |
86 | char buf[UTIL_PATH_SIZE]; | |
87 | int len; | |
88 | ||
912541b0 KS |
89 | len = readlink(slink, buf, sizeof(buf)); |
90 | if (len > 0 && len < (int)sizeof(buf)) { | |
91 | buf[len] = '\0'; | |
92 | if (strcmp(target, buf) == 0) { | |
baa30fbc | 93 | log_debug("preserve already existing symlink '%s' to '%s'\n", slink, target); |
912541b0 KS |
94 | udev_selinux_lsetfilecon(udev, slink, S_IFLNK); |
95 | utimensat(AT_FDCWD, slink, NULL, AT_SYMLINK_NOFOLLOW); | |
96 | goto exit; | |
97 | } | |
98 | } | |
99 | } | |
100 | } else { | |
baa30fbc | 101 | log_debug("creating symlink '%s' to '%s'\n", slink, target); |
912541b0 KS |
102 | do { |
103 | err = util_create_path_selinux(udev, slink); | |
104 | if (err != 0 && err != -ENOENT) | |
105 | break; | |
106 | udev_selinux_setfscreatecon(udev, slink, S_IFLNK); | |
107 | err = symlink(target, slink); | |
108 | if (err != 0) | |
109 | err = -errno; | |
110 | udev_selinux_resetfscreatecon(udev); | |
111 | } while (err == -ENOENT); | |
112 | if (err == 0) | |
113 | goto exit; | |
114 | } | |
115 | ||
baa30fbc | 116 | log_debug("atomically replace '%s'\n", slink); |
912541b0 KS |
117 | util_strscpyl(slink_tmp, sizeof(slink_tmp), slink, TMP_FILE_EXT, NULL); |
118 | unlink(slink_tmp); | |
119 | do { | |
120 | err = util_create_path_selinux(udev, slink_tmp); | |
121 | if (err != 0 && err != -ENOENT) | |
122 | break; | |
123 | udev_selinux_setfscreatecon(udev, slink_tmp, S_IFLNK); | |
124 | err = symlink(target, slink_tmp); | |
125 | if (err != 0) | |
126 | err = -errno; | |
127 | udev_selinux_resetfscreatecon(udev); | |
128 | } while (err == -ENOENT); | |
129 | if (err != 0) { | |
baa30fbc | 130 | log_error("symlink '%s' '%s' failed: %m\n", target, slink_tmp); |
912541b0 KS |
131 | goto exit; |
132 | } | |
133 | err = rename(slink_tmp, slink); | |
134 | if (err != 0) { | |
baa30fbc | 135 | log_error("rename '%s' '%s' failed: %m\n", slink_tmp, slink); |
912541b0 KS |
136 | unlink(slink_tmp); |
137 | } | |
fa33d857 | 138 | exit: |
912541b0 | 139 | return err; |
fa33d857 KS |
140 | } |
141 | ||
6c29f2b9 KS |
142 | /* find device node of device with highest priority */ |
143 | static const char *link_find_prioritized(struct udev_device *dev, bool add, const char *stackdir, char *buf, size_t bufsize) | |
24f0605c | 144 | { |
912541b0 KS |
145 | struct udev *udev = udev_device_get_udev(dev); |
146 | DIR *dir; | |
147 | int priority = 0; | |
148 | const char *target = NULL; | |
149 | ||
150 | if (add) { | |
151 | priority = udev_device_get_devlink_priority(dev); | |
152 | util_strscpy(buf, bufsize, udev_device_get_devnode(dev)); | |
153 | target = buf; | |
154 | } | |
155 | ||
156 | dir = opendir(stackdir); | |
157 | if (dir == NULL) | |
158 | return target; | |
159 | for (;;) { | |
160 | struct udev_device *dev_db; | |
161 | struct dirent *dent; | |
162 | ||
163 | dent = readdir(dir); | |
164 | if (dent == NULL || dent->d_name[0] == '\0') | |
165 | break; | |
166 | if (dent->d_name[0] == '.') | |
167 | continue; | |
168 | ||
baa30fbc | 169 | log_debug("found '%s' claiming '%s'\n", dent->d_name, stackdir); |
912541b0 KS |
170 | |
171 | /* did we find ourself? */ | |
172 | if (strcmp(dent->d_name, udev_device_get_id_filename(dev)) == 0) | |
173 | continue; | |
174 | ||
175 | dev_db = udev_device_new_from_id_filename(udev, dent->d_name); | |
176 | if (dev_db != NULL) { | |
177 | const char *devnode; | |
178 | ||
179 | devnode = udev_device_get_devnode(dev_db); | |
180 | if (devnode != NULL) { | |
912541b0 | 181 | if (target == NULL || udev_device_get_devlink_priority(dev_db) > priority) { |
baa30fbc KS |
182 | log_debug("'%s' claims priority %i for '%s'\n", |
183 | udev_device_get_syspath(dev_db), udev_device_get_devlink_priority(dev_db), stackdir); | |
912541b0 KS |
184 | priority = udev_device_get_devlink_priority(dev_db); |
185 | util_strscpy(buf, bufsize, devnode); | |
186 | target = buf; | |
187 | } | |
188 | } | |
189 | udev_device_unref(dev_db); | |
190 | } | |
191 | } | |
192 | closedir(dir); | |
193 | return target; | |
aa8734ff KS |
194 | } |
195 | ||
6c29f2b9 KS |
196 | /* manage "stack of names" with possibly specified device priorities */ |
197 | static void link_update(struct udev_device *dev, const char *slink, bool add) | |
aa8734ff | 198 | { |
912541b0 KS |
199 | struct udev *udev = udev_device_get_udev(dev); |
200 | char name_enc[UTIL_PATH_SIZE]; | |
201 | char filename[UTIL_PATH_SIZE * 2]; | |
202 | char dirname[UTIL_PATH_SIZE]; | |
203 | const char *target; | |
204 | char buf[UTIL_PATH_SIZE]; | |
205 | ||
912541b0 KS |
206 | util_path_encode(&slink[strlen(udev_get_dev_path(udev))+1], name_enc, sizeof(name_enc)); |
207 | util_strscpyl(dirname, sizeof(dirname), udev_get_run_path(udev), "/links/", name_enc, NULL); | |
208 | util_strscpyl(filename, sizeof(filename), dirname, "/", udev_device_get_id_filename(dev), NULL); | |
209 | ||
baa30fbc KS |
210 | if (!add && unlink(filename) == 0) |
211 | rmdir(dirname); | |
912541b0 KS |
212 | |
213 | target = link_find_prioritized(dev, add, dirname, buf, sizeof(buf)); | |
214 | if (target == NULL) { | |
baa30fbc | 215 | log_debug("no reference left, remove '%s'\n", slink); |
912541b0 KS |
216 | if (unlink(slink) == 0) |
217 | util_delete_path(udev, slink); | |
218 | } else { | |
baa30fbc | 219 | log_debug("creating link '%s' to '%s'\n", slink, target); |
912541b0 KS |
220 | node_symlink(udev, target, slink); |
221 | } | |
222 | ||
223 | if (add) { | |
224 | int err; | |
225 | ||
912541b0 KS |
226 | do { |
227 | int fd; | |
228 | ||
229 | err = util_create_path(udev, filename); | |
230 | if (err != 0 && err != -ENOENT) | |
231 | break; | |
232 | fd = open(filename, O_WRONLY|O_CREAT|O_CLOEXEC|O_TRUNC|O_NOFOLLOW, 0444); | |
233 | if (fd >= 0) | |
234 | close(fd); | |
235 | else | |
236 | err = -errno; | |
237 | } while (err == -ENOENT); | |
238 | } | |
24f0605c KS |
239 | } |
240 | ||
ec2dd02e | 241 | void udev_node_update_old_links(struct udev_device *dev, struct udev_device *dev_old) |
24f0605c | 242 | { |
912541b0 KS |
243 | struct udev *udev = udev_device_get_udev(dev); |
244 | struct udev_list_entry *list_entry; | |
245 | ||
246 | /* update possible left-over symlinks */ | |
247 | udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev_old)) { | |
248 | const char *name = udev_list_entry_get_name(list_entry); | |
249 | struct udev_list_entry *list_entry_current; | |
250 | int found; | |
251 | ||
252 | /* check if old link name still belongs to this device */ | |
253 | found = 0; | |
254 | udev_list_entry_foreach(list_entry_current, udev_device_get_devlinks_list_entry(dev)) { | |
255 | const char *name_current = udev_list_entry_get_name(list_entry_current); | |
256 | ||
257 | if (strcmp(name, name_current) == 0) { | |
258 | found = 1; | |
259 | break; | |
260 | } | |
261 | } | |
262 | if (found) | |
263 | continue; | |
264 | ||
baa30fbc | 265 | log_debug("update old name, '%s' no longer belonging to '%s'\n", |
912541b0 KS |
266 | name, udev_device_get_devpath(dev)); |
267 | link_update(dev, name, 0); | |
268 | } | |
24f0605c KS |
269 | } |
270 | ||
220893b3 KS |
271 | static int node_fixup(struct udev_device *dev, mode_t mode, uid_t uid, gid_t gid) |
272 | { | |
912541b0 KS |
273 | struct udev *udev = udev_device_get_udev(dev); |
274 | const char *devnode = udev_device_get_devnode(dev); | |
275 | dev_t devnum = udev_device_get_devnum(dev); | |
276 | struct stat stats; | |
277 | int err = 0; | |
278 | ||
279 | if (strcmp(udev_device_get_subsystem(dev), "block") == 0) | |
280 | mode |= S_IFBLK; | |
281 | else | |
282 | mode |= S_IFCHR; | |
283 | ||
284 | if (lstat(devnode, &stats) != 0) { | |
285 | err = -errno; | |
baa30fbc | 286 | log_debug("can not stat() node '%s' (%m)\n", devnode); |
912541b0 KS |
287 | goto out; |
288 | } | |
289 | ||
290 | if (((stats.st_mode & S_IFMT) != (mode & S_IFMT)) || (stats.st_rdev != devnum)) { | |
291 | err = -EEXIST; | |
baa30fbc KS |
292 | log_debug("found node '%s' with non-matching devnum %s, skip handling\n", |
293 | udev_device_get_devnode(dev), udev_device_get_id_filename(dev)); | |
912541b0 KS |
294 | goto out; |
295 | } | |
296 | ||
297 | if ((stats.st_mode & 0777) != (mode & 0777) || stats.st_uid != uid || stats.st_gid != gid) { | |
baa30fbc | 298 | log_debug("set permissions %s, %#o, uid=%u, gid=%u\n", devnode, mode, uid, gid); |
912541b0 KS |
299 | chmod(devnode, mode); |
300 | chown(devnode, uid, gid); | |
301 | } else { | |
baa30fbc | 302 | log_debug("preserve permissions %s, %#o, uid=%u, gid=%u\n", devnode, mode, uid, gid); |
912541b0 KS |
303 | } |
304 | ||
305 | /* | |
306 | * Set initial selinux file context only on add events. | |
307 | * We set the proper context on bootup (triger) or for newly | |
308 | * added devices, but we don't change it later, in case | |
309 | * something else has set a custom context in the meantime. | |
310 | */ | |
311 | if (strcmp(udev_device_get_action(dev), "add") == 0) | |
312 | udev_selinux_lsetfilecon(udev, devnode, mode); | |
313 | ||
314 | /* always update timestamp when we re-use the node, like on media change events */ | |
315 | utimensat(AT_FDCWD, devnode, NULL, 0); | |
220893b3 | 316 | out: |
912541b0 | 317 | return err; |
220893b3 KS |
318 | } |
319 | ||
e7f32890 | 320 | void udev_node_add(struct udev_device *dev, mode_t mode, uid_t uid, gid_t gid) |
97853b4f | 321 | { |
912541b0 KS |
322 | struct udev *udev = udev_device_get_udev(dev); |
323 | char filename[UTIL_PATH_SIZE]; | |
324 | struct udev_list_entry *list_entry; | |
325 | int err = 0; | |
326 | ||
baa30fbc KS |
327 | log_debug("handling device node '%s', devnum=%s, mode=%#o, uid=%d, gid=%d\n", |
328 | udev_device_get_devnode(dev), udev_device_get_id_filename(dev), mode, uid, gid); | |
912541b0 | 329 | |
e7f32890 KS |
330 | if (node_fixup(dev, mode, uid, gid) < 0) |
331 | return; | |
912541b0 KS |
332 | |
333 | /* always add /dev/{block,char}/$major:$minor */ | |
334 | snprintf(filename, sizeof(filename), "%s/%s/%u:%u", | |
335 | udev_get_dev_path(udev), | |
336 | strcmp(udev_device_get_subsystem(dev), "block") == 0 ? "block" : "char", | |
337 | major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev))); | |
338 | node_symlink(udev, udev_device_get_devnode(dev), filename); | |
339 | ||
340 | /* create/update symlinks, add symlinks to name index */ | |
341 | udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev)) { | |
342 | if (udev_list_entry_get_num(list_entry)) | |
343 | /* simple unmanaged link name */ | |
344 | node_symlink(udev, udev_device_get_devnode(dev), udev_list_entry_get_name(list_entry)); | |
345 | else | |
346 | link_update(dev, udev_list_entry_get_name(list_entry), 1); | |
347 | } | |
ea733a2f GKH |
348 | } |
349 | ||
e7f32890 | 350 | void udev_node_remove(struct udev_device *dev) |
ff9a488d | 351 | { |
912541b0 KS |
352 | struct udev *udev = udev_device_get_udev(dev); |
353 | struct udev_list_entry *list_entry; | |
354 | const char *devnode; | |
355 | struct stat stats; | |
356 | struct udev_device *dev_check; | |
357 | char filename[UTIL_PATH_SIZE]; | |
912541b0 KS |
358 | |
359 | /* remove/update symlinks, remove symlinks from name index */ | |
360 | udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev)) | |
361 | link_update(dev, udev_list_entry_get_name(list_entry), 0); | |
362 | ||
363 | /* remove /dev/{block,char}/$major:$minor */ | |
364 | snprintf(filename, sizeof(filename), "%s/%s/%u:%u", | |
365 | udev_get_dev_path(udev), | |
366 | strcmp(udev_device_get_subsystem(dev), "block") == 0 ? "block" : "char", | |
367 | major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev))); | |
368 | unlink(filename); | |
ea733a2f | 369 | } |