]>
Commit | Line | Data |
---|---|---|
ea733a2f GKH |
1 | /* |
2 | * udev-add.c | |
3 | * | |
4 | * Userspace devfs | |
5 | * | |
6 | * Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com> | |
7 | * | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify it | |
10 | * under the terms of the GNU General Public License as published by the | |
11 | * Free Software Foundation version 2 of the License. | |
12 | * | |
13 | * This program 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 along | |
19 | * with this program; if not, write to the Free Software Foundation, Inc., | |
20 | * 675 Mass Ave, Cambridge, MA 02139, USA. | |
21 | * | |
22 | */ | |
23 | ||
24 | #include <stdlib.h> | |
25 | #include <string.h> | |
26 | #include <stdio.h> | |
27 | #include <fcntl.h> | |
28 | #include <unistd.h> | |
29 | #include <errno.h> | |
32ff5bca | 30 | #include <sys/stat.h> |
10950dfe GKH |
31 | #include <sys/types.h> |
32 | #include <grp.h> | |
f61d732a KS |
33 | #include <net/if.h> |
34 | #include <sys/socket.h> | |
35 | #include <sys/ioctl.h> | |
36 | #include <linux/sockios.h> | |
10950dfe GKH |
37 | #ifndef __KLIBC__ |
38 | #include <pwd.h> | |
534c853d | 39 | #include <utmp.h> |
10950dfe | 40 | #endif |
ea733a2f | 41 | |
c80da508 | 42 | #include "libsysfs/sysfs/libsysfs.h" |
ea733a2f | 43 | #include "udev.h" |
c81b35c0 | 44 | #include "udev_lib.h" |
ea733a2f | 45 | #include "udev_version.h" |
54988802 | 46 | #include "logging.h" |
ea733a2f | 47 | #include "namedev.h" |
8e41d35d | 48 | #include "udevdb.h" |
10950dfe | 49 | #include "klibc_fixups.h" |
ea733a2f | 50 | |
534c853d KS |
51 | #define LOCAL_USER "$local" |
52 | ||
9825617b HH |
53 | #include "selinux.h" |
54 | ||
ea733a2f GKH |
55 | /* |
56 | * Right now the major/minor of a device is stored in a file called | |
57 | * "dev" in sysfs. | |
58 | * The number is stored as: | |
727d1ba5 | 59 | * MM:mm |
ea733a2f GKH |
60 | * MM is the major |
61 | * mm is the minor | |
727d1ba5 | 62 | * The value is in decimal. |
ea733a2f | 63 | */ |
30defadd | 64 | static int get_major_minor(struct sysfs_class_device *class_dev, struct udevice *udev) |
ea733a2f | 65 | { |
5d4754f1 | 66 | struct sysfs_attribute *attr = NULL; |
ea733a2f | 67 | |
5d4754f1 DS |
68 | attr = sysfs_get_classdev_attr(class_dev, "dev"); |
69 | if (attr == NULL) | |
bbbe503e | 70 | goto error; |
5d4754f1 | 71 | dbg("dev='%s'", attr->value); |
ea733a2f | 72 | |
5d4754f1 | 73 | if (sscanf(attr->value, "%u:%u", &udev->major, &udev->minor) != 2) |
bbbe503e | 74 | goto error; |
f7b4eca4 | 75 | dbg("found major=%d, minor=%d", udev->major, udev->minor); |
ea733a2f | 76 | |
bbbe503e KS |
77 | return 0; |
78 | error: | |
79 | return -1; | |
ea733a2f GKH |
80 | } |
81 | ||
3d150dfb KS |
82 | static int create_path(char *file) |
83 | { | |
84 | char p[NAME_SIZE]; | |
85 | char *pos; | |
86 | int retval; | |
87 | struct stat stats; | |
88 | ||
c472e3c8 | 89 | strfieldcpy(p, file); |
3d150dfb KS |
90 | pos = strchr(p+1, '/'); |
91 | while (1) { | |
92 | pos = strchr(pos+1, '/'); | |
93 | if (pos == NULL) | |
94 | break; | |
95 | *pos = 0x00; | |
96 | if (stat(p, &stats)) { | |
9825617b | 97 | selinux_setfscreatecon(p, S_IFDIR); |
3d150dfb | 98 | retval = mkdir(p, 0755); |
c5118442 | 99 | if (retval != 0) { |
3d150dfb KS |
100 | dbg("mkdir(%s) failed with error '%s'", |
101 | p, strerror(errno)); | |
102 | return retval; | |
103 | } | |
104 | dbg("created '%s'", p); | |
9825617b HH |
105 | } else { |
106 | selinux_setfilecon(p, S_IFDIR); | |
3d150dfb KS |
107 | } |
108 | *pos = '/'; | |
109 | } | |
110 | return 0; | |
111 | } | |
112 | ||
49747bdc | 113 | static int make_node(char *file, int major, int minor, unsigned int mode, uid_t uid, gid_t gid) |
50e5de03 | 114 | { |
49747bdc KS |
115 | struct stat stats; |
116 | int retval = 0; | |
117 | ||
118 | if (stat(file, &stats) != 0) | |
119 | goto create; | |
120 | ||
121 | /* preserve node with already correct numbers, to not change the inode number */ | |
122 | if (((stats.st_mode & S_IFMT) == S_IFBLK || (stats.st_mode & S_IFMT) == S_IFCHR) && | |
123 | (stats.st_rdev == makedev(major, minor))) { | |
124 | dbg("preserve file '%s', cause it has correct dev_t", file); | |
9825617b | 125 | selinux_setfilecon(file,stats.st_mode); |
49747bdc KS |
126 | goto perms; |
127 | } | |
128 | ||
129 | if (unlink(file) != 0) | |
130 | dbg("unlink(%s) failed with error '%s'", file, strerror(errno)); | |
131 | else | |
132 | dbg("already present file '%s' unlinked", file); | |
50e5de03 | 133 | |
49747bdc | 134 | create: |
9825617b | 135 | selinux_setfscreatecon(file, mode); |
49747bdc | 136 | retval = mknod(file, mode, makedev(major, minor)); |
50e5de03 KS |
137 | if (retval != 0) { |
138 | dbg("mknod(%s, %#o, %u, %u) failed with error '%s'", | |
49747bdc | 139 | file, mode, major, minor, strerror(errno)); |
bbbe503e | 140 | goto exit; |
50e5de03 KS |
141 | } |
142 | ||
49747bdc KS |
143 | perms: |
144 | dbg("chmod(%s, %#o)", file, mode); | |
145 | if (chmod(file, mode) != 0) { | |
146 | dbg("chmod(%s, %#o) failed with error '%s'", file, mode, strerror(errno)); | |
bbbe503e | 147 | goto exit; |
50e5de03 KS |
148 | } |
149 | ||
150 | if (uid != 0 || gid != 0) { | |
49747bdc KS |
151 | dbg("chown(%s, %u, %u)", file, uid, gid); |
152 | if (chown(file, uid, gid) != 0) { | |
50e5de03 | 153 | dbg("chown(%s, %u, %u) failed with error '%s'", |
49747bdc | 154 | file, uid, gid, strerror(errno)); |
bbbe503e | 155 | goto exit; |
50e5de03 KS |
156 | } |
157 | } | |
158 | ||
bbbe503e KS |
159 | exit: |
160 | return retval; | |
50e5de03 KS |
161 | } |
162 | ||
534c853d KS |
163 | /* get the local logged in user */ |
164 | static void set_to_local_user(char *user) | |
165 | { | |
166 | struct utmp *u; | |
167 | time_t recent = 0; | |
168 | ||
17794d77 | 169 | strfieldcpymax(user, default_owner_str, OWNER_SIZE); |
534c853d KS |
170 | setutent(); |
171 | while (1) { | |
172 | u = getutent(); | |
173 | if (u == NULL) | |
174 | break; | |
175 | ||
176 | /* is this a user login ? */ | |
177 | if (u->ut_type != USER_PROCESS) | |
178 | continue; | |
179 | ||
180 | /* is this a local login ? */ | |
181 | if (strcmp(u->ut_host, "")) | |
182 | continue; | |
183 | ||
184 | if (u->ut_time > recent) { | |
185 | recent = u->ut_time; | |
17794d77 | 186 | strfieldcpymax(user, u->ut_user, OWNER_SIZE); |
534c853d KS |
187 | dbg("local user is '%s'", user); |
188 | break; | |
189 | } | |
190 | } | |
191 | endutent(); | |
192 | } | |
193 | ||
97853b4f GKH |
194 | static int create_node(struct udevice *dev, int fake) |
195 | { | |
9fe3f9a9 KS |
196 | char filename[NAME_SIZE]; |
197 | char linkname[NAME_SIZE]; | |
198 | char linktarget[NAME_SIZE]; | |
199 | char partitionname[NAME_SIZE]; | |
e308ebb7 GKH |
200 | uid_t uid = 0; |
201 | gid_t gid = 0; | |
3d150dfb KS |
202 | int i; |
203 | int tail; | |
ef672b3d KS |
204 | char *pos; |
205 | int len; | |
3d150dfb | 206 | |
c472e3c8 KS |
207 | strfieldcpy(filename, udev_root); |
208 | strfieldcat(filename, dev->name); | |
5840bc63 GKH |
209 | |
210 | switch (dev->type) { | |
1331c889 | 211 | case 'b': |
5840bc63 | 212 | dev->mode |= S_IFBLK; |
1331c889 GKH |
213 | break; |
214 | case 'c': | |
215 | case 'u': | |
5840bc63 | 216 | dev->mode |= S_IFCHR; |
1331c889 GKH |
217 | break; |
218 | case 'p': | |
5840bc63 | 219 | dev->mode |= S_IFIFO; |
1331c889 GKH |
220 | break; |
221 | default: | |
5840bc63 | 222 | dbg("unknown node type %c\n", dev->type); |
1331c889 GKH |
223 | return -EINVAL; |
224 | } | |
0abf54fc | 225 | |
3d150dfb KS |
226 | /* create parent directories if needed */ |
227 | if (strrchr(dev->name, '/')) | |
228 | create_path(filename); | |
218eae87 | 229 | |
c5118442 | 230 | if (dev->owner[0] != '\0') { |
c19a6b30 KS |
231 | char *endptr; |
232 | unsigned long id = strtoul(dev->owner, &endptr, 10); | |
765cbd97 | 233 | if (endptr[0] == '\0') |
c19a6b30 | 234 | uid = (uid_t) id; |
10950dfe | 235 | else { |
5895eb31 | 236 | struct passwd *pw; |
534c853d KS |
237 | if (strncmp(dev->owner, LOCAL_USER, sizeof(LOCAL_USER)) == 0) |
238 | set_to_local_user(dev->owner); | |
239 | ||
5895eb31 | 240 | pw = getpwnam(dev->owner); |
765cbd97 KS |
241 | if (pw == NULL) |
242 | dbg("specified user unknown '%s'", dev->owner); | |
10950dfe GKH |
243 | else |
244 | uid = pw->pw_uid; | |
245 | } | |
c19a6b30 KS |
246 | } |
247 | ||
c5118442 | 248 | if (dev->group[0] != '\0') { |
c19a6b30 KS |
249 | char *endptr; |
250 | unsigned long id = strtoul(dev->group, &endptr, 10); | |
765cbd97 | 251 | if (endptr[0] == '\0') |
c19a6b30 | 252 | gid = (gid_t) id; |
10950dfe GKH |
253 | else { |
254 | struct group *gr = getgrnam(dev->group); | |
765cbd97 KS |
255 | if (gr == NULL) |
256 | dbg("specified group unknown '%s'", dev->group); | |
10950dfe GKH |
257 | else |
258 | gid = gr->gr_gid; | |
259 | } | |
c19a6b30 KS |
260 | } |
261 | ||
ab2e5bd9 | 262 | if (!fake) { |
50e5de03 | 263 | info("creating device node '%s'", filename); |
bbbe503e KS |
264 | if (make_node(filename, dev->major, dev->minor, dev->mode, uid, gid) != 0) |
265 | goto error; | |
ab2e5bd9 GKH |
266 | } else { |
267 | info("creating device node '%s', major = '%d', minor = '%d', " | |
268 | "mode = '%#o', uid = '%d', gid = '%d'", filename, | |
269 | dev->major, dev->minor, (mode_t)dev->mode, uid, gid); | |
270 | } | |
50e5de03 | 271 | |
bbbe503e | 272 | /* create all_partitions if requested */ |
50e5de03 KS |
273 | if (dev->partitions > 0) { |
274 | info("creating device partition nodes '%s[1-%i]'", filename, dev->partitions); | |
ab2e5bd9 GKH |
275 | if (!fake) { |
276 | for (i = 1; i <= dev->partitions; i++) { | |
c58e36c0 KS |
277 | strfieldcpy(partitionname, filename); |
278 | strintcat(partitionname, i); | |
ab2e5bd9 GKH |
279 | make_node(partitionname, dev->major, |
280 | dev->minor + i, dev->mode, uid, gid); | |
281 | } | |
50e5de03 | 282 | } |
3d150dfb KS |
283 | } |
284 | ||
bbbe503e | 285 | /* create symlink(s) if requested */ |
9fe3f9a9 | 286 | foreach_strpart(dev->symlink, " ", pos, len) { |
17794d77 | 287 | strfieldcpymax(linkname, pos, len+1); |
9fe3f9a9 KS |
288 | strfieldcpy(filename, udev_root); |
289 | strfieldcat(filename, linkname); | |
290 | dbg("symlink '%s' to node '%s' requested", filename, dev->name); | |
291 | if (!fake) | |
292 | if (strrchr(linkname, '/')) | |
293 | create_path(filename); | |
294 | ||
295 | /* optimize relative link */ | |
296 | linktarget[0] = '\0'; | |
297 | i = 0; | |
298 | tail = 0; | |
299 | while ((dev->name[i] == linkname[i]) && dev->name[i]) { | |
300 | if (dev->name[i] == '/') | |
301 | tail = i+1; | |
302 | i++; | |
303 | } | |
304 | while (linkname[i] != '\0') { | |
305 | if (linkname[i] == '/') | |
306 | strfieldcat(linktarget, "../"); | |
307 | i++; | |
308 | } | |
3d150dfb | 309 | |
9fe3f9a9 | 310 | strfieldcat(linktarget, &dev->name[tail]); |
3d150dfb | 311 | |
9fe3f9a9 KS |
312 | dbg("symlink(%s, %s)", linktarget, filename); |
313 | if (!fake) { | |
9825617b | 314 | selinux_setfscreatecon(filename, S_IFLNK); |
49747bdc | 315 | unlink(filename); |
bbbe503e | 316 | if (symlink(linktarget, filename) != 0) |
9fe3f9a9 KS |
317 | dbg("symlink(%s, %s) failed with error '%s'", |
318 | linktarget, filename, strerror(errno)); | |
4763256c | 319 | } |
c19a6b30 KS |
320 | } |
321 | ||
bbbe503e KS |
322 | return 0; |
323 | error: | |
324 | return -1; | |
ea733a2f GKH |
325 | } |
326 | ||
eb6c7cd0 | 327 | static struct sysfs_class_device *get_class_dev(const char *device_name) |
ea733a2f GKH |
328 | { |
329 | char dev_path[SYSFS_PATH_MAX]; | |
63dde9f8 GKH |
330 | struct sysfs_class_device *class_dev = NULL; |
331 | ||
c472e3c8 KS |
332 | strfieldcpy(dev_path, sysfs_path); |
333 | strfieldcat(dev_path, device_name); | |
f7b4eca4 | 334 | dbg("looking at '%s'", dev_path); |
ea733a2f GKH |
335 | |
336 | /* open up the sysfs class device for this thing... */ | |
bcbe2d8e | 337 | class_dev = sysfs_open_class_device_path(dev_path); |
ea733a2f | 338 | if (class_dev == NULL) { |
bcbe2d8e | 339 | dbg ("sysfs_open_class_device_path failed"); |
63dde9f8 | 340 | goto exit; |
ea733a2f | 341 | } |
f7b4eca4 | 342 | dbg("class_dev->name='%s'", class_dev->name); |
ea733a2f | 343 | |
63dde9f8 | 344 | exit: |
ea733a2f GKH |
345 | return class_dev; |
346 | } | |
347 | ||
29fd7e67 GKH |
348 | /* wait for the "dev" file to show up in the directory in sysfs. |
349 | * If it doesn't happen in about 10 seconds, give up. | |
350 | */ | |
f61d732a | 351 | #define SECONDS_TO_WAIT_FOR_FILE 10 |
eb6c7cd0 | 352 | static int sleep_for_file(const char *path, char* file) |
29fd7e67 GKH |
353 | { |
354 | char filename[SYSFS_PATH_MAX + 6]; | |
f61d732a | 355 | int loop = SECONDS_TO_WAIT_FOR_FILE; |
c332cfc7 | 356 | int retval; |
29fd7e67 | 357 | |
c472e3c8 KS |
358 | strfieldcpy(filename, sysfs_path); |
359 | strfieldcat(filename, path); | |
f61d732a | 360 | strfieldcat(filename, file); |
29fd7e67 | 361 | |
c332cfc7 RL |
362 | while (loop--) { |
363 | struct stat buf; | |
364 | ||
f7b4eca4 | 365 | dbg("looking for '%s'", filename); |
29fd7e67 | 366 | retval = stat(filename, &buf); |
c5118442 | 367 | if (retval == 0) |
29fd7e67 | 368 | goto exit; |
29fd7e67 | 369 | |
f7b4eca4 | 370 | /* sleep to give the kernel a chance to create the dev file */ |
29fd7e67 GKH |
371 | sleep(1); |
372 | } | |
373 | retval = -ENODEV; | |
374 | exit: | |
375 | return retval; | |
376 | } | |
377 | ||
bbbe503e | 378 | static int rename_net_if(struct udevice *dev, int fake) |
f61d732a KS |
379 | { |
380 | int sk; | |
381 | struct ifreq ifr; | |
382 | int retval; | |
383 | ||
bbbe503e KS |
384 | dbg("changing net interface name from '%s' to '%s'", dev->kernel_name, dev->name); |
385 | if (fake) | |
386 | return 0; | |
387 | ||
f61d732a KS |
388 | sk = socket(PF_INET, SOCK_DGRAM, 0); |
389 | if (sk < 0) { | |
390 | dbg("error opening socket"); | |
391 | return -1; | |
392 | } | |
393 | ||
394 | memset(&ifr, 0x00, sizeof(struct ifreq)); | |
395 | strfieldcpy(ifr.ifr_name, dev->kernel_name); | |
396 | strfieldcpy(ifr.ifr_newname, dev->name); | |
397 | ||
f61d732a KS |
398 | retval = ioctl(sk, SIOCSIFNAME, &ifr); |
399 | if (retval != 0) | |
400 | dbg("error changing net interface name"); | |
4a539daf | 401 | close(sk); |
f61d732a KS |
402 | |
403 | return retval; | |
404 | } | |
405 | ||
eb6c7cd0 | 406 | int udev_add_device(const char *path, const char *subsystem, int fake) |
ea733a2f | 407 | { |
bbbe503e | 408 | struct sysfs_class_device *class_dev; |
5840bc63 | 409 | struct udevice dev; |
9b28a52a | 410 | char devpath[DEVPATH_SIZE]; |
bbbe503e KS |
411 | char *pos; |
412 | int retval; | |
ea733a2f | 413 | |
f3b04a2e GKH |
414 | memset(&dev, 0x00, sizeof(dev)); |
415 | ||
f61d732a | 416 | dev.type = get_device_type(path, subsystem); |
f61d732a KS |
417 | switch (dev.type) { |
418 | case 'b': | |
419 | case 'c': | |
420 | retval = sleep_for_file(path, "/dev"); | |
421 | break; | |
422 | ||
423 | case 'n': | |
424 | retval = sleep_for_file(path, "/address"); | |
425 | break; | |
426 | ||
427 | default: | |
428 | dbg("unknown device type '%c'", dev.type); | |
bbbe503e | 429 | return -1; |
f61d732a | 430 | } |
63dde9f8 | 431 | |
5840bc63 | 432 | class_dev = get_class_dev(path); |
ea733a2f | 433 | if (class_dev == NULL) |
bbbe503e | 434 | return -1; |
ea733a2f | 435 | |
f61d732a KS |
436 | if (dev.type == 'b' || dev.type == 'c') { |
437 | retval = get_major_minor(class_dev, &dev); | |
438 | if (retval != 0) { | |
439 | dbg("get_major_minor failed"); | |
440 | goto exit; | |
441 | } | |
ea733a2f GKH |
442 | } |
443 | ||
bbbe503e | 444 | if (namedev_name_device(class_dev, &dev) != 0) |
30defadd GKH |
445 | goto exit; |
446 | ||
f7b4eca4 | 447 | dbg("name='%s'", dev.name); |
bbbe503e | 448 | |
9825617b | 449 | selinux_init(); |
f61d732a KS |
450 | switch (dev.type) { |
451 | case 'b': | |
452 | case 'c': | |
453 | retval = create_node(&dev, fake); | |
c4603a07 | 454 | if (retval != 0) |
bbbe503e | 455 | goto exit; |
c4603a07 | 456 | if ((!fake) && (udevdb_add_dev(path, &dev) != 0)) |
bbbe503e KS |
457 | dbg("udevdb_add_dev failed, but we are going to try " |
458 | "to create the node anyway. But remove might not " | |
459 | "work properly for this device."); | |
9b28a52a KS |
460 | |
461 | dev_d_send(&dev, subsystem, path); | |
f61d732a KS |
462 | break; |
463 | ||
464 | case 'n': | |
a41de030 | 465 | strfieldcpy(devpath, path); |
bbbe503e KS |
466 | if (strcmp(dev.name, dev.kernel_name) != 0) { |
467 | retval = rename_net_if(&dev, fake); | |
c4603a07 | 468 | if (retval != 0) |
bbbe503e KS |
469 | goto exit; |
470 | /* netif's are keyed with the configured name, cause | |
471 | * the original kernel name sleeps with the fishes | |
472 | */ | |
9b28a52a | 473 | pos = strrchr(devpath, '/'); |
bbbe503e KS |
474 | if (pos != NULL) { |
475 | pos[1] = '\0'; | |
9b28a52a | 476 | strfieldcat(devpath, dev.name); |
bbbe503e KS |
477 | } |
478 | } | |
c4603a07 | 479 | if ((!fake) && (udevdb_add_dev(devpath, &dev) != 0)) |
bbbe503e | 480 | dbg("udevdb_add_dev failed"); |
9b28a52a KS |
481 | |
482 | dev_d_send(&dev, subsystem, devpath); | |
f61d732a KS |
483 | break; |
484 | } | |
ea733a2f GKH |
485 | |
486 | exit: | |
9825617b | 487 | selinux_restore(); |
bbbe503e | 488 | sysfs_close_class_device(class_dev); |
30defadd | 489 | |
ea733a2f GKH |
490 | return retval; |
491 | } |