src/test/test-udev.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2003-2004 Greg Kroah-Hartman <greg@kroah.com>
   5   Copyright 2004-2012 Kay Sievers <kay@vrfy.org>
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <stdio.h>
  22 #include <stddef.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <fcntl.h>
  26 #include <ctype.h>
  27 #include <errno.h>
  28 #include <unistd.h>
  29 #include <syslog.h>
  30 #include <grp.h>
  31 #include <sched.h>
  32 #include <sys/mount.h>
  33 #include <sys/signalfd.h>
  34
  35 #include "missing.h"
  36 #include "udev.h"
  37 #include "udev-util.h"
  38
  39 void udev_main_log(struct udev *udev, int priority,
  40                    const char *file, int line, const char *fn,
  41                    const char *format, va_list args) {}
  42
  43 static int fake_filesystems(void) {
  44         static const struct fakefs {
  45                 const char *src;
  46                 const char *target;
  47                 const char *error;
  48         } fakefss[] = {
  49                 { "test/sys", "/sys",                   "failed to mount test /sys" },
  50                 { "test/dev", "/dev",                   "failed to mount test /dev" },
  51                 { "test/run", "/run",                   "failed to mount test /run" },
  52                 { "test/run", "/etc/udev/rules.d",      "failed to mount empty /etc/udev/rules.d" },
  53                 { "test/run", "/usr/lib/udev/rules.d",  "failed to mount empty /usr/lib/udev/rules.d" },
  54         };
  55         unsigned int i;
  56         int err;
  57
  58         err = unshare(CLONE_NEWNS);
  59         if (err < 0) {
  60                 err = -errno;
  61                 fprintf(stderr, "failed to call unshare(): %m\n");
  62                 goto out;
  63         }
  64
  65         if (mount(NULL, "/", NULL, MS_PRIVATE|MS_REC, NULL) < 0) {
  66                 err = -errno;
  67                 fprintf(stderr, "failed to mount / as private: %m\n");
  68                 goto out;
  69         }
  70
  71         for (i = 0; i < ELEMENTSOF(fakefss); i++) {
  72                 err = mount(fakefss[i].src, fakefss[i].target, NULL, MS_BIND, NULL);
  73                 if (err < 0) {
  74                         err = -errno;
  75                         fprintf(stderr, "%s %m", fakefss[i].error);
  76                         return err;
  77                 }
  78         }
  79 out:
  80         return err;
  81 }
  82
  83
  84 int main(int argc, char *argv[]) {
  85         _cleanup_udev_unref_ struct udev *udev = NULL;
  86         _cleanup_udev_event_unref_ struct udev_event *event = NULL;
  87         _cleanup_udev_device_unref_ struct udev_device *dev = NULL;
  88         _cleanup_udev_rules_unref_ struct udev_rules *rules = NULL;
  89         char syspath[UTIL_PATH_SIZE];
  90         const char *devpath;
  91         const char *action;
  92         sigset_t mask, sigmask_orig;
  93         int err;
  94
  95         err = fake_filesystems();
  96         if (err < 0)
  97                 return EXIT_FAILURE;
  98
  99         udev = udev_new();
 100         if (udev == NULL)
 101                 return EXIT_FAILURE;
 102
 103         log_debug("version %s", VERSION);
 104         label_init("/dev");
 105
 106         sigprocmask(SIG_SETMASK, NULL, &sigmask_orig);
 107
 108         action = argv[1];
 109         if (action == NULL) {
 110                 log_error("action missing");
 111                 goto out;
 112         }
 113
 114         devpath = argv[2];
 115         if (devpath == NULL) {
 116                 log_error("devpath missing");
 117                 goto out;
 118         }
 119
 120         rules = udev_rules_new(udev, 1);
 121
 122         strscpyl(syspath, sizeof(syspath), "/sys", devpath, NULL);
 123         dev = udev_device_new_from_syspath(udev, syspath);
 124         if (dev == NULL) {
 125                 log_debug("unknown device '%s'", devpath);
 126                 goto out;
 127         }
 128
 129         udev_device_set_action(dev, action);
 130         event = udev_event_new(dev);
 131
 132         sigfillset(&mask);
 133         sigprocmask(SIG_SETMASK, &mask, &sigmask_orig);
 134         event->fd_signal = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
 135         if (event->fd_signal < 0) {
 136                 fprintf(stderr, "error creating signalfd\n");
 137                 goto out;
 138         }
 139
 140         /* do what devtmpfs usually provides us */
 141         if (udev_device_get_devnode(dev) != NULL) {
 142                 mode_t mode = 0600;
 143
 144                 if (streq(udev_device_get_subsystem(dev), "block"))
 145                         mode |= S_IFBLK;
 146                 else
 147                         mode |= S_IFCHR;
 148
 149                 if (!streq(action, "remove")) {
 150                         mkdir_parents_label(udev_device_get_devnode(dev), 0755);
 151                         mknod(udev_device_get_devnode(dev), mode, udev_device_get_devnum(dev));
 152                 } else {
 153                         unlink(udev_device_get_devnode(dev));
 154                         util_delete_path(udev, udev_device_get_devnode(dev));
 155                 }
 156         }
 157
 158         err = udev_event_execute_rules(event, rules, &sigmask_orig);
 159         if (err == 0)
 160                 udev_event_execute_run(event, NULL);
 161 out:
 162         if (event != NULL && event->fd_signal >= 0)
 163                 close(event->fd_signal);
 164         label_finish();
 165
 166         return err ? EXIT_FAILURE : EXIT_SUCCESS;
 167 }