| /* |
| * 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 "closestream.h" |
| #include "nls.h" |
| #include "strutils.h" |
| #include "xalloc.h" |
| #include "pathnames.h" |
| #include "sysfs.h" |
| #include "monotonic.h" |
| |
| /* |
| * sg_io_hdr_t driver_status -- see kernel include/scsi/scsi.h |
| */ |
| #ifndef DRIVER_SENSE |
| # define DRIVER_SENSE 0x08 |
| #endif |
| |
| |
| #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 */ |
| |
| struct eject_control { |
| struct libmnt_table *mtab; |
| char *device; /* device or mount point to be ejected */ |
| int fd; /* file descriptor for device */ |
| unsigned int /* command flags and arguments */ |
| a_option:1, |
| c_option:1, |
| d_option:1, |
| F_option:1, |
| f_option:1, |
| i_option:1, |
| M_option:1, |
| m_option:1, |
| n_option:1, |
| p_option:1, |
| q_option:1, |
| r_option:1, |
| s_option:1, |
| T_option:1, |
| t_option:1, |
| v_option:1, |
| X_option:1, |
| x_option:1, |
| a_arg:1, |
| i_arg:1; |
| long int c_arg; /* changer slot number */ |
| long int x_arg; /* cd speed */ |
| }; |
| |
| 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 struct eject_control *ctl, const char *fmt, ...) |
| { |
| va_list va; |
| |
| if (!ctl->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_SEPARATOR, out); |
| fputs(_("Eject removable media.\n"), out); |
| |
| 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" |
| " -M, --no-partitions-unmount do not unmount another partitions\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(struct eject_control *ctl, int argc, char **argv) |
| { |
| 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'}, |
| {"no-partitions-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:dfFhnqrstTXvVpmM", long_opts, NULL)) != -1) { |
| switch (c) { |
| case 'a': |
| ctl->a_option = 1; |
| ctl->a_arg = parse_switch(optarg, _("argument error"), |
| "on", "off", "1", "0", NULL); |
| break; |
| case 'c': |
| ctl->c_option = 1; |
| ctl->c_arg = strtoul_or_err(optarg, _("invalid argument to --changerslot/-c option")); |
| break; |
| case 'x': |
| ctl->x_option = 1; |
| ctl->x_arg = strtoul_or_err(optarg, _("invalid argument to --cdspeed/-x option")); |
| break; |
| case 'd': |
| ctl->d_option = 1; |
| break; |
| case 'f': |
| ctl->f_option = 1; |
| break; |
| case 'F': |
| ctl->F_option = 1; |
| break; |
| case 'h': |
| usage(stdout); |
| break; |
| case 'i': |
| ctl->i_option = 1; |
| ctl->i_arg = parse_switch(optarg, _("argument error"), |
| "on", "off", "1", "0", NULL); |
| break; |
| case 'm': |
| ctl->m_option = 1; |
| break; |
| case 'M': |
| ctl->M_option = 1; |
| break; |
| case 'n': |
| ctl->n_option = 1; |
| break; |
| case 'p': |
| ctl->p_option = 1; |
| break; |
| case 'q': |
| ctl->q_option = 1; |
| break; |
| case 'r': |
| ctl->r_option = 1; |
| break; |
| case 's': |
| ctl->s_option = 1; |
| break; |
| case 't': |
| ctl->t_option = 1; |
| break; |
| case 'T': |
| ctl->T_option = 1; |
| break; |
| case 'X': |
| ctl->X_option = 1; |
| break; |
| case 'v': |
| ctl->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) |
| ctl->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(const struct eject_control *ctl) |
| { |
| int status = -1; |
| |
| #if defined(CDROM_SET_OPTIONS) && defined(CDROM_CLEAR_OPTIONS) |
| if (ctl->a_arg) |
| status = ioctl(ctl->fd, CDROM_SET_OPTIONS, CDO_AUTO_EJECT); |
| else |
| status = ioctl(ctl->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 button press. |
| * 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 |
| */ |
| static void manual_eject(const struct eject_control *ctl) |
| { |
| if (ioctl(ctl->fd, CDROM_LOCKDOOR, ctl->i_arg) < 0) { |
| switch (errno) { |
| case EDRIVE_CANT_DO_THIS: |
| errx(EXIT_FAILURE, _("CD-ROM door lock is not supported")); |
| case EBUSY: |
| errx(EXIT_FAILURE, _("other users have the drive open and not CAP_SYS_ADMIN")); |
| default: |
| err(EXIT_FAILURE, _("CD-ROM lock door command failed")); |
| } |
| } |
| |
| if (ctl->i_arg) |
| 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(const struct eject_control *ctl) |
| { |
| #ifdef CDROM_SELECT_DISC |
| if (ioctl(ctl->fd, CDROM_SELECT_DISC, ctl->c_arg) < 0) |
| err(EXIT_FAILURE, _("CD-ROM select disc command failed")); |
| |
| #elif defined CDROMLOADFROMSLOT |
| if (ioctl(ctl->fd, CDROMLOADFROMSLOT, ctl->c_arg) != 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 |
| } |
| |
| /* |
| * Eject using CDROMEJECT ioctl. |
| */ |
| static int eject_cdrom(int fd) |
| { |
| #if defined(CDROMEJECT) |
| int ret = ioctl(fd, CDROM_LOCKDOOR, 0); |
| if (ret < 0) |
| return 0; |
| return ioctl(fd, CDROMEJECT) >= 0; |
| #elif defined(CDIOCEJECT) |
| return ioctl(fd, CDIOCEJECT) >= 0; |
| #else |
| warnx(_("CD-ROM eject unsupported")); |
| errno = ENOSYS; |
| return 0; |
| #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) |
| { |
| #ifdef CDROM_DRIVE_STATUS |
| /* First ask the CDROM for info, otherwise fall back to manual. */ |
| switch (ioctl(fd, CDROM_DRIVE_STATUS)) { |
| case CDS_TRAY_OPEN: |
| close_tray(fd); |
| return; |
| |
| case CDS_NO_DISC: |
| case CDS_DISC_OK: |
| if (!eject_cdrom(fd)) |
| err(EXIT_FAILURE, _("CD-ROM eject command failed")); |
| return; |
| case CDS_NO_INFO: |
| warnx(_("no CD-ROM information available")); |
| return; |
| case CDS_DRIVE_NOT_READY: |
| warnx(_("CD-ROM drive is not ready")); |
| return; |
| default: |
| abort(); |
| } |
| #else |
| struct timeval time_start, time_stop; |
| int time_elapsed; |
| |
| /* 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. */ |
| gettime_monotonic(&time_start); |
| |
| /* Send the CDROMEJECT command to the device. */ |
| if (!eject_cdrom(fd)) |
| err(EXIT_FAILURE, _("CD-ROM eject command failed")); |
| |
| /* Get the second timestamp, to measure the time needed to open |
| * the tray. */ |
| gettime_monotonic(&time_stop); |
| |
| 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); |
| #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(const struct eject_control *ctl) |
| { |
| #ifdef CDROM_SELECT_SPEED |
| if (ioctl(ctl->fd, CDROM_SELECT_SPEED, ctl->x_arg) != 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, _("cannot open %s"), _PATH_PROC_CDROMINFO); |
| |
| name = strrchr(devname, '/') + 1; |
| |
| while (name && !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 (str && 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; |
| |
| 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); |
| fclose(f); |
| return atoi(str); |
| } |
| } |
| } |
| |
| errx(EXIT_FAILURE, _("failed to read speed")); |
| } |
| |
| /* |
| * List Speed of CD-ROM drive. |
| */ |
| static void list_speeds(struct eject_control *ctl) |
| { |
| #ifdef CDROM_SELECT_SPEED |
| int max_speed, curr_speed = 0; |
| |
| select_speed(ctl); |
| max_speed = read_speed(ctl->device); |
| |
| while (curr_speed < max_speed) { |
| ctl->x_arg = curr_speed + 1; |
| select_speed(ctl); |
| curr_speed = read_speed(ctl->device); |
| if (ctl->x_arg < curr_speed) |
| printf("%d ", curr_speed); |
| else |
| curr_speed = ctl->x_arg + 1; |
| } |
| |
| printf("\n"); |
| #else |
| warnx(_("CD-ROM select speed command not supported by this kernel")); |
| #endif |
| } |
| |
| /* |
| * Eject using SCSI SG_IO commands. Return 1 if successful, 0 otherwise. |
| */ |
| static int eject_scsi(const struct eject_control *ctl) |
| { |
| 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(ctl->fd, SG_GET_VERSION_NUM, &k) < 0) || (k < 30000)) { |
| verbose(ctl, _("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(ctl->fd, SG_IO, (void *)&io_hdr); |
| if (status < 0 || io_hdr.host_status || io_hdr.driver_status) |
| return 0; |
| |
| io_hdr.cmdp = startStop1Blk; |
| status = ioctl(ctl->fd, SG_IO, (void *)&io_hdr); |
| if (status < 0 || io_hdr.host_status) |
| return 0; |
| |
| /* Ignore errors when there is not medium -- in this case driver sense |
| * buffer sets MEDIUM NOT PRESENT (3a) bit. For more details see: |
| * http://www.tldp.org/HOWTO/archived/SCSI-Programming-HOWTO/SCSI-Programming-HOWTO-22.html#sec-sensecodes |
| * -- kzak Jun 2013 |
| */ |
| if (io_hdr.driver_status != 0 && |
| !(io_hdr.driver_status == DRIVER_SENSE && io_hdr.sbp && |
| io_hdr.sbp[12] == 0x3a)) |
| return 0; |
| |
| io_hdr.cmdp = startStop2Blk; |
| status = ioctl(ctl->fd, SG_IO, (void *)&io_hdr); |
| if (status < 0 || io_hdr.host_status || io_hdr.driver_status) |
| return 0; |
| |
| /* force kernel to reread partition table when new disc inserted */ |
| ioctl(ctl->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 struct eject_control *ctl, const char *name) |
| { |
| int status; |
| |
| if (!name) |
| return; |
| |
| verbose(ctl, _("%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, _("cannot set user id")); |
| |
| if (ctl->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 void open_device(struct eject_control *ctl) |
| { |
| ctl->fd = open(ctl->device, O_RDWR | O_NONBLOCK); |
| if (ctl->fd < 0) |
| ctl->fd = open(ctl->device, O_RDONLY | O_NONBLOCK); |
| if (ctl->fd == -1) |
| err(EXIT_FAILURE, _("cannot open %s"), ctl->device); |
| } |
| |
| /* |
| * 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(struct eject_control *ctl, char **devname, char **mnt) |
| { |
| struct libmnt_fs *fs; |
| int rc; |
| |
| *mnt = NULL; |
| |
| if (!ctl->mtab) { |
| struct libmnt_cache *cache; |
| |
| ctl->mtab = mnt_new_table(); |
| if (!ctl->mtab) |
| err(EXIT_FAILURE, _("failed to initialize libmount table")); |
| |
| cache = mnt_new_cache(); |
| mnt_table_set_cache(ctl->mtab, cache); |
| mnt_unref_cache(cache); |
| |
| if (ctl->p_option) |
| rc = mnt_table_parse_file(ctl->mtab, _PATH_PROC_MOUNTINFO); |
| else |
| rc = mnt_table_parse_mtab(ctl->mtab, NULL); |
| if (rc) |
| err(EXIT_FAILURE, _("failed to parse mount table")); |
| } |
| |
| fs = mnt_table_find_source(ctl->mtab, *devname, MNT_ITER_BACKWARD); |
| if (!fs) { |
| /* maybe 'devname' is mountpoint rather than a real device */ |
| fs = mnt_table_find_target(ctl->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)); |
| 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 int umount_partitions(struct eject_control *ctl) |
| { |
| struct sysfs_cxt cxt = UL_SYSFSCXT_EMPTY; |
| dev_t devno; |
| DIR *dir = NULL; |
| struct dirent *d; |
| int count = 0; |
| |
| devno = sysfs_devname_to_devno(ctl->device, NULL); |
| if (sysfs_init(&cxt, devno, NULL) != 0) |
| return 0; |
| |
| /* 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, ctl->device)) { |
| char *mnt = NULL; |
| char *dev = find_device(d->d_name); |
| |
| if (dev && device_get_mountpoint(ctl, &dev, &mnt) == 0) { |
| verbose(ctl, _("%s: mounted on %s"), dev, mnt); |
| if (!ctl->M_option) |
| umount_one(ctl, mnt); |
| count++; |
| } |
| free(dev); |
| free(mnt); |
| } |
| } |
| |
| done: |
| if (dir) |
| closedir(dir); |
| sysfs_deinit(&cxt); |
| |
| return count; |
| } |
| |
| static int is_hotpluggable(const struct eject_control *ctl) |
| { |
| struct sysfs_cxt cxt = UL_SYSFSCXT_EMPTY; |
| dev_t devno; |
| int rc = 0; |
| |
| devno = sysfs_devname_to_devno(ctl->device, NULL); |
| if (sysfs_init(&cxt, devno, NULL) != 0) |
| return 0; |
| |
| rc = sysfs_is_hotpluggable(&cxt); |
| |
| sysfs_deinit(&cxt); |
| return rc; |
| } |
| |
| |
| /* handle -x option */ |
| static void set_device_speed(struct eject_control *ctl) |
| { |
| if (!ctl->x_option) |
| return; |
| |
| if (ctl->x_arg == 0) |
| verbose(ctl, _("setting CD-ROM speed to auto")); |
| else |
| verbose(ctl, _("setting CD-ROM speed to %ldX"), ctl->x_arg); |
| |
| open_device(ctl); |
| select_speed(ctl); |
| exit(EXIT_SUCCESS); |
| } |
| |
| |
| /* main program */ |
| int main(int argc, char **argv) |
| { |
| char *disk = NULL; |
| char *mountpoint = NULL; |
| int worked = 0; /* set to 1 when successfully ejected */ |
| struct eject_control ctl = { 0 }; |
| |
| setlocale(LC_ALL,""); |
| bindtextdomain(PACKAGE, LOCALEDIR); |
| textdomain(PACKAGE); |
| atexit(close_stdout); |
| |
| /* parse the command line arguments */ |
| parse_args(&ctl, argc, argv); |
| |
| /* handle -d option */ |
| if (ctl.d_option) { |
| info(_("default device: `%s'"), EJECT_DEFAULT_DEVICE); |
| return EXIT_SUCCESS; |
| } |
| |
| if (!ctl.device) { |
| ctl.device = mnt_resolve_path(EJECT_DEFAULT_DEVICE, NULL); |
| verbose(&ctl, _("using default device `%s'"), ctl.device); |
| } else { |
| char *p; |
| |
| if (ctl.device[strlen(ctl.device) - 1] == '/') |
| ctl.device[strlen(ctl.device) - 1] = '\0'; |
| |
| /* figure out full device or mount point name */ |
| p = find_device(ctl.device); |
| if (p) |
| free(ctl.device); |
| else |
| p = ctl.device; |
| |
| ctl.device = mnt_resolve_spec(p, NULL); |
| free(p); |
| } |
| |
| if (!ctl.device) |
| errx(EXIT_FAILURE, _("%s: unable to find device"), ctl.device); |
| |
| verbose(&ctl, _("device name is `%s'"), ctl.device); |
| |
| device_get_mountpoint(&ctl, &ctl.device, &mountpoint); |
| if (mountpoint) |
| verbose(&ctl, _("%s: mounted on %s"), ctl.device, mountpoint); |
| else |
| verbose(&ctl, _("%s: not mounted"), ctl.device); |
| |
| disk = get_disk_devname(ctl.device); |
| if (disk) { |
| verbose(&ctl, _("%s: disc device: %s (disk device will be used for eject)"), ctl.device, disk); |
| free(ctl.device); |
| ctl.device = disk; |
| disk = NULL; |
| } else { |
| struct stat st; |
| |
| if (stat(ctl.device, &st) != 0 || !S_ISBLK(st.st_mode)) |
| errx(EXIT_FAILURE, _("%s: not found mountpoint or device " |
| "with the given name"), ctl.device); |
| |
| verbose(&ctl, _("%s: is whole-disk device"), ctl.device); |
| } |
| |
| if (ctl.F_option == 0 && is_hotpluggable(&ctl) == 0) |
| errx(EXIT_FAILURE, _("%s: is not hot-pluggable device"), ctl.device); |
| |
| /* handle -n option */ |
| if (ctl.n_option) { |
| info(_("device is `%s'"), ctl.device); |
| verbose(&ctl, _("exiting due to -n/--noop option")); |
| return EXIT_SUCCESS; |
| } |
| |
| /* handle -i option */ |
| if (ctl.i_option) { |
| open_device(&ctl); |
| manual_eject(&ctl); |
| return EXIT_SUCCESS; |
| } |
| |
| /* handle -a option */ |
| if (ctl.a_option) { |
| if (ctl.a_arg) |
| verbose(&ctl, _("%s: enabling auto-eject mode"), ctl.device); |
| else |
| verbose(&ctl, _("%s: disabling auto-eject mode"), ctl.device); |
| open_device(&ctl); |
| auto_eject(&ctl); |
| return EXIT_SUCCESS; |
| } |
| |
| /* handle -t option */ |
| if (ctl.t_option) { |
| verbose(&ctl, _("%s: closing tray"), ctl.device); |
| open_device(&ctl); |
| close_tray(ctl.fd); |
| set_device_speed(&ctl); |
| return EXIT_SUCCESS; |
| } |
| |
| /* handle -T option */ |
| if (ctl.T_option) { |
| verbose(&ctl, _("%s: toggling tray"), ctl.device); |
| open_device(&ctl); |
| toggle_tray(ctl.fd); |
| set_device_speed(&ctl); |
| return EXIT_SUCCESS; |
| } |
| |
| /* handle -X option */ |
| if (ctl.X_option) { |
| verbose(&ctl, _("%s: listing CD-ROM speed"), ctl.device); |
| open_device(&ctl); |
| list_speeds(&ctl); |
| return EXIT_SUCCESS; |
| } |
| |
| /* handle -x option only */ |
| if (!ctl.c_option) |
| set_device_speed(&ctl); |
| |
| |
| /* |
| * Unmount all partitions if -m is not specified; or umount given |
| * mountpoint if -M is specified, otherwise print error of another |
| * partition is mounted. |
| */ |
| if (!ctl.m_option) { |
| int ct = umount_partitions(&ctl); |
| |
| if (ct == 0 && mountpoint) |
| umount_one(&ctl, mountpoint); /* probably whole-device */ |
| |
| if (ctl.M_option) { |
| if (ct == 1 && mountpoint) |
| umount_one(&ctl, mountpoint); |
| else if (ct) |
| errx(EXIT_FAILURE, _("error: %s: device in use"), ctl.device); |
| } |
| } |
| |
| /* handle -c option */ |
| if (ctl.c_option) { |
| verbose(&ctl, _("%s: selecting CD-ROM disc #%ld"), ctl.device, ctl.c_arg); |
| open_device(&ctl); |
| changer_select(&ctl); |
| set_device_speed(&ctl); |
| return EXIT_SUCCESS; |
| } |
| |
| /* if user did not specify type of eject, try all four methods */ |
| if (ctl.r_option + ctl.s_option + ctl.f_option + ctl.q_option == 0) |
| ctl.r_option = ctl.s_option = ctl.f_option = ctl.q_option = 1; |
| |
| /* open device */ |
| open_device(&ctl); |
| |
| /* try various methods of ejecting until it works */ |
| if (ctl.r_option) { |
| verbose(&ctl, _("%s: trying to eject using CD-ROM eject command"), ctl.device); |
| worked = eject_cdrom(ctl.fd); |
| verbose(&ctl, worked ? _("CD-ROM eject command succeeded") : |
| _("CD-ROM eject command failed")); |
| } |
| |
| if (ctl.s_option && !worked) { |
| verbose(&ctl, _("%s: trying to eject using SCSI commands"), ctl.device); |
| worked = eject_scsi(&ctl); |
| verbose(&ctl, worked ? _("SCSI eject succeeded") : |
| _("SCSI eject failed")); |
| } |
| |
| if (ctl.f_option && !worked) { |
| verbose(&ctl, _("%s: trying to eject using floppy eject command"), ctl.device); |
| worked = eject_floppy(ctl.fd); |
| verbose(&ctl, worked ? _("floppy eject command succeeded") : |
| _("floppy eject command failed")); |
| } |
| |
| if (ctl.q_option && !worked) { |
| verbose(&ctl, _("%s: trying to eject using tape offline command"), ctl.device); |
| worked = eject_tape(ctl.fd); |
| verbose(&ctl, worked ? _("tape offline command succeeded") : |
| _("tape offline command failed")); |
| } |
| |
| if (!worked) |
| errx(EXIT_FAILURE, _("unable to eject")); |
| |
| /* cleanup */ |
| close(ctl.fd); |
| free(ctl.device); |
| free(mountpoint); |
| |
| mnt_unref_table(ctl.mtab); |
| |
| return EXIT_SUCCESS; |
| } |