From 88a3f049ec48b59eb9373d342e52759c1f9261ec Mon Sep 17 00:00:00 2001 From: Karel Zak Date: Thu, 5 Apr 2012 15:39:44 +0200 Subject: eject: use BUILD_EJECT, move to sys-utils Signed-off-by: Karel Zak --- sys-utils/eject.c | 1082 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1082 insertions(+) create mode 100644 sys-utils/eject.c (limited to 'sys-utils/eject.c') 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 + * Copyright (C) Michal Luscon + * + * 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#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] [|]\n"), program_invocation_short_name); + + fputs(USAGE_OPTIONS, out); + fputs(_(" -a, --auto turn auto-eject feature on or off\n" + " -c, --changerslot 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 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 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 and + * Sybren Stuvel + * + * 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/ */ + 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 /subsystem symlink exists, if yes then returns + * basename of the readlink result, and remove the last subdirectory from the + * 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/:/removable attribute */ + if (sysfs_read_int(&cxt, "removable", &rc) == 0 && rc == 1) { + verbose(_("%s: is removable device"), device); + goto done; + } + + /* read /sys/dev/block/: 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; +} -- cgit v1.2.3-55-g7522