eject: use BUILD_EJECT, move to sys-utils

Signed-off-by: Karel Zak <kzak@redhat.com>

1 files changed, 1082 insertions, 0 deletions

diff --git a/sys-utils/eject.c b/sys-utils/eject.c
new file mode 100644
index 000000000..2d8b0cbcc
--- /dev/null
+++ b/sys-utils/eject.c
@@ -0,0 +1,1082 @@
+/*
+ * Copyright (C) 1994-2005 Jeff Tranter (tranter@pobox.com)
+ * Copyright (C) 2012 Karel Zak <kzak@redhat.com>
+ * Copyright (C) Michal Luscon <mluscon@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <err.h>
+#include <stdarg.h>
+
+#include <getopt.h>
+#include <errno.h>
+#include <regex.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <sys/mtio.h>
+#include <linux/cdrom.h>
+#include <linux/fd.h>
+#include <sys/mount.h>
+#include <scsi/scsi.h>
+#include <scsi/sg.h>
+#include <scsi/scsi_ioctl.h>
+#include <sys/time.h>
+
+#include <libmount.h>
+
+#include "c.h"
+#include "nls.h"
+#include "strutils.h"
+#include "xalloc.h"
+#include "pathnames.h"
+#include "sysfs.h"
+
+#define EJECT_DEFAULT_DEVICE "/dev/cdrom"
+
+
+/* Used by the toggle_tray() function. If ejecting the tray takes this
+ * time or less, the tray was probably already ejected, so we close it
+ * again.
+ */
+#define TRAY_WAS_ALREADY_OPEN_USECS  200000	/* about 0.2 seconds */
+
+/* eject(1) is able to eject only 'removable' devices (attribute in /sys)
+ * _or_ devices connected by hotplug subsystem.
+ */
+static const char *hotplug_subsystems[] = {
+	"usb",
+	"ieee1394",
+	"pcmcia",
+	"mmc",
+	"ccw"
+};
+
+/* Global Variables */
+static int a_option; /* command flags and arguments */
+static int c_option;
+static int d_option;
+static int f_option;
+static int F_option;
+static int n_option;
+static int q_option;
+static int r_option;
+static int s_option;
+static int t_option;
+static int T_option;
+static int X_option;
+static int v_option;
+static int x_option;
+static int p_option;
+static int m_option;
+static int i_option;
+static int a_arg;
+static int i_arg;
+static long int c_arg;
+static long int x_arg;
+
+struct libmnt_table *mtab;
+struct libmnt_cache *cache;
+
+static void vinfo(const char *fmt, va_list va)
+{
+	fprintf(stdout, "%s: ", program_invocation_short_name);
+	vprintf(fmt, va);
+	fputc('\n', stdout);
+}
+
+static inline void verbose(const char *fmt, ...)
+{
+	va_list va;
+
+	if (!v_option)
+		return;
+
+	va_start(va, fmt);
+	vinfo(fmt, va);
+	va_end(va);
+}
+
+static inline void info(const char *fmt, ...)
+{
+	va_list va;
+	va_start(va, fmt);
+	vinfo(fmt, va);
+	va_end(va);
+}
+
+static void __attribute__ ((__noreturn__)) usage(FILE * out)
+{
+	fputs(USAGE_HEADER, out);
+
+	fprintf(out,
+		_(" %s [options] [<device>|<mountpoint>]\n"), program_invocation_short_name);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -a, --auto <on|off>        turn auto-eject feature on or off\n"
+		" -c, --changerslot <slot>   switch discs on a CD-ROM changer\n"
+		" -d, --default              display default device\n"
+		" -f, --floppy               eject floppy\n"
+		" -F, --force                don't care about device type\n"
+		" -i, --manualeject <on|off> toggle manual eject protection on/off\n"
+		" -m, --no-unmount           do not unmount device even if it is mounted\n"
+		" -n, --noop                 don't eject, just show device found\n"
+		" -p, --proc                 use /proc/mounts instead of /etc/mtab\n"
+		" -q, --tape                 eject tape\n"
+		" -r, --cdrom                eject CD-ROM\n"
+		" -s, --scsi                 eject SCSI device\n"
+		" -t, --trayclose            close tray\n"
+		" -T, --traytoggle           toggle tray\n"
+		" -v, --verbose              enable verbose output\n"
+		" -x, --cdspeed <speed>      set CD-ROM max speed\n"
+		" -X, --listspeed            list CD-ROM available speeds\n"),
+		out);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(USAGE_HELP, out);
+	fputs(USAGE_VERSION, out);
+
+	fputs(_("\nBy default tries -r, -s, -f, and -q in order until success.\n"), out);
+	fprintf(out, USAGE_MAN_TAIL("eject(1)"));
+
+	exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS);
+}
+
+
+/* Handle command line options. */
+static void parse_args(int argc, char **argv, char **device)
+{
+	static const struct option long_opts[] =
+	{
+		{"auto",	required_argument, NULL, 'a'},
+		{"cdrom",	no_argument,	   NULL, 'r'},
+		{"cdspeed",	required_argument, NULL, 'x'},
+		{"changerslot", required_argument, NULL, 'c'},
+		{"default",	no_argument,	   NULL, 'd'},
+		{"floppy",	no_argument,	   NULL, 'f'},
+		{"force",       no_argument,       NULL, 'F'},
+		{"help",	no_argument,	   NULL, 'h'},
+		{"listspeed",   no_argument,       NULL, 'X'},
+		{"manualeject", required_argument, NULL, 'i'},
+		{"noop",	no_argument,	   NULL, 'n'},
+		{"no-unmount",	no_argument,	   NULL, 'm'},
+		{"proc",	no_argument,	   NULL, 'p'},
+		{"scsi",	no_argument,	   NULL, 's'},
+		{"tape",	no_argument,	   NULL, 'q'},
+		{"trayclose",	no_argument,	   NULL, 't'},
+		{"traytoggle",	no_argument,	   NULL, 'T'},
+		{"verbose",	no_argument,	   NULL, 'v'},
+		{"version",	no_argument,	   NULL, 'V'},
+		{0, 0, 0, 0}
+	};
+	int c;
+
+	while ((c = getopt_long(argc, argv,
+				"a:c:i:x:dfFhnqrstTXvVpm", long_opts, NULL)) != -1) {
+		switch (c) {
+		case 'a':
+			a_option = 1;
+			if (!strcmp(optarg, "0") || !strcmp(optarg, "off"))
+				a_arg = 0;
+			else if (!strcmp(optarg, "1") || !strcmp(optarg, "on"))
+				a_arg = 1;
+			else
+				errx(EXIT_FAILURE, _("invalid argument to --auto/-a option"));
+			break;
+		case 'c':
+			c_option = 1;
+			c_arg = strtoul_or_err(optarg, _("invalid argument to --changerslot/-c option"));
+			break;
+		case 'x':
+			x_option = 1;
+			x_arg = strtoul_or_err(optarg, _("invalid argument to --cdspeed/-x option"));
+			break;
+		case 'd':
+			d_option = 1;
+			break;
+		case 'f':
+			f_option = 1;
+			break;
+		case 'F':
+			F_option = 1;
+			break;
+		case 'h':
+			usage(stdout);
+			break;
+		case 'i':
+			i_option = 1;
+			if (!strcmp(optarg, "0") || !strcmp(optarg, "off"))
+				i_arg = 0;
+			else if (!strcmp(optarg, "1") || !strcmp(optarg, "on"))
+				i_arg = 1;
+			else
+				errx(EXIT_FAILURE, _("invalid argument to --manualeject/-i option"));
+			break;
+		case 'm':
+			m_option = 1;
+			break;
+		case 'n':
+			n_option = 1;
+			break;
+		case 'p':
+			p_option = 1;
+			break;
+		case 'q':
+			q_option = 1;
+			break;
+		case 'r':
+			r_option = 1;
+			break;
+		case 's':
+			s_option = 1;
+			break;
+		case 't':
+			t_option = 1;
+			break;
+		case 'T':
+			T_option = 1;
+			break;
+		case 'X':
+			X_option = 1;
+			break;
+		case 'v':
+			v_option = 1;
+			break;
+		case 'V':
+			printf(UTIL_LINUX_VERSION);
+			exit(EXIT_SUCCESS);
+			break;
+		default:
+		case '?':
+			usage(stderr);
+			break;
+		}
+	}
+
+	/* check for a single additional argument */
+	if ((argc - optind) > 1)
+		errx(EXIT_FAILURE, _("too many arguments"));
+
+	if ((argc - optind) == 1)
+		*device = xstrdup(argv[optind]);
+}
+
+/*
+ * Given name, such as foo, see if any of the following exist:
+ *
+ * foo (if foo starts with '.' or '/')
+ * /dev/foo
+ *
+ * If found, return the full path. If not found, return 0.
+ * Returns pointer to dynamically allocated string.
+ */
+static char *find_device(const char *name)
+{
+	if (!name)
+		return NULL;
+
+	if ((*name == '.' || *name == '/') && access(name, F_OK) == 0)
+		return xstrdup(name);
+	else {
+		char buf[PATH_MAX];
+
+		snprintf(buf, sizeof(buf), "/dev/%s", name);
+		if (access(buf, F_OK) == 0)
+			return xstrdup(buf);
+	}
+
+	return NULL;
+}
+
+/* Set or clear auto-eject mode. */
+static void auto_eject(int fd, int on)
+{
+	int status = -1;
+
+#if defined(CDROM_SET_OPTIONS) && defined(CDROM_CLEAR_OPTIONS)
+	if (on)
+		status = ioctl(fd, CDROM_SET_OPTIONS, CDO_AUTO_EJECT);
+	else
+		status = ioctl(fd, CDROM_CLEAR_OPTIONS, CDO_AUTO_EJECT);
+#else
+	errno = ENOSYS;
+#endif
+	if (status < 0)
+		err(EXIT_FAILURE,_("CD-ROM auto-eject command failed"));
+}
+
+/*
+ * Stops CDROM from opening on manual eject pressing the button.
+ * This can be useful when you carry your laptop
+ * in your bag while it's on and no CD inserted in it's drive.
+ * Implemented as found in Documentation/ioctl/cdrom.txt
+ *
+ * TODO: Maybe we should check this also:
+ * EDRIVE_CANT_DO_THIS   Door lock function not supported.
+ * EBUSY                 Attempt to unlock when multiple users
+ *                       have the drive open and not CAP_SYS_ADMIN
+ */
+static void manual_eject(int fd, int on)
+{
+	if (ioctl(fd, CDROM_LOCKDOOR, on) < 0)
+		err(EXIT_FAILURE, _("CD-ROM lock door command failed"));
+
+	if (on)
+		info(_("CD-Drive may NOT be ejected with device button"));
+	else
+		info(_("CD-Drive may be ejected with device button"));
+}
+
+/*
+ * Changer select. CDROM_SELECT_DISC is preferred, older kernels used
+ * CDROMLOADFROMSLOT.
+ */
+static void changer_select(int fd, int slot)
+{
+#ifdef CDROM_SELECT_DISC
+	if (ioctl(fd, CDROM_SELECT_DISC, slot) < 0)
+		err(EXIT_FAILURE, _("CD-ROM select disc command failed"));
+
+#elif defined CDROMLOADFROMSLOT
+	if (ioctl(fd, CDROMLOADFROMSLOT, slot) != 0)
+		err(EXIT_FAILURE, _("CD-ROM load from slot command failed"));
+#else
+	warnx(_("IDE/ATAPI CD-ROM changer not supported by this kernel\n") );
+#endif
+}
+
+/*
+ * Close tray. Not supported by older kernels.
+ */
+static void close_tray(int fd)
+{
+	int status;
+
+#if defined(CDROMCLOSETRAY) || defined(CDIOCCLOSE)
+#if defined(CDROMCLOSETRAY)
+	status = ioctl(fd, CDROMCLOSETRAY);
+#elif defined(CDIOCCLOSE)
+	status = ioctl(fd, CDIOCCLOSE);
+#endif
+	if (status != 0)
+		err(EXIT_FAILURE, _("CD-ROM tray close command failed"));
+#else
+	warnx(_("CD-ROM tray close command not supported by this kernel\n"));
+#endif
+}
+
+/*
+ * Toggle tray.
+ *
+ * Written by Benjamin Schwenk <benjaminschwenk@yahoo.de> and
+ * Sybren Stuvel <sybren@thirdtower.com>
+ *
+ * Not supported by older kernels because it might use
+ * CloseTray().
+ *
+ */
+static void toggle_tray(int fd)
+{
+	struct timeval time_start, time_stop;
+	int time_elapsed;
+
+#ifdef CDROMCLOSETRAY
+	/* Try to open the CDROM tray and measure the time therefor
+	 * needed.  In my experience the function needs less than 0.05
+	 * seconds if the tray was already open, and at least 1.5 seconds
+	 * if it was closed.  */
+	gettimeofday(&time_start, NULL);
+
+	/* Send the CDROMEJECT command to the device. */
+	if (ioctl(fd, CDROMEJECT, 0) < 0)
+		err(EXIT_FAILURE, _("CD-ROM eject command failed"));
+
+	/* Get the second timestamp, to measure the time needed to open
+	 * the tray.  */
+	gettimeofday(&time_stop, NULL);
+
+	time_elapsed = (time_stop.tv_sec * 1000000 + time_stop.tv_usec) -
+		(time_start.tv_sec * 1000000 + time_start.tv_usec);
+
+	/* If the tray "opened" too fast, we can be nearly sure, that it
+	 * was already open. In this case, close it now. Else the tray was
+	 * closed before. This would mean that we are done.  */
+	if (time_elapsed < TRAY_WAS_ALREADY_OPEN_USECS)
+		close_tray(fd);
+#else
+	warnx(_("CD-ROM tray toggle command not supported by this kernel"));
+#endif
+
+}
+
+/*
+ * Select Speed of CD-ROM drive.
+ * Thanks to Roland Krivanek (krivanek@fmph.uniba.sk)
+ * http://dmpc.dbp.fmph.uniba.sk/~krivanek/cdrom_speed/
+ */
+static void select_speed(int fd, int speed)
+{
+#ifdef CDROM_SELECT_SPEED
+	if (ioctl(fd, CDROM_SELECT_SPEED, speed) != 0)
+		err(EXIT_FAILURE, _("CD-ROM select speed command failed"));
+#else
+	warnx(_("CD-ROM select speed command not supported by this kernel"));
+#endif
+}
+
+/*
+ * Read Speed of CD-ROM drive. From Linux 2.6.13, the current speed
+ * is correctly reported
+ */
+static int read_speed(const char *devname)
+{
+	int drive_number = -1;
+	char *name;
+	FILE *f;
+
+	f = fopen(_PATH_PROC_CDROMINFO, "r");
+	if (!f)
+		err(EXIT_FAILURE, _("%s: open failed"), _PATH_PROC_CDROMINFO);
+
+	name = rindex(devname, '/') + 1;
+
+	while (!feof(f)) {
+		char line[512];
+		char *str;
+
+		if (!fgets(line, sizeof(line), f))
+			break;
+
+		/* find drive number in line "drive name" */
+		if (drive_number == -1) {
+			if (strncmp(line, "drive name:", 11) == 0) {
+				str = strtok(&line[11], "\t ");
+				drive_number = 0;
+				while (strncmp(name, str, strlen(name)) != 0) {
+					drive_number++;
+					str = strtok(NULL, "\t ");
+					if (!str)
+						errx(EXIT_FAILURE,
+						     _("%s: failed to finding CD-ROM name"),
+						     _PATH_PROC_CDROMINFO);
+				}
+			}
+		/* find line "drive speed" and read the correct speed */
+		} else {
+			if (strncmp(line, "drive speed:", 12) == 0) {
+				int i;
+				char *str;
+
+				str = strtok(&line[12], "\t ");
+				for (i = 1; i < drive_number; i++)
+					str = strtok(NULL, "\t ");
+
+				if (!str)
+					errx(EXIT_FAILURE,
+						_("%s: failed to read speed"),
+						_PATH_PROC_CDROMINFO);
+				return atoi(str);
+			}
+		}
+	}
+
+	errx(EXIT_FAILURE, _("failed to read speed"));
+}
+
+/*
+ * List Speed of CD-ROM drive.
+ */
+static void list_speeds(const char *name, int fd)
+{
+#ifdef CDROM_SELECT_SPEED
+	int max_speed, curr_speed = 0, prev_speed;
+
+	select_speed(fd, 0);
+	max_speed = read_speed(name);
+
+	while (curr_speed < max_speed) {
+		prev_speed = curr_speed;
+		select_speed(fd, prev_speed + 1);
+		curr_speed = read_speed(name);
+		if (curr_speed > prev_speed)
+			printf("%d ", curr_speed);
+		else
+			curr_speed = prev_speed + 1;
+	}
+
+	printf("\n");
+#else
+	warnx(_("CD-ROM select speed command not supported by this kernel"));
+#endif
+}
+
+/*
+ * Eject using CDROMEJECT ioctl. Return 1 if successful, 0 otherwise.
+ */
+static int eject_cdrom(int fd)
+{
+#if defined(CDROMEJECT)
+	return ioctl(fd, CDROMEJECT) == 0;
+#elif defined(CDIOCEJECT)
+	return ioctl(fd, CDIOCEJECT) == 0;
+#else
+	warnx(_("CD-ROM eject unsupported"));
+#endif
+}
+
+/*
+ * Eject using SCSI SG_IO commands. Return 1 if successful, 0 otherwise.
+ */
+static int eject_scsi(int fd)
+{
+	int status, k;
+	sg_io_hdr_t io_hdr;
+	unsigned char allowRmBlk[6] = {ALLOW_MEDIUM_REMOVAL, 0, 0, 0, 0, 0};
+	unsigned char startStop1Blk[6] = {START_STOP, 0, 0, 0, 1, 0};
+	unsigned char startStop2Blk[6] = {START_STOP, 0, 0, 0, 2, 0};
+	unsigned char inqBuff[2];
+	unsigned char sense_buffer[32];
+
+	if ((ioctl(fd, SG_GET_VERSION_NUM, &k) < 0) || (k < 30000)) {
+		verbose(_("not an sg device, or old sg driver"));
+		return 0;
+	}
+
+	memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
+	io_hdr.interface_id = 'S';
+	io_hdr.cmd_len = 6;
+	io_hdr.mx_sb_len = sizeof(sense_buffer);
+	io_hdr.dxfer_direction = SG_DXFER_NONE;
+	io_hdr.dxfer_len = 0;
+	io_hdr.dxferp = inqBuff;
+	io_hdr.sbp = sense_buffer;
+	io_hdr.timeout = 10000;
+
+	io_hdr.cmdp = allowRmBlk;
+	status = ioctl(fd, SG_IO, (void *)&io_hdr);
+	if (status < 0)
+		return 0;
+
+	io_hdr.cmdp = startStop1Blk;
+	status = ioctl(fd, SG_IO, (void *)&io_hdr);
+	if (status < 0)
+		return 0;
+
+	io_hdr.cmdp = startStop2Blk;
+	status = ioctl(fd, SG_IO, (void *)&io_hdr);
+	if (status < 0)
+		return 0;
+
+	/* force kernel to reread partition table when new disc inserted */
+	status = ioctl(fd, BLKRRPART);
+	return 1;
+}
+
+/*
+ * Eject using FDEJECT ioctl. Return 1 if successful, 0 otherwise.
+ */
+static int eject_floppy(int fd)
+{
+	return ioctl(fd, FDEJECT) >= 0;
+}
+
+
+/*
+ * Rewind and eject using tape ioctl. Return 1 if successful, 0 otherwise.
+ */
+static int eject_tape(int fd)
+{
+	struct mtop op = { .mt_op = MTOFFL, .mt_count = 0 };
+
+	return ioctl(fd, MTIOCTOP, &op) >= 0;
+}
+
+
+/* umount a device. */
+static void umount_one(const char *name)
+{
+	int status;
+
+	if (!name)
+		return;
+
+	verbose(_("%s: unmounting"), name);
+
+	switch (fork()) {
+	case 0: /* child */
+		if (setgid(getgid()) < 0)
+			err(EXIT_FAILURE, _("cannot set group id"));
+
+		if (setuid(getuid()) < 0)
+			err(EXIT_FAILURE, _("eject: cannot set user id"));
+
+		if (p_option)
+			execl("/bin/umount", "/bin/umount", name, "-n", NULL);
+		else
+			execl("/bin/umount", "/bin/umount", name, NULL);
+
+		errx(EXIT_FAILURE, _("unable to exec /bin/umount of `%s'"), name);
+
+	case -1:
+		warn( _("unable to fork"));
+		break;
+
+	default: /* parent */
+		wait(&status);
+		if (WIFEXITED(status) == 0)
+			errx(EXIT_FAILURE,
+			     _("unmount of `%s' did not exit normally"), name);
+
+		if (WEXITSTATUS(status) != 0)
+			errx(EXIT_FAILURE, _("unmount of `%s' failed\n"), name);
+		break;
+	}
+}
+
+/* Open a device file. */
+static int open_device(const char *name)
+{
+	int fd = open(name, O_RDWR|O_NONBLOCK);
+
+	if (fd < 0)
+		fd = open(name, O_RDONLY|O_NONBLOCK);
+	if (fd == -1)
+		errx(EXIT_FAILURE, _("%s: open failed"), name);
+	return fd;
+}
+
+/*
+ * See if device has been mounted by looking in mount table.  If so, set
+ * device name and mount point name, and return 1, otherwise return 0.
+ */
+static int device_get_mountpoint(char **devname, char **mnt)
+{
+	struct libmnt_fs *fs;
+	int rc;
+
+	*mnt = NULL;
+
+	if (!mtab) {
+		mtab = mnt_new_table();
+		if (!mtab)
+			err(EXIT_FAILURE, _("failed to initialize libmount table"));
+
+		cache = mnt_new_cache();
+		mnt_table_set_cache(mtab, cache);
+
+		if (p_option)
+			rc = mnt_table_parse_file(mtab, _PATH_PROC_MOUNTINFO);
+		else
+			rc = mnt_table_parse_mtab(mtab, NULL);
+		if (rc)
+			err(EXIT_FAILURE, _("failed to parse mount table"));
+	}
+
+	fs = mnt_table_find_source(mtab, *devname, MNT_ITER_BACKWARD);
+	if (!fs) {
+		/* maybe 'devname' is mountpoint rather than a real device */
+		fs = mnt_table_find_target(mtab, *devname, MNT_ITER_BACKWARD);
+		if (fs) {
+			free(*devname);
+			*devname = xstrdup(mnt_fs_get_source(fs));
+		}
+	}
+
+	if (fs) {
+		*mnt = xstrdup(mnt_fs_get_target(fs));
+		/* We'll call umount(), so remove the filesystem from the table
+		 * to avoid duplicate results in the next device_get_mountpoint()
+		 * call */
+		mnt_free_fs(fs);
+	}
+	return *mnt ? 0 : -1;
+}
+
+static char *get_disk_devname(const char *device)
+{
+	struct stat st;
+	dev_t diskno = 0;
+	char diskname[128];
+
+	if (stat(device, &st) != 0)
+		return NULL;
+
+	/* get whole-disk devno */
+	if (sysfs_devno_to_wholedisk(st.st_rdev, diskname,
+				sizeof(diskname), &diskno) != 0)
+		return NULL;
+
+	return st.st_rdev == diskno ? NULL : find_device(diskname);
+}
+
+static void umount_partitions(const char *disk)
+{
+	struct sysfs_cxt cxt = UL_SYSFSCXT_EMPTY;
+	dev_t devno;
+	DIR *dir = NULL;
+	struct dirent *d;
+
+	devno = sysfs_devname_to_devno(disk, NULL);
+	if (sysfs_init(&cxt, devno, NULL) != 0)
+		return;
+
+	/* open /sys/block/<wholedisk> */
+	if (!(dir = sysfs_opendir(&cxt, NULL)))
+		goto done;
+
+	/* scan for partition subdirs */
+	while ((d = readdir(dir))) {
+		if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
+			continue;
+
+		if (sysfs_is_partition_dirent(dir, d, disk)) {
+			char *mnt = NULL;
+			char *dev = find_device(d->d_name);
+
+			if (dev && device_get_mountpoint(&dev, &mnt) == 0) {
+				verbose(_("%s: mounted at %s"), dev, mnt);
+				umount_one(mnt);
+			}
+			free(dev);
+		}
+	}
+
+done:
+	if (dir)
+		closedir(dir);
+	sysfs_deinit(&cxt);
+}
+
+static int is_hotpluggable_subsystem(const char *name)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(hotplug_subsystems); i++)
+		if (strcmp(name, hotplug_subsystems[i]) == 0)
+			return 1;
+
+	return 0;
+}
+
+#define SUBSYSTEM_LINKNAME	"/subsystem"
+
+/*
+ * For example:
+ *
+ * chain: /sys/dev/block/../../devices/pci0000:00/0000:00:1a.0/usb1/1-1/1-1.2/ \
+ *                           1-1.2:1.0/host65/target65:0:0/65:0:0:0/block/sdb
+ *
+ * The function check if <chain>/subsystem symlink exists, if yes then returns
+ * basename of the readlink result, and remove the last subdirectory from the
+ * <chain> path.
+ */
+static char *get_subsystem(char *chain, char *buf, size_t bufsz)
+{
+	size_t len;
+	char *p;
+
+	if (!chain || !*chain)
+		return NULL;
+
+	len = strlen(chain);
+	if (len + sizeof(SUBSYSTEM_LINKNAME) > PATH_MAX)
+		return NULL;
+
+	do {
+		ssize_t sz;
+
+		/* append "/subsystem" to the path */
+		memcpy(chain + len, SUBSYSTEM_LINKNAME, sizeof(SUBSYSTEM_LINKNAME));
+
+		/* try if subsystem symlink exists */
+		sz = readlink(chain, buf, bufsz);
+
+		/* remove last subsystem from chain */
+		chain[len] = '\0';
+		p = strrchr(chain, '/');
+		if (p) {
+			*p = '\0';
+			len = p - chain;
+		}
+
+		if (sz > 0) {
+			/* we found symlink to subsystem, return basename */
+			buf[sz] = '\0';
+			return basename(buf);
+		}
+
+	} while (p);
+
+	return NULL;
+}
+
+static int is_hotpluggable(const char* device)
+{
+	struct sysfs_cxt cxt = UL_SYSFSCXT_EMPTY;
+	char devchain[PATH_MAX];
+	char subbuf[PATH_MAX];
+	dev_t devno;
+	int rc = 0;
+	ssize_t sz;
+	char *sub;
+
+	devno = sysfs_devname_to_devno(device, NULL);
+	if (sysfs_init(&cxt, devno, NULL) != 0)
+		return 0;
+
+	/* check /sys/dev/block/<maj>:<min>/removable attribute */
+	if (sysfs_read_int(&cxt, "removable", &rc) == 0 && rc == 1) {
+		verbose(_("%s: is removable device"), device);
+		goto done;
+	}
+
+	/* read /sys/dev/block/<maj>:<min> symlink */
+	sz = sysfs_readlink(&cxt, NULL, devchain, sizeof(devchain));
+	if (sz <= 0 || sz + sizeof(_PATH_SYS_DEVBLOCK "/") > sizeof(devchain))
+		goto done;
+
+	devchain[sz++] = '\0';
+
+	/* create absolute patch from the link */
+	memmove(devchain + sizeof(_PATH_SYS_DEVBLOCK "/") - 1, devchain, sz);
+	memcpy(devchain, _PATH_SYS_DEVBLOCK "/",
+	       sizeof(_PATH_SYS_DEVBLOCK "/") - 1);
+
+	while ((sub = get_subsystem(devchain, subbuf, sizeof(subbuf)))) {
+		rc = is_hotpluggable_subsystem(sub);
+		if (rc) {
+			verbose(_("%s: connected by hotplug subsystem: %s"),
+				device, sub);
+			break;
+		}
+	}
+
+done:
+	sysfs_deinit(&cxt);
+	return rc;
+}
+
+
+/* handle -x option */
+void set_device_speed(char *name)
+{
+	int fd;
+
+	if (!x_option)
+		return;
+
+	if (x_arg == 0)
+		verbose(_("setting CD-ROM speed to auto"));
+	else
+		verbose(_("setting CD-ROM speed to %ldX"), x_arg);
+
+	fd = open_device(name);
+	select_speed(fd, x_arg);
+	exit(EXIT_SUCCESS);
+}
+
+
+/* main program */
+int main(int argc, char **argv)
+{
+	char *device = NULL;
+	char *disk = NULL;
+	char *mountpoint = NULL;
+	int worked = 0;    /* set to 1 when successfully ejected */
+	int fd;            /* file descriptor for device */
+
+	setlocale(LC_ALL,"");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+
+	/* parse the command line arguments */
+	parse_args(argc, argv, &device);
+
+	/* handle -d option */
+	if (d_option) {
+		info(_("default device: `%s'"), EJECT_DEFAULT_DEVICE);
+		return EXIT_SUCCESS;
+	}
+
+	if (!device) {
+		device = mnt_resolve_path(EJECT_DEFAULT_DEVICE, NULL);
+		verbose(_("using default device `%s'"), device);
+	} else {
+		char *p;
+
+		if (device[strlen(device)-1] == '/')
+			device[strlen(device)-1] = '\0';
+
+		/* figure out full device or mount point name */
+		p = find_device(device);
+		free(device);
+
+		device = mnt_resolve_path(p, NULL);
+		free(p);
+	}
+
+	if (!device)
+		errx(EXIT_FAILURE, _("%s: unable to find device"), device);
+
+	verbose(_("device name is `%s'"), device);
+
+	device_get_mountpoint(&device, &mountpoint);
+	if (mountpoint)
+		verbose(_("%s: mounted at %s"), device, mountpoint);
+	else
+		verbose(_("%s: not mounted"), device);
+
+	disk = get_disk_devname(device);
+	if (disk) {
+		verbose(_("%s: disc device: %s (disk device will be used for eject)"), device, disk);
+		free(device);
+		device = disk;
+		disk = NULL;
+	} else
+		verbose(_("%s: is whole-disk device"), device);
+
+	if (F_option == 0 && is_hotpluggable(device) == 0)
+		errx(EXIT_FAILURE, _("%s: is not hot-pluggable device"), device);
+
+	/* handle -n option */
+	if (n_option) {
+		info(_("device is `%s'"), device);
+		verbose(_("exiting due to -n/--noop option"));
+		return EXIT_SUCCESS;
+	}
+
+	/* handle -i option */
+	if (i_option) {
+		fd = open_device(device);
+		manual_eject(fd, i_arg);
+		return EXIT_SUCCESS;
+	}
+
+	/* handle -a option */
+	if (a_option) {
+		if (a_arg)
+			verbose(_("%s: enabling auto-eject mode"), device);
+		else
+			verbose(_("%s: disabling auto-eject mode"), device);
+		fd = open_device(device);
+		auto_eject(fd, a_arg);
+		return EXIT_SUCCESS;
+	}
+
+	/* handle -t option */
+	if (t_option) {
+		verbose(_("%s: closing tray"), device);
+		fd = open_device(device);
+		close_tray(fd);
+		set_device_speed(device);
+		return EXIT_SUCCESS;
+	}
+
+	/* handle -T option */
+	if (T_option) {
+		verbose(_("%s: toggling tray"), device);
+		fd = open_device(device);
+		toggle_tray(fd);
+		set_device_speed(device);
+		return EXIT_SUCCESS;
+	}
+
+	/* handle -X option */
+	if (X_option) {
+		verbose(_("%s: listing CD-ROM speed"), device);
+		fd = open_device(device);
+		list_speeds(device, fd);
+		return EXIT_SUCCESS;
+	}
+
+	/* handle -x option only */
+	if (!c_option)
+		set_device_speed(device);
+
+
+	/* if it is a multipartition device, unmount any other partitions on
+	   the device */
+	if (m_option != 1) {
+		if (mountpoint)
+			umount_one(mountpoint);		/* usually whole-disk */
+		umount_partitions(device);
+	}
+
+	/* handle -c option */
+	if (c_option) {
+		verbose(_("%s: selecting CD-ROM disc #%ld"), device, c_arg);
+		fd = open_device(device);
+		changer_select(fd, c_arg);
+		set_device_speed(device);
+		return EXIT_SUCCESS;
+	}
+
+	/* if user did not specify type of eject, try all four methods */
+	if (r_option + s_option + f_option + q_option == 0)
+		r_option = s_option = f_option = q_option = 1;
+
+	/* open device */
+	fd = open_device(device);
+
+	/* try various methods of ejecting until it works */
+	if (r_option) {
+		verbose(_("%s: trying to eject using CD-ROM eject command"), device);
+		worked = eject_cdrom(fd);
+		verbose(worked ? _("CD-ROM eject command succeeded") :
+				 _("CD-ROM eject command failed"));
+	}
+
+	if (s_option && !worked) {
+		verbose(_("%s: trying to eject using SCSI commands"), device);
+		worked = eject_scsi(fd);
+		verbose(worked ? _("SCSI eject succeeded") :
+				 _("SCSI eject failed"));
+	}
+
+	if (f_option && !worked) {
+		verbose(_("%s: trying to eject using floppy eject command"), device);
+		worked = eject_floppy(fd);
+		verbose(worked ? _("floppy eject command succeeded") :
+				 _("floppy eject command failed"));
+	}
+
+	if (q_option && !worked) {
+		verbose(_("%s: trying to eject using tape offline command"), device);
+		worked = eject_tape(fd);
+		verbose(worked ? _("tape offline command succeeded") :
+				 _("tape offline command failed"));
+	}
+
+	if (!worked)
+		errx(EXIT_FAILURE, _("unable to eject"));
+
+	/* cleanup */
+	close(fd);
+	free(device);
+	free(mountpoint);
+
+	mnt_free_table(mtab);
+	mnt_free_cache(cache);
+
+	return EXIT_SUCCESS;
+}