sys-utils/eject.c

   1 /*
   2  * Copyright (C) 1994-2005 Jeff Tranter (tranter@pobox.com)
   3  * Copyright (C) 2012 Karel Zak <kzak@redhat.com>
   4  * Copyright (C) Michal Luscon <mluscon@redhat.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19  */
  20
  21 #include <unistd.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <fcntl.h>
  26 #include <limits.h>
  27 #include <err.h>
  28 #include <stdarg.h>
  29
  30 #include <getopt.h>
  31 #include <errno.h>
  32 #include <regex.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/wait.h>
  37 #include <sys/mtio.h>
  38 #include <linux/cdrom.h>
  39 #include <linux/fd.h>
  40 #include <sys/mount.h>
  41 #include <scsi/scsi.h>
  42 #include <scsi/sg.h>
  43 #include <scsi/scsi_ioctl.h>
  44 #include <sys/time.h>
  45
  46 #include <libmount.h>
  47
  48 #include "c.h"
  49 #include "closestream.h"
  50 #include "nls.h"
  51 #include "strutils.h"
  52 #include "xalloc.h"
  53 #include "pathnames.h"
  54 #include "sysfs.h"
  55 #include "monotonic.h"
  56
  57 /*
  58  * sg_io_hdr_t driver_status -- see kernel include/scsi/scsi.h
  59  */
  60 #ifndef DRIVER_SENSE
  61 # define DRIVER_SENSE   0x08
  62 #endif
  63
  64
  65 #define EJECT_DEFAULT_DEVICE "/dev/cdrom"
  66
  67
  68 /* Used by the toggle_tray() function. If ejecting the tray takes this
  69  * time or less, the tray was probably already ejected, so we close it
  70  * again.
  71  */
  72 #define TRAY_WAS_ALREADY_OPEN_USECS  200000     /* about 0.2 seconds */
  73
  74 struct eject_control {
  75         struct libmnt_table *mtab;
  76         char *device;                   /* device or mount point to be ejected */
  77         int fd;                         /* file descriptor for device */
  78         unsigned int                    /* command flags and arguments */
  79                 a_option:1,
  80                 c_option:1,
  81                 d_option:1,
  82                 F_option:1,
  83                 f_option:1,
  84                 i_option:1,
  85                 M_option:1,
  86                 m_option:1,
  87                 n_option:1,
  88                 p_option:1,
  89                 q_option:1,
  90                 r_option:1,
  91                 s_option:1,
  92                 T_option:1,
  93                 t_option:1,
  94                 v_option:1,
  95                 X_option:1,
  96                 x_option:1,
  97                 a_arg:1,
  98                 i_arg:1;
  99         long int c_arg;                 /* changer slot number */
 100         long int x_arg;                 /* cd speed */
 101 };
 102
 103 static void vinfo(const char *fmt, va_list va)
 104 {
 105         fprintf(stdout, "%s: ", program_invocation_short_name);
 106         vprintf(fmt, va);
 107         fputc('\n', stdout);
 108 }
 109
 110 static inline void verbose(const struct eject_control *ctl, const char *fmt, ...)
 111 {
 112         va_list va;
 113
 114         if (!ctl->v_option)
 115                 return;
 116
 117         va_start(va, fmt);
 118         vinfo(fmt, va);
 119         va_end(va);
 120 }
 121
 122 static inline void info(const char *fmt, ...)
 123 {
 124         va_list va;
 125         va_start(va, fmt);
 126         vinfo(fmt, va);
 127         va_end(va);
 128 }
 129
 130 static void __attribute__((__noreturn__)) usage(void)
 131 {
 132         FILE *out = stdout;
 133         fputs(USAGE_HEADER, out);
 134         fprintf(out,
 135                 _(" %s [options] [<device>|<mountpoint>]\n"), program_invocation_short_name);
 136
 137         fputs(USAGE_SEPARATOR, out);
 138         fputs(_("Eject removable media.\n"), out);
 139
 140         fputs(USAGE_OPTIONS, out);
 141         fputs(_(" -a, --auto <on|off>         turn auto-eject feature on or off\n"
 142                 " -c, --changerslot <slot>    switch discs on a CD-ROM changer\n"
 143                 " -d, --default               display default device\n"
 144                 " -f, --floppy                eject floppy\n"
 145                 " -F, --force                 don't care about device type\n"
 146                 " -i, --manualeject <on|off>  toggle manual eject protection on/off\n"
 147                 " -m, --no-unmount            do not unmount device even if it is mounted\n"
 148                 " -M, --no-partitions-unmount do not unmount another partitions\n"
 149                 " -n, --noop                  don't eject, just show device found\n"
 150                 " -p, --proc                  use /proc/mounts instead of /etc/mtab\n"
 151                 " -q, --tape                  eject tape\n"
 152                 " -r, --cdrom                 eject CD-ROM\n"
 153                 " -s, --scsi                  eject SCSI device\n"
 154                 " -t, --trayclose             close tray\n"
 155                 " -T, --traytoggle            toggle tray\n"
 156                 " -v, --verbose               enable verbose output\n"
 157                 " -x, --cdspeed <speed>       set CD-ROM max speed\n"
 158                 " -X, --listspeed             list CD-ROM available speeds\n"),
 159                 out);
 160
 161         fputs(USAGE_SEPARATOR, out);
 162         printf(USAGE_HELP_OPTIONS(29));
 163
 164         fputs(_("\nBy default tries -r, -s, -f, and -q in order until success.\n"), out);
 165         printf(USAGE_MAN_TAIL("eject(1)"));
 166
 167         exit(EXIT_SUCCESS);
 168 }
 169
 170
 171 /* Handle command line options. */
 172 static void parse_args(struct eject_control *ctl, int argc, char **argv)
 173 {
 174         static const struct option long_opts[] =
 175         {
 176                 {"auto",        required_argument, NULL, 'a'},
 177                 {"cdrom",       no_argument,       NULL, 'r'},
 178                 {"cdspeed",     required_argument, NULL, 'x'},
 179                 {"changerslot", required_argument, NULL, 'c'},
 180                 {"default",     no_argument,       NULL, 'd'},
 181                 {"floppy",      no_argument,       NULL, 'f'},
 182                 {"force",       no_argument,       NULL, 'F'},
 183                 {"help",        no_argument,       NULL, 'h'},
 184                 {"listspeed",   no_argument,       NULL, 'X'},
 185                 {"manualeject", required_argument, NULL, 'i'},
 186                 {"noop",        no_argument,       NULL, 'n'},
 187                 {"no-unmount",  no_argument,       NULL, 'm'},
 188                 {"no-partitions-unmount", no_argument, NULL, 'M' },
 189                 {"proc",        no_argument,       NULL, 'p'},
 190                 {"scsi",        no_argument,       NULL, 's'},
 191                 {"tape",        no_argument,       NULL, 'q'},
 192                 {"trayclose",   no_argument,       NULL, 't'},
 193                 {"traytoggle",  no_argument,       NULL, 'T'},
 194                 {"verbose",     no_argument,       NULL, 'v'},
 195                 {"version",     no_argument,       NULL, 'V'},
 196                 {NULL, 0, NULL, 0}
 197         };
 198         int c;
 199
 200         while ((c = getopt_long(argc, argv,
 201                                 "a:c:i:x:dfFhnqrstTXvVpmM", long_opts, NULL)) != -1) {
 202                 switch (c) {
 203                 case 'a':
 204                         ctl->a_option = 1;
 205                         ctl->a_arg = parse_switch(optarg, _("argument error"),
 206                                                 "on", "off",  "1", "0",  NULL);
 207                         break;
 208                 case 'c':
 209                         ctl->c_option = 1;
 210                         ctl->c_arg = strtoul_or_err(optarg, _("invalid argument to --changerslot/-c option"));
 211                         break;
 212                 case 'x':
 213                         ctl->x_option = 1;
 214                         ctl->x_arg = strtoul_or_err(optarg, _("invalid argument to --cdspeed/-x option"));
 215                         break;
 216                 case 'd':
 217                         ctl->d_option = 1;
 218                         break;
 219                 case 'f':
 220                         ctl->f_option = 1;
 221                         break;
 222                 case 'F':
 223                         ctl->F_option = 1;
 224                         break;
 225                 case 'h':
 226                         usage();
 227                         break;
 228                 case 'i':
 229                         ctl->i_option = 1;
 230                         ctl->i_arg = parse_switch(optarg, _("argument error"),
 231                                                 "on", "off",  "1", "0",  NULL);
 232                         break;
 233                 case 'm':
 234                         ctl->m_option = 1;
 235                         break;
 236                 case 'M':
 237                         ctl->M_option = 1;
 238                         break;
 239                 case 'n':
 240                         ctl->n_option = 1;
 241                         break;
 242                 case 'p':
 243                         ctl->p_option = 1;
 244                         break;
 245                 case 'q':
 246                         ctl->q_option = 1;
 247                         break;
 248                 case 'r':
 249                         ctl->r_option = 1;
 250                         break;
 251                 case 's':
 252                         ctl->s_option = 1;
 253                         break;
 254                 case 't':
 255                         ctl->t_option = 1;
 256                         break;
 257                 case 'T':
 258                         ctl->T_option = 1;
 259                         break;
 260                 case 'X':
 261                         ctl->X_option = 1;
 262                         break;
 263                 case 'v':
 264                         ctl->v_option = 1;
 265                         break;
 266                 case 'V':
 267                         printf(UTIL_LINUX_VERSION);
 268                         exit(EXIT_SUCCESS);
 269                         break;
 270                 default:
 271                         errtryhelp(EXIT_FAILURE);
 272                         break;
 273                 }
 274         }
 275
 276         /* check for a single additional argument */
 277         if ((argc - optind) > 1)
 278                 errx(EXIT_FAILURE, _("too many arguments"));
 279
 280         if ((argc - optind) == 1)
 281                 ctl->device = xstrdup(argv[optind]);
 282 }
 283
 284 /*
 285  * Given name, such as foo, see if any of the following exist:
 286  *
 287  * foo (if foo starts with '.' or '/')
 288  * /dev/foo
 289  *
 290  * If found, return the full path. If not found, return 0.
 291  * Returns pointer to dynamically allocated string.
 292  */
 293 static char *find_device(const char *name)
 294 {
 295         if (!name)
 296                 return NULL;
 297
 298         if ((*name == '.' || *name == '/') && access(name, F_OK) == 0)
 299                 return xstrdup(name);
 300         else {
 301                 char buf[PATH_MAX];
 302
 303                 snprintf(buf, sizeof(buf), "/dev/%s", name);
 304                 if (access(buf, F_OK) == 0)
 305                         return xstrdup(buf);
 306         }
 307
 308         return NULL;
 309 }
 310
 311 /* Set or clear auto-eject mode. */
 312 static void auto_eject(const struct eject_control *ctl)
 313 {
 314         int status = -1;
 315
 316 #if defined(CDROM_SET_OPTIONS) && defined(CDROM_CLEAR_OPTIONS)
 317         if (ctl->a_arg)
 318                 status = ioctl(ctl->fd, CDROM_SET_OPTIONS, CDO_AUTO_EJECT);
 319         else
 320                 status = ioctl(ctl->fd, CDROM_CLEAR_OPTIONS, CDO_AUTO_EJECT);
 321 #else
 322         errno = ENOSYS;
 323 #endif
 324         if (status < 0)
 325                 err(EXIT_FAILURE,_("CD-ROM auto-eject command failed"));
 326 }
 327
 328 /*
 329  * Stops CDROM from opening on manual eject button press.
 330  * This can be useful when you carry your laptop
 331  * in your bag while it's on and no CD inserted in it's drive.
 332  * Implemented as found in Documentation/ioctl/cdrom.txt
 333  */
 334 static void manual_eject(const struct eject_control *ctl)
 335 {
 336         if (ioctl(ctl->fd, CDROM_LOCKDOOR, ctl->i_arg) < 0) {
 337                 switch (errno) {
 338                 case EDRIVE_CANT_DO_THIS:
 339                         errx(EXIT_FAILURE, _("CD-ROM door lock is not supported"));
 340                 case EBUSY:
 341                         errx(EXIT_FAILURE, _("other users have the drive open and not CAP_SYS_ADMIN"));
 342                 default:
 343                         err(EXIT_FAILURE, _("CD-ROM lock door command failed"));
 344                 }
 345         }
 346
 347         if (ctl->i_arg)
 348                 info(_("CD-Drive may NOT be ejected with device button"));
 349         else
 350                 info(_("CD-Drive may be ejected with device button"));
 351 }
 352
 353 /*
 354  * Changer select. CDROM_SELECT_DISC is preferred, older kernels used
 355  * CDROMLOADFROMSLOT.
 356  */
 357 static void changer_select(const struct eject_control *ctl)
 358 {
 359 #ifdef CDROM_SELECT_DISC
 360         if (ioctl(ctl->fd, CDROM_SELECT_DISC, ctl->c_arg) < 0)
 361                 err(EXIT_FAILURE, _("CD-ROM select disc command failed"));
 362
 363 #elif defined CDROMLOADFROMSLOT
 364         if (ioctl(ctl->fd, CDROMLOADFROMSLOT, ctl->c_arg) != 0)
 365                 err(EXIT_FAILURE, _("CD-ROM load from slot command failed"));
 366 #else
 367         warnx(_("IDE/ATAPI CD-ROM changer not supported by this kernel\n") );
 368 #endif
 369 }
 370
 371 /*
 372  * Close tray. Not supported by older kernels.
 373  */
 374 static void close_tray(int fd)
 375 {
 376         int status;
 377
 378 #if defined(CDROMCLOSETRAY) || defined(CDIOCCLOSE)
 379 #if defined(CDROMCLOSETRAY)
 380         status = ioctl(fd, CDROMCLOSETRAY);
 381 #elif defined(CDIOCCLOSE)
 382         status = ioctl(fd, CDIOCCLOSE);
 383 #endif
 384         if (status != 0)
 385                 err(EXIT_FAILURE, _("CD-ROM tray close command failed"));
 386 #else
 387         warnx(_("CD-ROM tray close command not supported by this kernel\n"));
 388 #endif
 389 }
 390
 391 /*
 392  * Eject using CDROMEJECT ioctl.
 393  */
 394 static int eject_cdrom(int fd)
 395 {
 396 #if defined(CDROMEJECT)
 397         int ret = ioctl(fd, CDROM_LOCKDOOR, 0);
 398         if (ret < 0)
 399                 return 0;
 400         return ioctl(fd, CDROMEJECT) >= 0;
 401 #elif defined(CDIOCEJECT)
 402         return ioctl(fd, CDIOCEJECT) >= 0;
 403 #else
 404         warnx(_("CD-ROM eject unsupported"));
 405         errno = ENOSYS;
 406         return 0;
 407 #endif
 408 }
 409
 410 /*
 411  * Toggle tray.
 412  *
 413  * Written by Benjamin Schwenk <benjaminschwenk@yahoo.de> and
 414  * Sybren Stuvel <sybren@thirdtower.com>
 415  *
 416  * Not supported by older kernels because it might use
 417  * CloseTray().
 418  *
 419  */
 420 static void toggle_tray(int fd)
 421 {
 422 #ifdef CDROM_DRIVE_STATUS
 423         /* First ask the CDROM for info, otherwise fall back to manual.  */
 424         switch (ioctl(fd, CDROM_DRIVE_STATUS)) {
 425         case CDS_TRAY_OPEN:
 426                 close_tray(fd);
 427                 return;
 428
 429         case CDS_NO_DISC:
 430         case CDS_DISC_OK:
 431                 if (!eject_cdrom(fd))
 432                         err(EXIT_FAILURE, _("CD-ROM eject command failed"));
 433                 return;
 434         case CDS_NO_INFO:
 435                 warnx(_("no CD-ROM information available"));
 436                 return;
 437         case CDS_DRIVE_NOT_READY:
 438                 warnx(_("CD-ROM drive is not ready"));
 439                 return;
 440         default:
 441                 abort();
 442         }
 443 #else
 444         struct timeval time_start, time_stop;
 445         int time_elapsed;
 446
 447         /* Try to open the CDROM tray and measure the time therefor
 448          * needed.  In my experience the function needs less than 0.05
 449          * seconds if the tray was already open, and at least 1.5 seconds
 450          * if it was closed.  */
 451         gettime_monotonic(&time_start);
 452
 453         /* Send the CDROMEJECT command to the device. */
 454         if (!eject_cdrom(fd))
 455                 err(EXIT_FAILURE, _("CD-ROM eject command failed"));
 456
 457         /* Get the second timestamp, to measure the time needed to open
 458          * the tray.  */
 459         gettime_monotonic(&time_stop);
 460
 461         time_elapsed = (time_stop.tv_sec * 1000000 + time_stop.tv_usec) -
 462                 (time_start.tv_sec * 1000000 + time_start.tv_usec);
 463
 464         /* If the tray "opened" too fast, we can be nearly sure, that it
 465          * was already open. In this case, close it now. Else the tray was
 466          * closed before. This would mean that we are done.  */
 467         if (time_elapsed < TRAY_WAS_ALREADY_OPEN_USECS)
 468                 close_tray(fd);
 469 #endif
 470 }
 471
 472 /*
 473  * Select Speed of CD-ROM drive.
 474  * Thanks to Roland Krivanek (krivanek@fmph.uniba.sk)
 475  * http://dmpc.dbp.fmph.uniba.sk/~krivanek/cdrom_speed/
 476  */
 477 static void select_speed(const struct eject_control *ctl)
 478 {
 479 #ifdef CDROM_SELECT_SPEED
 480         if (ioctl(ctl->fd, CDROM_SELECT_SPEED, ctl->x_arg) != 0)
 481                 err(EXIT_FAILURE, _("CD-ROM select speed command failed"));
 482 #else
 483         warnx(_("CD-ROM select speed command not supported by this kernel"));
 484 #endif
 485 }
 486
 487 /*
 488  * Read Speed of CD-ROM drive. From Linux 2.6.13, the current speed
 489  * is correctly reported
 490  */
 491 static int read_speed(const char *devname)
 492 {
 493         int drive_number = -1;
 494         char *name;
 495         FILE *f;
 496
 497         f = fopen(_PATH_PROC_CDROMINFO, "r");
 498         if (!f)
 499                 err(EXIT_FAILURE, _("cannot open %s"), _PATH_PROC_CDROMINFO);
 500
 501         name = strrchr(devname, '/') + 1;
 502
 503         while (name && !feof(f)) {
 504                 char line[512];
 505                 char *str;
 506
 507                 if (!fgets(line, sizeof(line), f))
 508                         break;
 509
 510                 /* find drive number in line "drive name" */
 511                 if (drive_number == -1) {
 512                         if (strncmp(line, "drive name:", 11) == 0) {
 513                                 str = strtok(&line[11], "\t ");
 514                                 drive_number = 0;
 515                                 while (str && strncmp(name, str, strlen(name)) != 0) {
 516                                         drive_number++;
 517                                         str = strtok(NULL, "\t ");
 518                                         if (!str)
 519                                                 errx(EXIT_FAILURE,
 520                                                      _("%s: failed to finding CD-ROM name"),
 521                                                      _PATH_PROC_CDROMINFO);
 522                                 }
 523                         }
 524                 /* find line "drive speed" and read the correct speed */
 525                 } else {
 526                         if (strncmp(line, "drive speed:", 12) == 0) {
 527                                 int i;
 528
 529                                 str = strtok(&line[12], "\t ");
 530                                 for (i = 1; i < drive_number; i++)
 531                                         str = strtok(NULL, "\t ");
 532
 533                                 if (!str)
 534                                         errx(EXIT_FAILURE,
 535                                                 _("%s: failed to read speed"),
 536                                                 _PATH_PROC_CDROMINFO);
 537                                 fclose(f);
 538                                 return atoi(str);
 539                         }
 540                 }
 541         }
 542
 543         errx(EXIT_FAILURE, _("failed to read speed"));
 544 }
 545
 546 /*
 547  * List Speed of CD-ROM drive.
 548  */
 549 static void list_speeds(struct eject_control *ctl)
 550 {
 551         int max_speed, curr_speed = 0;
 552
 553         select_speed(ctl);
 554         max_speed = read_speed(ctl->device);
 555
 556         while (curr_speed < max_speed) {
 557                 ctl->x_arg = curr_speed + 1;
 558                 select_speed(ctl);
 559                 curr_speed = read_speed(ctl->device);
 560                 if (ctl->x_arg < curr_speed)
 561                         printf("%d ", curr_speed);
 562                 else
 563                         curr_speed = ctl->x_arg + 1;
 564         }
 565
 566         printf("\n");
 567 }
 568
 569 /*
 570  * Eject using SCSI SG_IO commands. Return 1 if successful, 0 otherwise.
 571  */
 572 static int eject_scsi(const struct eject_control *ctl)
 573 {
 574         int status, k;
 575         sg_io_hdr_t io_hdr;
 576         unsigned char allowRmBlk[6] = {ALLOW_MEDIUM_REMOVAL, 0, 0, 0, 0, 0};
 577         unsigned char startStop1Blk[6] = {START_STOP, 0, 0, 0, 1, 0};
 578         unsigned char startStop2Blk[6] = {START_STOP, 0, 0, 0, 2, 0};
 579         unsigned char inqBuff[2];
 580         unsigned char sense_buffer[32];
 581
 582         if ((ioctl(ctl->fd, SG_GET_VERSION_NUM, &k) < 0) || (k < 30000)) {
 583                 verbose(ctl, _("not an sg device, or old sg driver"));
 584                 return 0;
 585         }
 586
 587         memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
 588         io_hdr.interface_id = 'S';
 589         io_hdr.cmd_len = 6;
 590         io_hdr.mx_sb_len = sizeof(sense_buffer);
 591         io_hdr.dxfer_direction = SG_DXFER_NONE;
 592         io_hdr.dxfer_len = 0;
 593         io_hdr.dxferp = inqBuff;
 594         io_hdr.sbp = sense_buffer;
 595         io_hdr.timeout = 10000;
 596
 597         io_hdr.cmdp = allowRmBlk;
 598         status = ioctl(ctl->fd, SG_IO, (void *)&io_hdr);
 599         if (status < 0 || io_hdr.host_status || io_hdr.driver_status)
 600                 return 0;
 601
 602         io_hdr.cmdp = startStop1Blk;
 603         status = ioctl(ctl->fd, SG_IO, (void *)&io_hdr);
 604         if (status < 0 || io_hdr.host_status)
 605                 return 0;
 606
 607         /* Ignore errors when there is not medium -- in this case driver sense
 608          * buffer sets MEDIUM NOT PRESENT (3a) bit. For more details see:
 609          * http://www.tldp.org/HOWTO/archived/SCSI-Programming-HOWTO/SCSI-Programming-HOWTO-22.html#sec-sensecodes
 610          * -- kzak Jun 2013
 611          */
 612         if (io_hdr.driver_status != 0 &&
 613             !(io_hdr.driver_status == DRIVER_SENSE && io_hdr.sbp &&
 614                                                       io_hdr.sbp[12] == 0x3a))
 615                 return 0;
 616
 617         io_hdr.cmdp = startStop2Blk;
 618         status = ioctl(ctl->fd, SG_IO, (void *)&io_hdr);
 619         if (status < 0 || io_hdr.host_status || io_hdr.driver_status)
 620                 return 0;
 621
 622         /* force kernel to reread partition table when new disc inserted */
 623         ioctl(ctl->fd, BLKRRPART);
 624         return 1;
 625 }
 626
 627 /*
 628  * Eject using FDEJECT ioctl. Return 1 if successful, 0 otherwise.
 629  */
 630 static int eject_floppy(int fd)
 631 {
 632         return ioctl(fd, FDEJECT) >= 0;
 633 }
 634
 635
 636 /*
 637  * Rewind and eject using tape ioctl. Return 1 if successful, 0 otherwise.
 638  */
 639 static int eject_tape(int fd)
 640 {
 641         struct mtop op = { .mt_op = MTOFFL, .mt_count = 0 };
 642
 643         return ioctl(fd, MTIOCTOP, &op) >= 0;
 644 }
 645
 646
 647 /* umount a device. */
 648 static void umount_one(const struct eject_control *ctl, const char *name)
 649 {
 650         int status;
 651
 652         if (!name)
 653                 return;
 654
 655         verbose(ctl, _("%s: unmounting"), name);
 656
 657         switch (fork()) {
 658         case 0: /* child */
 659                 if (setgid(getgid()) < 0)
 660                         err(EXIT_FAILURE, _("cannot set group id"));
 661
 662                 if (setuid(getuid()) < 0)
 663                         err(EXIT_FAILURE, _("cannot set user id"));
 664
 665                 if (ctl->p_option)
 666                         execl("/bin/umount", "/bin/umount", name, "-n", NULL);
 667                 else
 668                         execl("/bin/umount", "/bin/umount", name, NULL);
 669
 670                 errx(EXIT_FAILURE, _("unable to exec /bin/umount of `%s'"), name);
 671
 672         case -1:
 673                 warn( _("unable to fork"));
 674                 break;
 675
 676         default: /* parent */
 677                 wait(&status);
 678                 if (WIFEXITED(status) == 0)
 679                         errx(EXIT_FAILURE,
 680                              _("unmount of `%s' did not exit normally"), name);
 681
 682                 if (WEXITSTATUS(status) != 0)
 683                         errx(EXIT_FAILURE, _("unmount of `%s' failed\n"), name);
 684                 break;
 685         }
 686 }
 687
 688 /* Open a device file. */
 689 static void open_device(struct eject_control *ctl)
 690 {
 691         ctl->fd = open(ctl->device, O_RDWR | O_NONBLOCK);
 692         if (ctl->fd < 0)
 693                 ctl->fd = open(ctl->device, O_RDONLY | O_NONBLOCK);
 694         if (ctl->fd == -1)
 695                 err(EXIT_FAILURE, _("cannot open %s"), ctl->device);
 696 }
 697
 698 /*
 699  * See if device has been mounted by looking in mount table.  If so, set
 700  * device name and mount point name, and return 1, otherwise return 0.
 701  */
 702 static int device_get_mountpoint(struct eject_control *ctl, char **devname, char **mnt)
 703 {
 704         struct libmnt_fs *fs;
 705         int rc;
 706
 707         *mnt = NULL;
 708
 709         if (!ctl->mtab) {
 710                 struct libmnt_cache *cache;
 711
 712                 ctl->mtab = mnt_new_table();
 713                 if (!ctl->mtab)
 714                         err(EXIT_FAILURE, _("failed to initialize libmount table"));
 715
 716                 cache = mnt_new_cache();
 717                 mnt_table_set_cache(ctl->mtab, cache);
 718                 mnt_unref_cache(cache);
 719
 720                 if (ctl->p_option)
 721                         rc = mnt_table_parse_file(ctl->mtab, _PATH_PROC_MOUNTINFO);
 722                 else
 723                         rc = mnt_table_parse_mtab(ctl->mtab, NULL);
 724                 if (rc)
 725                         err(EXIT_FAILURE, _("failed to parse mount table"));
 726         }
 727
 728         fs = mnt_table_find_source(ctl->mtab, *devname, MNT_ITER_BACKWARD);
 729         if (!fs) {
 730                 /* maybe 'devname' is mountpoint rather than a real device */
 731                 fs = mnt_table_find_target(ctl->mtab, *devname, MNT_ITER_BACKWARD);
 732                 if (fs) {
 733                         free(*devname);
 734                         *devname = xstrdup(mnt_fs_get_source(fs));
 735                 }
 736         }
 737
 738         if (fs)
 739                 *mnt = xstrdup(mnt_fs_get_target(fs));
 740         return *mnt ? 0 : -1;
 741 }
 742
 743 static char *get_disk_devname(const char *device)
 744 {
 745         struct stat st;
 746         dev_t diskno = 0;
 747         char diskname[128];
 748
 749         if (stat(device, &st) != 0)
 750                 return NULL;
 751
 752         /* get whole-disk devno */
 753         if (sysfs_devno_to_wholedisk(st.st_rdev, diskname,
 754                                 sizeof(diskname), &diskno) != 0)
 755                 return NULL;
 756
 757         return st.st_rdev == diskno ? NULL : find_device(diskname);
 758 }
 759
 760 static int umount_partitions(struct eject_control *ctl)
 761 {
 762         struct sysfs_cxt cxt = UL_SYSFSCXT_EMPTY;
 763         dev_t devno;
 764         DIR *dir = NULL;
 765         struct dirent *d;
 766         int count = 0;
 767
 768         devno = sysfs_devname_to_devno(ctl->device, NULL);
 769         if (sysfs_init(&cxt, devno, NULL) != 0)
 770                 return 0;
 771
 772         /* open /sys/block/<wholedisk> */
 773         if (!(dir = sysfs_opendir(&cxt, NULL)))
 774                 goto done;
 775
 776         /* scan for partition subdirs */
 777         while ((d = readdir(dir))) {
 778                 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
 779                         continue;
 780
 781                 if (sysfs_is_partition_dirent(dir, d, ctl->device)) {
 782                         char *mnt = NULL;
 783                         char *dev = find_device(d->d_name);
 784
 785                         if (dev && device_get_mountpoint(ctl, &dev, &mnt) == 0) {
 786                                 verbose(ctl, _("%s: mounted on %s"), dev, mnt);
 787                                 if (!ctl->M_option)
 788                                         umount_one(ctl, mnt);
 789                                 count++;
 790                         }
 791                         free(dev);
 792                         free(mnt);
 793                 }
 794         }
 795
 796 done:
 797         if (dir)
 798                 closedir(dir);
 799         sysfs_deinit(&cxt);
 800
 801         return count;
 802 }
 803
 804 static int is_hotpluggable(const struct eject_control *ctl)
 805 {
 806         struct sysfs_cxt cxt = UL_SYSFSCXT_EMPTY;
 807         dev_t devno;
 808         int rc = 0;
 809
 810         devno = sysfs_devname_to_devno(ctl->device, NULL);
 811         if (sysfs_init(&cxt, devno, NULL) != 0)
 812                 return 0;
 813
 814         rc = sysfs_is_hotpluggable(&cxt);
 815
 816         sysfs_deinit(&cxt);
 817         return rc;
 818 }
 819
 820
 821 /* handle -x option */
 822 static void set_device_speed(struct eject_control *ctl)
 823 {
 824         if (!ctl->x_option)
 825                 return;
 826
 827         if (ctl->x_arg == 0)
 828                 verbose(ctl, _("setting CD-ROM speed to auto"));
 829         else
 830                 verbose(ctl, _("setting CD-ROM speed to %ldX"), ctl->x_arg);
 831
 832         open_device(ctl);
 833         select_speed(ctl);
 834         exit(EXIT_SUCCESS);
 835 }
 836
 837
 838 /* main program */
 839 int main(int argc, char **argv)
 840 {
 841         char *disk = NULL;
 842         char *mountpoint = NULL;
 843         int worked = 0;    /* set to 1 when successfully ejected */
 844         struct eject_control ctl = { NULL };
 845
 846         setlocale(LC_ALL,"");
 847         bindtextdomain(PACKAGE, LOCALEDIR);
 848         textdomain(PACKAGE);
 849         atexit(close_stdout);
 850
 851         /* parse the command line arguments */
 852         parse_args(&ctl, argc, argv);
 853
 854         /* handle -d option */
 855         if (ctl.d_option) {
 856                 info(_("default device: `%s'"), EJECT_DEFAULT_DEVICE);
 857                 return EXIT_SUCCESS;
 858         }
 859
 860         if (!ctl.device) {
 861                 ctl.device = mnt_resolve_path(EJECT_DEFAULT_DEVICE, NULL);
 862                 verbose(&ctl, _("using default device `%s'"), ctl.device);
 863         } else {
 864                 char *p;
 865
 866                 if (ctl.device[strlen(ctl.device) - 1] == '/')
 867                         ctl.device[strlen(ctl.device) - 1] = '\0';
 868
 869                 /* figure out full device or mount point name */
 870                 p = find_device(ctl.device);
 871                 if (p)
 872                         free(ctl.device);
 873                 else
 874                         p = ctl.device;
 875
 876                 ctl.device = mnt_resolve_spec(p, NULL);
 877                 free(p);
 878         }
 879
 880         if (!ctl.device)
 881                 errx(EXIT_FAILURE, _("%s: unable to find device"), ctl.device);
 882
 883         verbose(&ctl, _("device name is `%s'"), ctl.device);
 884
 885         device_get_mountpoint(&ctl, &ctl.device, &mountpoint);
 886         if (mountpoint)
 887                 verbose(&ctl, _("%s: mounted on %s"), ctl.device, mountpoint);
 888         else
 889                 verbose(&ctl, _("%s: not mounted"), ctl.device);
 890
 891         disk = get_disk_devname(ctl.device);
 892         if (disk) {
 893                 verbose(&ctl, _("%s: disc device: %s (disk device will be used for eject)"), ctl.device, disk);
 894                 free(ctl.device);
 895                 ctl.device = disk;
 896                 disk = NULL;
 897         } else {
 898                 struct stat st;
 899
 900                 if (stat(ctl.device, &st) != 0 || !S_ISBLK(st.st_mode))
 901                         errx(EXIT_FAILURE, _("%s: not found mountpoint or device "
 902                                         "with the given name"), ctl.device);
 903
 904                 verbose(&ctl, _("%s: is whole-disk device"), ctl.device);
 905         }
 906
 907         if (ctl.F_option == 0 && is_hotpluggable(&ctl) == 0)
 908                 errx(EXIT_FAILURE, _("%s: is not hot-pluggable device"), ctl.device);
 909
 910         /* handle -n option */
 911         if (ctl.n_option) {
 912                 info(_("device is `%s'"), ctl.device);
 913                 verbose(&ctl, _("exiting due to -n/--noop option"));
 914                 return EXIT_SUCCESS;
 915         }
 916
 917         /* handle -i option */
 918         if (ctl.i_option) {
 919                 open_device(&ctl);
 920                 manual_eject(&ctl);
 921                 return EXIT_SUCCESS;
 922         }
 923
 924         /* handle -a option */
 925         if (ctl.a_option) {
 926                 if (ctl.a_arg)
 927                         verbose(&ctl, _("%s: enabling auto-eject mode"), ctl.device);
 928                 else
 929                         verbose(&ctl, _("%s: disabling auto-eject mode"), ctl.device);
 930                 open_device(&ctl);
 931                 auto_eject(&ctl);
 932                 return EXIT_SUCCESS;
 933         }
 934
 935         /* handle -t option */
 936         if (ctl.t_option) {
 937                 verbose(&ctl, _("%s: closing tray"), ctl.device);
 938                 open_device(&ctl);
 939                 close_tray(ctl.fd);
 940                 set_device_speed(&ctl);
 941                 return EXIT_SUCCESS;
 942         }
 943
 944         /* handle -T option */
 945         if (ctl.T_option) {
 946                 verbose(&ctl, _("%s: toggling tray"), ctl.device);
 947                 open_device(&ctl);
 948                 toggle_tray(ctl.fd);
 949                 set_device_speed(&ctl);
 950                 return EXIT_SUCCESS;
 951         }
 952
 953         /* handle -X option */
 954         if (ctl.X_option) {
 955                 verbose(&ctl, _("%s: listing CD-ROM speed"), ctl.device);
 956                 open_device(&ctl);
 957                 list_speeds(&ctl);
 958                 return EXIT_SUCCESS;
 959         }
 960
 961         /* handle -x option only */
 962         if (!ctl.c_option)
 963                 set_device_speed(&ctl);
 964
 965
 966         /*
 967          * Unmount all partitions if -m is not specified; or umount given
 968          * mountpoint if -M is specified, otherwise print error of another
 969          * partition is mounted.
 970          */
 971         if (!ctl.m_option) {
 972                 int ct = umount_partitions(&ctl);
 973
 974                 if (ct == 0 && mountpoint)
 975                         umount_one(&ctl, mountpoint); /* probably whole-device */
 976
 977                 if (ctl.M_option) {
 978                         if (ct == 1 && mountpoint)
 979                                 umount_one(&ctl, mountpoint);
 980                         else if (ct)
 981                                 errx(EXIT_FAILURE, _("error: %s: device in use"), ctl.device);
 982                 }
 983         }
 984
 985         /* handle -c option */
 986         if (ctl.c_option) {
 987                 verbose(&ctl, _("%s: selecting CD-ROM disc #%ld"), ctl.device, ctl.c_arg);
 988                 open_device(&ctl);
 989                 changer_select(&ctl);
 990                 set_device_speed(&ctl);
 991                 return EXIT_SUCCESS;
 992         }
 993
 994         /* if user did not specify type of eject, try all four methods */
 995         if (ctl.r_option + ctl.s_option + ctl.f_option + ctl.q_option == 0)
 996                 ctl.r_option = ctl.s_option = ctl.f_option = ctl.q_option = 1;
 997
 998         /* open device */
 999         open_device(&ctl);
1000
1001         /* try various methods of ejecting until it works */
1002         if (ctl.r_option) {
1003                 verbose(&ctl, _("%s: trying to eject using CD-ROM eject command"), ctl.device);
1004                 worked = eject_cdrom(ctl.fd);
1005                 verbose(&ctl, worked ? _("CD-ROM eject command succeeded") :
1006                                  _("CD-ROM eject command failed"));
1007         }
1008
1009         if (ctl.s_option && !worked) {
1010                 verbose(&ctl, _("%s: trying to eject using SCSI commands"), ctl.device);
1011                 worked = eject_scsi(&ctl);
1012                 verbose(&ctl, worked ? _("SCSI eject succeeded") :
1013                                  _("SCSI eject failed"));
1014         }
1015
1016         if (ctl.f_option && !worked) {
1017                 verbose(&ctl, _("%s: trying to eject using floppy eject command"), ctl.device);
1018                 worked = eject_floppy(ctl.fd);
1019                 verbose(&ctl, worked ? _("floppy eject command succeeded") :
1020                                  _("floppy eject command failed"));
1021         }
1022
1023         if (ctl.q_option && !worked) {
1024                 verbose(&ctl, _("%s: trying to eject using tape offline command"), ctl.device);
1025                 worked = eject_tape(ctl.fd);
1026                 verbose(&ctl, worked ? _("tape offline command succeeded") :
1027                                  _("tape offline command failed"));
1028         }
1029
1030         if (!worked)
1031                 errx(EXIT_FAILURE, _("unable to eject"));
1032
1033         /* cleanup */
1034         close(ctl.fd);
1035         free(ctl.device);
1036         free(mountpoint);
1037
1038         mnt_unref_table(ctl.mtab);
1039
1040         return EXIT_SUCCESS;
1041 }