cmd/eject/eject.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * Program to eject one or more pieces of media.
 */

#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
#include    <sys/types.h>
#include    <sys/stat.h>
#include    <sys/fdio.h>
#include    <sys/dkio.h>
#include    <sys/cdio.h>
#include    <sys/param.h>
#include    <sys/wait.h>
#include    <dirent.h>
#include    <fcntl.h>
#include    <string.h>
#include    <errno.h>
#include    <locale.h>
#include    <libintl.h>
#include    <unistd.h>
#include    <pwd.h>
#include    <volmgt.h>
#include    <sys/mnttab.h>
#include    <signal.h>

static char     *prog_name = NULL;
static boolean_t    do_default = B_FALSE;
static boolean_t    do_list = B_FALSE;
static boolean_t    do_closetray = B_FALSE;
static boolean_t    force_eject = B_FALSE;
static boolean_t    do_query = B_FALSE;
static boolean_t    is_direct = B_FALSE;

static int      work(char *, char *);
static void     usage(void);
static int      ejectit(char *);
static boolean_t    query(char *, boolean_t);
static boolean_t    floppy_in_drive(char *, int, boolean_t *);
static boolean_t    display_busy(char *, boolean_t);
static char     *eject_getfullblkname(char *, boolean_t);
extern char     *getfullrawname(char *);

/*
 * ON-private libvolmgt routines
 */
int     _dev_mounted(char *path);
int     _dev_unmount(char *path);
char        *_media_oldaliases(char *name);
void        _media_printaliases(void);


/*
 * Hold over from old eject.
 * returns exit codes:  (KEEP THESE - especially important for query)
 *  0 = -n, -d or eject operation was ok, -q = media in drive
 *  1 = -q only = media not in drive
 *  2 = various parameter errors, etc.
 *  3 = eject ioctl failed
 * New Value (2/94)
 *  4 = eject partially succeeded, but now manually remove media
 */

#define EJECT_OK        0
#define EJECT_NO_MEDIA      1
#define EJECT_PARM_ERR      2
#define EJECT_IOCTL_ERR     3
#define EJECT_MAN_EJ        4

#define AVAIL_MSG       "%s is available\n"
#define NOT_AVAIL_MSG       "%s is not available\n"

#define OK_TO_EJECT_MSG     "%s can now be manually ejected\n"

#define FLOPPY_MEDIA_TYPE   "floppy"
#define CDROM_MEDIA_TYPE    "cdrom"


int
main(int argc, char **argv)
{
    int     c;
    const char  *opts = "dqflt";
    int     excode;
    int     res;
    boolean_t   err_seen = B_FALSE;
    boolean_t   man_eject_seen = B_FALSE;
    char        *rmmount_opt = NULL;

    (void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif

    (void) textdomain(TEXT_DOMAIN);

    prog_name = argv[0];

    is_direct = (getenv("EJECT_DIRECT") != NULL);

    /* process arguments */
    while ((c = getopt(argc, argv, opts)) != EOF) {
        switch (c) {
        case 'd':
            do_default = B_TRUE;
            rmmount_opt = "-d";
            break;
        case 'q':
            do_query = B_TRUE;
            break;
        case 'l':
            do_list = B_TRUE;
            rmmount_opt = "-l";
            break;
        case 'f':
            force_eject = B_TRUE;
            break;
        case 't':
            do_closetray = B_TRUE;
            break;
        default:
            usage();
            exit(EJECT_PARM_ERR);
        }
    }

    if (argc == optind) {
        /* no argument -- use the default */
        excode = work(NULL, rmmount_opt);
    } else {
        /* multiple things to eject */
        for (; optind < argc; optind++) {
            res = work(argv[optind], rmmount_opt);
            if (res == EJECT_MAN_EJ) {
                man_eject_seen = B_TRUE;
            } else if (res != EJECT_OK) {
                err_seen = B_TRUE;
            }
        }
        if (err_seen) {
            if (!is_direct) {
                excode = res;
            } else {
                excode = EJECT_IOCTL_ERR;
            }
        } else if (man_eject_seen) {
            excode = EJECT_MAN_EJ;
        } else {
            excode = EJECT_OK;
        }
    }

    return (excode);
}

/*
 * the the real work of ejecting (and notifying)
 */
static int
work(char *arg, char *rmmount_opt)
{
    char        *name;
    int     excode = EJECT_OK;
    struct stat64   sb;
    char        *arg1, *arg2;
    pid_t       pid;
    int     status = 1;

    if (!is_direct) {
        /* exec rmmount */
        if (do_closetray) {
            (void) putenv("EJECT_CLOSETRAY=1");
        }
        if (do_query) {
            (void) putenv("EJECT_QUERY=1");
        }
        pid = fork();
        if (pid < 0) {
            exit(1);
        } else if (pid == 0) {
            /* child */
            if (rmmount_opt != NULL) {
                arg1 = rmmount_opt;
                arg2 = arg;
            } else {
                arg1 = arg;
                arg2 = NULL;
            }

            if (execl("/usr/bin/rmmount", "eject",
                arg1, arg2, 0) < 0) {
                excode = 99;
            } else {
                exit(0);
            }
        } else {
            /* parent */
            if (waitpid(pid, &status, 0) != pid) {
                excode = 1;
            } else if (WIFEXITED(status) &&
                (WEXITSTATUS(status) != 0)) {
                excode = WEXITSTATUS(status);
            } else {
                excode = 0;
            }
        }
    }

    /*
     * rmmount returns 99 if HAL not running -
     * fallback to direct in that case
     */
    if (is_direct || (excode == 99)) {
        excode = EJECT_OK;

        if (arg == NULL) {
            arg = "floppy";
        }
        if ((name = _media_oldaliases(arg)) == NULL) {
            name = arg;
        }
        if (do_default) {
            (void) printf("%s\n", name);
            goto out;
        }
        if (do_list) {
            (void) printf("%s\t%s\n", name, arg);
            goto out;
        }
        if (access(name, R_OK) != 0) {
            if (do_query) {
                (void) fprintf(stderr,
                    gettext("%s: no media\n"), name);
                return (EJECT_NO_MEDIA);
            } else {
                perror(name);
                return (EJECT_PARM_ERR);
            }
        }

        if (do_query) {
            if ((stat64(name, &sb) == 0) && S_ISDIR(sb.st_mode)) {
                (void) fprintf(stderr,
                    gettext("%s: no media\n"), name);
                return (EJECT_NO_MEDIA);
            }
            if (!query(name, B_TRUE)) {
                excode = EJECT_NO_MEDIA;
            }
        } else {
            excode = ejectit(name);
        }
    }
out:
    return (excode);
}


static void
usage(void)
{
    (void) fprintf(stderr,
        gettext("usage: %s [-fldqt] [name | nickname]\n"),
        prog_name);
    (void) fprintf(stderr,
        gettext("options:\t-f force eject\n"));
    (void) fprintf(stderr,
        gettext("\t\t-l list ejectable devices\n"));
    (void) fprintf(stderr,
        gettext("\t\t-d show default device\n"));
    (void) fprintf(stderr,
        gettext("\t\t-q query for media present\n"));
    (void) fprintf(stderr,
        gettext("\t\t-t close tray\n"));
}


static int
ejectit(char *name)
{
    int         fd, r;
    boolean_t   mejectable = B_FALSE;   /* manually ejectable */
    int     result = EJECT_OK;

    /*
     * If volume management is either not running or not being managed by
     * vold, and the device is mounted, we try to umount the device.  If we
     * fail, we give up, unless he used the -f flag.
     */

    if (_dev_mounted(name)) {
        r = _dev_unmount(name);
        if (r == 0) {
            if (!force_eject) {
                (void) fprintf(stderr,
gettext("WARNING: can not unmount %s, the file system is (probably) busy\n"),
                    name);
                return (EJECT_PARM_ERR);
            } else {
                (void) fprintf(stderr,
gettext("WARNING: %s has a mounted filesystem, ejecting anyway\n"),
                    name);
            }
        }
    }

    /*
     * Require O_NDELAY for when floppy is not formatted
     * will still id floppy in drive
     */

    /*
     * make sure we are dealing with a raw device
     *
     * XXX: NOTE: results from getfullrawname()
     * really should be free()d when no longer
     * in use
     */
    name = getfullrawname(name);

    if ((fd = open(name, O_RDONLY | O_NDELAY)) < 0) {
        if (errno == EBUSY) {
            (void) fprintf(stderr,
gettext("%s is busy (try 'eject floppy' or 'eject cdrom'?)\n"),
                name);
            return (EJECT_PARM_ERR);
        }
        perror(name);
        return (EJECT_PARM_ERR);
    }

    if (do_closetray) {
        if (ioctl(fd, CDROMCLOSETRAY) < 0) {
            result = EJECT_IOCTL_ERR;
        }
    } else if (ioctl(fd, DKIOCEJECT, 0) < 0) {
        /* check on why eject failed */

        /* check for no floppy in manually ejectable drive */
        if ((errno == ENOSYS) &&
            !floppy_in_drive(name, fd, &mejectable)) {
            /* use code below to handle "not present" */
            errno = ENXIO;
        }

        if (errno == ENOSYS || errno == ENOTSUP) {
            (void) fprintf(stderr, gettext(OK_TO_EJECT_MSG), name);
        }

        if ((errno == ENOSYS || errno == ENOTSUP) && mejectable) {
            /*
             * keep track of the fact that this is a manual
             * ejection
             */
            result = EJECT_MAN_EJ;

        } else if (errno == EBUSY) {
            /*
             * if our pathname is s slice (UFS is great) then
             * check to see what really is busy
             */
            if (!display_busy(name, B_FALSE)) {
                perror(name);
            }
            result = EJECT_IOCTL_ERR;

        } else if ((errno == EAGAIN) || (errno == ENODEV) ||
            (errno == ENXIO)) {
            (void) fprintf(stderr,
                gettext("%s not present in a drive\n"),
                name);
            result = EJECT_OK;
        } else {
            perror(name);
            result = EJECT_IOCTL_ERR;
        }
    }

    (void) close(fd);
    return (result);
}


/*
 * return B_TRUE if a floppy is in the drive, B_FALSE otherwise
 *
 * this routine assumes that the file descriptor passed in is for
 * a floppy disk.  this works because it's only called if the device
 * is "manually ejectable", which only (currently) occurs for floppies.
 */
static boolean_t
floppy_in_drive(char *name, int fd, boolean_t *is_floppy)
{
    int ival = 0;
    boolean_t rval = B_FALSE;


    if (ioctl(fd, FDGETCHANGE, &ival) >= 0) {
        if (!(ival & FDGC_CURRENT)) {
            rval = B_TRUE;
        }
        *is_floppy = B_TRUE;
    } else {
        *is_floppy = B_FALSE;
        (void) fprintf(stderr, gettext("%s is not a floppy disk\n"),
            name);
    }

    return (rval);
}


/*
 * display a "busy" message for the supplied pathname
 *
 * if the pathname is not a slice, then just display a busy message
 * else if the pathname is some slice subdirectory then look for the
 * *real* culprits
 *
 * if this is not done then the user can get a message like
 *  /vol/dev/rdsk/c0t6d0/solaris_2_5_sparc/s5: Device busy
 * when they try to eject "cdrom0", but "s0" (e.g.) may be the only busy
 * slice
 *
 * return B_TRUE iff we printed the appropriate error message, else
 * return B_FALSE (and caller will print error message itself)
 */
static boolean_t
display_busy(char *path, boolean_t vm_running)
{
    int     errno_save = errno; /* to save errno */
    char        *blk;           /* block name */
    FILE        *fp = NULL;     /* for scanning mnttab */
    struct mnttab   mref;           /* for scanning mnttab */
    struct mnttab   mp;         /* for scanning mnttab */
    boolean_t   res = B_FALSE;      /* return value */
    char        busy_base[MAXPATHLEN];  /* for keeping base dir name */
    uint_t      bblen;          /* busy_base string length */
    char        *cp;            /* for truncating path */


#ifdef  DEBUG
    (void) fprintf(stderr, "display_busy(\"%s\"): entering\n", path);
#endif

    /*
     * get the block pathname.
     * eject_getfullblkname returns NULL or pathname which
     * has length < MAXPATHLEN.
     */
    blk = eject_getfullblkname(path, vm_running);
    if (blk == NULL)
        goto dun;

    /* open mnttab for scanning */
    if ((fp = fopen(MNTTAB, "r")) == NULL) {
        /* can't open mnttab!? -- give up */
        goto dun;
    }

    (void) memset((void *)&mref, '\0', sizeof (struct mnttab));
    mref.mnt_special = blk;
    if (getmntany(fp, &mp, &mref) == 0) {
        /* we found our entry -- we're done */
        goto dun;
    }

    /* perhaps we have a sub-slice (which is what we exist to test for) */

    /* create a base pathname */
    (void) strcpy(busy_base, blk);
    if ((cp = strrchr(busy_base, '/')) == NULL) {
        /* no last slash in pathname!!?? -- give up */
        goto dun;
    }
    *cp = '\0';
    bblen = strlen(busy_base);
    /* bblen = (uint)(cp - busy_base); */

    /* scan for matches */
    rewind(fp);             /* rescan mnttab */
    while (getmntent(fp, &mp) == 0) {
        /*
         * work around problem where '-' in /etc/mnttab for
         * special device turns to NULL which isn't expected
         */
        if (mp.mnt_special == NULL)
            mp.mnt_special = "-";
        if (strncmp(busy_base, mp.mnt_special, bblen) == 0) {
            res = B_TRUE;
            (void) fprintf(stderr, "%s: %s\n", mp.mnt_special,
                strerror(EBUSY));
        }
    }

dun:
    if (fp != NULL) {
        (void) fclose(fp);
    }
#ifdef  DEBUG
    (void) fprintf(stderr, "display_busy: returning %s\n",
        res ? "B_TRUE" : "B_FALSE");
#endif
    errno = errno_save;
    return (res);
}


/*
 * In my experience with removable media drivers so far... the
 * most reliable way to tell if a piece of media is in a drive
 * is simply to open it.  If the open works, there's something there,
 * if it fails, there's not.  We check for two errnos which we
 * want to interpret for the user,  ENOENT and EPERM.  All other
 * errors are considered to be "media isn't there".
 *
 * return B_TRUE if media found, else B_FALSE (XXX: was 0 and -1)
 */
static boolean_t
query(char *name, boolean_t doprint)
{
    int     fd;
    int     rval;           /* FDGETCHANGE return value */
    enum dkio_state state;

    if ((fd = open(name, O_RDONLY|O_NONBLOCK)) < 0) {
        if ((errno == EPERM) || (errno == ENOENT)) {
            if (doprint) {
                perror(name);
            }
        } else {
            if (doprint) {
                (void) fprintf(stderr, gettext(NOT_AVAIL_MSG),
                    name);
            }
        }
        return (B_FALSE);
    }

    rval = 0;
    if (ioctl(fd, FDGETCHANGE, &rval) >= 0) {
        /* hey, it worked, what a deal, it must be a floppy */
        (void) close(fd);
        if (!(rval & FDGC_CURRENT)) {
            if (doprint) {
                (void) fprintf(stderr, gettext(AVAIL_MSG),
                    name);
            }
            return (B_TRUE);
        }
        if (rval & FDGC_CURRENT) {
            if (doprint) {
                (void) fprintf(stderr,  gettext(NOT_AVAIL_MSG),
                    name);
            }
            return (B_FALSE);
        }
    }

again:
    state = DKIO_NONE;
    if (ioctl(fd, DKIOCSTATE, &state) >= 0) {
        /* great, the fancy ioctl is supported. */
        if (state == DKIO_INSERTED) {
            if (doprint) {
                (void) fprintf(stderr, gettext(AVAIL_MSG),
                    name);
            }
            (void) close(fd);
            return (B_TRUE);
        }
        if (state == DKIO_EJECTED) {
            if (doprint) {
                (void) fprintf(stderr,  gettext(NOT_AVAIL_MSG),
                    name);
            }
            (void) close(fd);
            return (B_FALSE);
        }
        /*
         * Silly retry loop.
         */
        (void) sleep(1);
        goto again;
    }
    (void) close(fd);

    /*
     * Ok, we've tried the non-blocking/ioctl route.  The
     * device doesn't support any of our nice ioctls, so
     * we'll just say that if it opens it's there, if it
     * doesn't, it's not.
     */
    if ((fd = open(name, O_RDONLY)) < 0) {
        if (doprint) {
            (void) fprintf(stderr, gettext(NOT_AVAIL_MSG), name);
        }
        return (B_FALSE);
    }

    (void) close(fd);
    if (doprint) {
        (void) fprintf(stderr, gettext(AVAIL_MSG), name);
    }
    return (B_TRUE);    /* success */
}


/*
 * this routine will return the volmgt block name given the volmgt
 *  raw (char spcl) name
 *
 * if anything but a volmgt raw pathname is supplied that pathname will
 *  be returned
 *
 * NOTE: non-null return value will point to static data, overwritten with
 *  each call
 *
 * e.g. names starting with "/vol/r" will be changed to start with "/vol/",
 * and names starting with "vol/dev/r" will be changed to start with
 * "/vol/dev/"
 */
static char *
eject_getfullblkname(char *path, boolean_t vm_running)
{
    char        raw_root[MAXPATHLEN];
    const char  *vm_root;
    static char res_buf[MAXPATHLEN];
    uint_t      raw_root_len;

#ifdef  DEBUG
    (void) fprintf(stderr, "eject_getfullblkname(\"%s\", %s): entering\n",
        path, vm_running ? "B_TRUE" : "B_FALSE");
#endif
    /*
     * try different strategies based on whether or not vold is running
     */
    if (vm_running) {

        /* vold IS running -- look in /vol (or its alternate) */

        /* get vm root dir */
        vm_root = volmgt_root();

        /* get first volmgt root dev directory (and its length) */
        (void) snprintf(raw_root, sizeof (raw_root), "%s/r", vm_root);
        raw_root_len = strlen(raw_root);

        /* see if we have a raw volmgt pathname (e.g. "/vol/r*") */
        if (strncmp(path, raw_root, raw_root_len) == 0) {
            if (snprintf(res_buf, sizeof (res_buf), "%s/%s",
                vm_root, path + raw_root_len) >= sizeof (res_buf)) {
                return (NULL);
            }
            goto dun;       /* found match in /vol */
        }

        /* get second volmgt root dev directory (and its length) */
        (void) snprintf(raw_root, sizeof (raw_root),
            "%s/dev/r", vm_root);
        raw_root_len = strlen(raw_root);

        /* see if we have a raw volmgt pathname (e.g. "/vol/dev/r*") */
        if (strncmp(path, raw_root, raw_root_len) == 0) {
            if (snprintf(res_buf, sizeof (res_buf), "%s/dev/%s",
                vm_root, path + raw_root_len) >= sizeof (res_buf)) {
                return (NULL);
            }
            goto dun;       /* found match in /vol/dev */
        }

    } else {

        /* vold is NOT running -- look in /dev */

        (void) strcpy(raw_root, "/dev/r");
        raw_root_len = strlen(raw_root);
        if (strncmp(path, raw_root, raw_root_len) == 0) {
            if (snprintf(res_buf, sizeof (res_buf), "/dev/%s",
                path + raw_root_len) >= sizeof (res_buf)) {
                return (NULL);
            }
            goto dun;       /* found match in /dev */
        }
    }

    /* no match -- return what we got */
    (void) strcpy(res_buf, path);

dun:
#ifdef  DEBUG
    (void) fprintf(stderr, "eject_getfullblkname: returning %s\n",
        res_buf ? res_buf : "<null ptr>");
#endif
    return (res_buf);
}