udev_add.c

   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>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32 #include <grp.h>
  33 #include <net/if.h>
  34 #include <sys/socket.h>
  35 #include <sys/ioctl.h>
  36 #include <linux/sockios.h>
  37 #ifndef __KLIBC__
  38 #include <pwd.h>
  39 #include <utmp.h>
  40 #endif
  41
  42 #include "libsysfs/sysfs/libsysfs.h"
  43 #include "udev.h"
  44 #include "udev_lib.h"
  45 #include "udev_version.h"
  46 #include "logging.h"
  47 #include "namedev.h"
  48 #include "udevdb.h"
  49 #include "klibc_fixups.h"
  50
  51 #define LOCAL_USER "$local"
  52
  53 #include "selinux.h"
  54
  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:
  59  *      MM:mm
  60  *              MM is the major
  61  *              mm is the minor
  62  *              The value is in decimal.
  63  */
  64 static int get_major_minor(struct sysfs_class_device *class_dev, struct udevice *udev)
  65 {
  66         struct sysfs_attribute *attr = NULL;
  67
  68         attr = sysfs_get_classdev_attr(class_dev, "dev");
  69         if (attr == NULL)
  70                 goto error;
  71         dbg("dev='%s'", attr->value);
  72
  73         if (sscanf(attr->value, "%u:%u", &udev->major, &udev->minor) != 2)
  74                 goto error;
  75         dbg("found major=%d, minor=%d", udev->major, udev->minor);
  76
  77         return 0;
  78 error:
  79         return -1;
  80 }
  81
  82 static int create_path(char *file)
  83 {
  84         char p[NAME_SIZE];
  85         char *pos;
  86         int retval;
  87         struct stat stats;
  88
  89         strfieldcpy(p, file);
  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)) {
  97                         selinux_setfscreatecon(p, S_IFDIR);
  98                         retval = mkdir(p, 0755);
  99                         if (retval != 0) {
 100                                 dbg("mkdir(%s) failed with error '%s'",
 101                                     p, strerror(errno));
 102                                 return retval;
 103                         }
 104                         dbg("created '%s'", p);
 105                 } else {
 106                         selinux_setfilecon(p, S_IFDIR);
 107                 }
 108                 *pos = '/';
 109         }
 110         return 0;
 111 }
 112
 113 static int make_node(char *file, int major, int minor, unsigned int mode, uid_t uid, gid_t gid)
 114 {
 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);
 125                 selinux_setfilecon(file,stats.st_mode);
 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);
 133
 134 create:
 135         selinux_setfscreatecon(file, mode);
 136         retval = mknod(file, mode, makedev(major, minor));
 137         if (retval != 0) {
 138                 dbg("mknod(%s, %#o, %u, %u) failed with error '%s'",
 139                     file, mode, major, minor, strerror(errno));
 140                 goto exit;
 141         }
 142
 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));
 147                 goto exit;
 148         }
 149
 150         if (uid != 0 || gid != 0) {
 151                 dbg("chown(%s, %u, %u)", file, uid, gid);
 152                 if (chown(file, uid, gid) != 0) {
 153                         dbg("chown(%s, %u, %u) failed with error '%s'",
 154                             file, uid, gid, strerror(errno));
 155                         goto exit;
 156                 }
 157         }
 158
 159 exit:
 160         return retval;
 161 }
 162
 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
 169         strfieldcpymax(user, default_owner_str, OWNER_SIZE);
 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;
 186                         strfieldcpymax(user, u->ut_user, OWNER_SIZE);
 187                         dbg("local user is '%s'", user);
 188                         break;
 189                 }
 190         }
 191         endutent();
 192 }
 193
 194 static int create_node(struct udevice *dev, int fake)
 195 {
 196         char filename[NAME_SIZE];
 197         char linkname[NAME_SIZE];
 198         char linktarget[NAME_SIZE];
 199         char partitionname[NAME_SIZE];
 200         uid_t uid = 0;
 201         gid_t gid = 0;
 202         int i;
 203         int tail;
 204         char *pos;
 205         int len;
 206
 207         strfieldcpy(filename, udev_root);
 208         strfieldcat(filename, dev->name);
 209
 210         switch (dev->type) {
 211         case 'b':
 212                 dev->mode |= S_IFBLK;
 213                 break;
 214         case 'c':
 215         case 'u':
 216                 dev->mode |= S_IFCHR;
 217                 break;
 218         case 'p':
 219                 dev->mode |= S_IFIFO;
 220                 break;
 221         default:
 222                 dbg("unknown node type %c\n", dev->type);
 223                 return -EINVAL;
 224         }
 225
 226         /* create parent directories if needed */
 227         if (strrchr(dev->name, '/'))
 228                 create_path(filename);
 229
 230         if (dev->owner[0] != '\0') {
 231                 char *endptr;
 232                 unsigned long id = strtoul(dev->owner, &endptr, 10);
 233                 if (endptr[0] == '\0')
 234                         uid = (uid_t) id;
 235                 else {
 236                         struct passwd *pw;
 237                         if (strncmp(dev->owner, LOCAL_USER, sizeof(LOCAL_USER)) == 0)
 238                                 set_to_local_user(dev->owner);
 239
 240                         pw = getpwnam(dev->owner);
 241                         if (pw == NULL)
 242                                 dbg("specified user unknown '%s'", dev->owner);
 243                         else
 244                                 uid = pw->pw_uid;
 245                 }
 246         }
 247
 248         if (dev->group[0] != '\0') {
 249                 char *endptr;
 250                 unsigned long id = strtoul(dev->group, &endptr, 10);
 251                 if (endptr[0] == '\0')
 252                         gid = (gid_t) id;
 253                 else {
 254                         struct group *gr = getgrnam(dev->group);
 255                         if (gr == NULL)
 256                                 dbg("specified group unknown '%s'", dev->group);
 257                         else
 258                                 gid = gr->gr_gid;
 259                 }
 260         }
 261
 262         if (!fake) {
 263                 info("creating device node '%s'", filename);
 264                 if (make_node(filename, dev->major, dev->minor, dev->mode, uid, gid) != 0)
 265                         goto error;
 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         }
 271
 272         /* create all_partitions if requested */
 273         if (dev->partitions > 0) {
 274                 info("creating device partition nodes '%s[1-%i]'", filename, dev->partitions);
 275                 if (!fake) {
 276                         for (i = 1; i <= dev->partitions; i++) {
 277                                 strfieldcpy(partitionname, filename);
 278                                 strintcat(partitionname, i);
 279                                 make_node(partitionname, dev->major,
 280                                           dev->minor + i, dev->mode, uid, gid);
 281                         }
 282                 }
 283         }
 284
 285         /* create symlink(s) if requested */
 286         foreach_strpart(dev->symlink, " ", pos, len) {
 287                 strfieldcpymax(linkname, pos, len+1);
 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                 }
 309
 310                 strfieldcat(linktarget, &dev->name[tail]);
 311
 312                 dbg("symlink(%s, %s)", linktarget, filename);
 313                 if (!fake) {
 314                         selinux_setfscreatecon(filename, S_IFLNK);
 315                         unlink(filename);
 316                         if (symlink(linktarget, filename) != 0)
 317                                 dbg("symlink(%s, %s) failed with error '%s'",
 318                                     linktarget, filename, strerror(errno));
 319                 }
 320         }
 321
 322         return 0;
 323 error:
 324         return -1;
 325 }
 326
 327 static struct sysfs_class_device *get_class_dev(const char *device_name)
 328 {
 329         char dev_path[SYSFS_PATH_MAX];
 330         struct sysfs_class_device *class_dev = NULL;
 331
 332         strfieldcpy(dev_path, sysfs_path);
 333         strfieldcat(dev_path, device_name);
 334         dbg("looking at '%s'", dev_path);
 335
 336         /* open up the sysfs class device for this thing... */
 337         class_dev = sysfs_open_class_device_path(dev_path);
 338         if (class_dev == NULL) {
 339                 dbg ("sysfs_open_class_device_path failed");
 340                 goto exit;
 341         }
 342         dbg("class_dev->name='%s'", class_dev->name);
 343
 344 exit:
 345         return class_dev;
 346 }
 347
 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  */
 351 static int sleep_for_file(const char *path, char* file)
 352 {
 353         char filename[SYSFS_PATH_MAX + 6];
 354         int loop = WAIT_FOR_FILE_SECONDS * WAIT_FOR_FILE_RETRY_FREQ;
 355         int retval;
 356
 357         strfieldcpy(filename, sysfs_path);
 358         strfieldcat(filename, path);
 359         strfieldcat(filename, file);
 360
 361         while (loop--) {
 362                 struct stat buf;
 363
 364                 dbg("looking for '%s'", filename);
 365                 retval = stat(filename, &buf);
 366                 if (retval == 0)
 367                         goto exit;
 368
 369                 /* sleep to give the kernel a chance to create the dev file */
 370                 usleep(1000 * 1000 / WAIT_FOR_FILE_RETRY_FREQ);
 371         }
 372         retval = -ENODEV;
 373 exit:
 374         return retval;
 375 }
 376
 377 static int rename_net_if(struct udevice *dev, int fake)
 378 {
 379         int sk;
 380         struct ifreq ifr;
 381         int retval;
 382
 383         dbg("changing net interface name from '%s' to '%s'", dev->kernel_name, dev->name);
 384         if (fake)
 385                 return 0;
 386
 387         sk = socket(PF_INET, SOCK_DGRAM, 0);
 388         if (sk < 0) {
 389                 dbg("error opening socket");
 390                 return -1;
 391         }
 392
 393         memset(&ifr, 0x00, sizeof(struct ifreq));
 394         strfieldcpy(ifr.ifr_name, dev->kernel_name);
 395         strfieldcpy(ifr.ifr_newname, dev->name);
 396
 397         retval = ioctl(sk, SIOCSIFNAME, &ifr);
 398         if (retval != 0)
 399                 dbg("error changing net interface name");
 400         close(sk);
 401
 402         return retval;
 403 }
 404
 405 int udev_add_device(const char *path, const char *subsystem, int fake)
 406 {
 407         struct sysfs_class_device *class_dev;
 408         struct udevice dev;
 409         char devpath[DEVPATH_SIZE];
 410         char *pos;
 411         int retval;
 412
 413         memset(&dev, 0x00, sizeof(dev));
 414
 415         dev.type = get_device_type(path, subsystem);
 416         switch (dev.type) {
 417         case 'b':
 418         case 'c':
 419                 retval = sleep_for_file(path, "/dev");
 420                 break;
 421
 422         case 'n':
 423                 retval = sleep_for_file(path, "/address");
 424                 break;
 425
 426         default:
 427                 dbg("unknown device type '%c'", dev.type);
 428                 return -1;
 429         }
 430
 431         class_dev = get_class_dev(path);
 432         if (class_dev == NULL)
 433                 return -1;
 434
 435         if (dev.type == 'b' || dev.type == 'c') {
 436                 retval = get_major_minor(class_dev, &dev);
 437                 if (retval != 0) {
 438                         dbg("get_major_minor failed");
 439                         goto exit;
 440                 }
 441         }
 442
 443         if (namedev_name_device(class_dev, &dev) != 0)
 444                 goto exit;
 445
 446         dbg("name='%s'", dev.name);
 447
 448         selinux_init();
 449         switch (dev.type) {
 450         case 'b':
 451         case 'c':
 452                 retval = create_node(&dev, fake);
 453                 if (retval != 0)
 454                         goto exit;
 455                 if ((!fake) && (udevdb_add_dev(path, &dev) != 0))
 456                         dbg("udevdb_add_dev failed, but we are going to try "
 457                             "to create the node anyway. But remove might not "
 458                             "work properly for this device.");
 459
 460                 dev_d_send(&dev, subsystem, path);
 461                 break;
 462
 463         case 'n':
 464                 strfieldcpy(devpath, path);
 465                 if (strcmp(dev.name, dev.kernel_name) != 0) {
 466                         retval = rename_net_if(&dev, fake);
 467                         if (retval != 0)
 468                                 goto exit;
 469                         /* netif's are keyed with the configured name, cause
 470                          * the original kernel name sleeps with the fishes
 471                          */
 472                         pos = strrchr(devpath, '/');
 473                         if (pos != NULL) {
 474                                 pos[1] = '\0';
 475                                 strfieldcat(devpath, dev.name);
 476                         }
 477                 }
 478                 if ((!fake) && (udevdb_add_dev(devpath, &dev) != 0))
 479                         dbg("udevdb_add_dev failed");
 480
 481                 dev_d_send(&dev, subsystem, devpath);
 482                 break;
 483         }
 484
 485 exit:
 486         selinux_restore();
 487         sysfs_close_class_device(class_dev);
 488
 489         return retval;
 490 }